Aprender Arduino
1.0.1
更好地瀏覽Wiki：https：//github.com/simplyyan/learldur/wiki/curso
要編程Arduino（帶有C ++），必須使用Arduino IDE。您可以為Windows，Linux和MacOS安裝它：https：//www.arduino.cc/en/software。但是，您可以使用在線編輯器（Web）：https：//create.arduino.cc/editor。 （Web版本只是為了測試，使用本機版本，免費且可為您的系統發出障礙）
; ）結束。//進行的，並且以/*的啟動了多個行評論，並以*/結尾。int ， float ， bool ， char等）聲明，然後是變量的名稱。int numero = 10; for ( int i = 0 ; i < 10 ; i++) {
// Bloco de código a ser repetido
} void minhaFuncao () {
// Bloco de código da função
}delay(1000);等待1秒鐘，然後繼續執行代碼。 void setup () {
// Configurações iniciais, como inicialização de pinos
}
void loop () {
// Código que é executado repetidamente
}#include <Wire.h>使用允許I2C通信的線庫。INPUT ）或輸出（ OUTPUT ）。Serial.begin(9600);它以9600 bps的速度開始串行通信。if的條件不正確，則執行代碼塊。 int valor = 5 ;
if (valor > 0 ) {
// Executa se valor for maior que zero
} else if (valor == 0 ) {
// Executa se valor for igual a zero
} else {
// Executa se nenhuma das condições anteriores for verdadeira
}+ ， - ， * ， / ， % （模塊）。== != ， > ， < ， >= ， <= 。&& （and）， || （或者） ! （不是）。int meuArray[5]; （創建一個帶有5個元素的整個數組）。String minhaString = "Olá"; 。const int MEU_PINO = 9; 。for ， while ）。 struct Pessoa {
String nome;
int idade;
float altura;
};這些其他概念對於擴大Arduino/C ++編程的知識至關重要。有了更深入的了解這些元素，您可以為更廣泛的應用程序創建更複雜和高效的程序。
當然，我將討論有關Arduino/C ++編程的一些其他主題：
Serial.read()讀取序列端口數據。Serial.write()通過串行端口發送數據。& （and）操作， | （OR）， ^ （XOR）， ~ （不）進行鑽頭操縱。digitalRead和digitalWrite類的功能更快。這些高級主題通過Arduino/c ++擴展了地平線，從而創建了更複雜和深入的項目。實踐和實驗是對這些概念的理解和掌握的基礎。
Arduino由硬件板（例如Arduino Uno）和您在集成開發環境中編寫的編程語言組成）。這是一個簡單的示例，可以點燃連接到數字引腳13的LED：
void setup () {
pinMode ( 13 , OUTPUT);
}
void loop () {
digitalWrite ( 13 , HIGH);
delay ( 1000 );
digitalWrite ( 13 , LOW);
delay ( 1000 );
}該代碼導致連接到引腳13的LED每秒閃爍。
void setup() ：這是您配置程序的初始狀態的地方。在這種情況下，我們將引腳13定義為輸出（輸出）以連接LED。void loop() ：這是連續執行主代碼的地方。它點亮了LED（將引腳13定義為高），等待一秒鐘（延遲1000毫秒），擦除LED（將引腳13定義為低），然後再次等待一秒鐘。 Arduino一次執行setup() ，然後繼續重複執行loop() 。
變量用於存儲在程序執行過程中可以操縱和更改的值。在Arduino中，變量可以存儲不同的數據類型：
整數：商店整數。示例： int ， long ， byte ， unsigned int ，等。
int numero = 10 ;浮點：存儲十進制數字。示例： float ， double 。
float temperatura = 25.5 ;字符：存儲單個字符。示例： char 。
char letra = ' A ' ; int ledPin = 13 ; // Declaração de uma variável do tipo inteiro para armazenar o número do pino do LED
int valorSensor; // Declaração de uma variável inteira para armazenar valores de sensores
void setup () {
pinMode (ledPin, OUTPUT);
}
void loop () {
valorSensor = analogRead (A0); // Lê o valor analógico do pino A0 e armazena na variável valorSensor
if (valorSensor > 500 ) {
digitalWrite (ledPin, HIGH); // Liga o LED se o valor do sensor for maior que 500
} else {
digitalWrite (ledPin, LOW); // Desliga o LED se o valor do sensor for menor ou igual a 500
}
delay ( 100 ); // Aguarda 100 milissegundos antes de fazer a próxima leitura do sensor
}int ledPin = 13; ：聲明一個整數ledPin變量，並用值13初始化它，代表LED引腳。int valorSensor; ：聲明一個可存儲類似讀數的整valorSensor變量。在loop()中，代碼讀取一個連接到模擬引腳A0的傳感器，如果讀取的值大於500，則點亮LED；否則，它會刪除LED。
變量對於在Arduino計劃中存儲和操縱信息至關重要。
在Arduino（以及C ++）中，流控制結構有助於控製程序的行為，具體取決於某些條件或允許重複執行代碼塊。
if-else結構）： if-else結構允許該程序根據條件做出決策。
int sensorValue = analogRead(A0);
if (sensorValue > 500 ) {
// Executa se a condição for verdadeira (valor do sensor maior que 500)
digitalWrite (ledPin, HIGH);
} else {
// Executa se a condição for falsa (valor do sensor menor ou igual a 500)
digitalWrite (ledPin, LOW);
}if (condição) { // código se verdadeiro } else { // código se falso } ：根據括號之間的條件是True還是False執行不同的代碼塊。 while和for ）：循環允許您在條件為TRUE時反复執行代碼代碼（ while ）或特定次數（ for ）。
int contador = 0 ;
while (contador < 5 ) {
// Executa o código dentro do loop enquanto a condição (contador < 5) for verdadeira
contador++;
}while (condição) { // código } ：在條件為真時執行代碼。 for ( int i = 0 ; i < 5 ; i++) {
// Executa o código dentro do loop um número específico de vezes (5 vezes neste caso)
}for (inicialização; condição; incremento) { // código } ：執行代碼塊特定數量的次數，從啟動開始，檢查每個迭代的條件並增加值。這些結構是控製程序的執行流，允許以受控方式重複代碼執行的基礎。
除了數字輸入和輸出外，Arduino還具有模擬輸入引腳和PWM輸出（英式脈衝寬度調製的脈衝寬度調製）。
Arduino的引腳可以讀取模擬值，從而允許讀取可變數量的電位儀，溫度傳感器等。
讀取連接到模擬引腳A0的傳感器的示例：
int sensorValue = analogRead(A0); // Lê o valor analógico do pino A0 analogRead()的結果範圍為0到1023，代表模擬引腳中從0V到5V的間隔。
PWM引腳允許模擬通過脈衝寬度調製控制平均張力的模擬輸出。
PWM輸出的示例用於控制LED的強度：
int ledPin = 9 ; // Pino PWM para controle do LED
void setup () {
pinMode (ledPin, OUTPUT);
}
void loop () {
// Define o brilho do LED com um valor entre 0 (apagado) e 255 (brilho máximo)
analogWrite (ledPin, 127 ); // Define o LED com 50% de brilho
delay ( 1000 );
analogWrite (ledPin, 255 ); // Define o LED com 100% de brilho
delay ( 1000 );
} analogWrite()允許您調整LED的光澤或發動機的速度，從而在指定的引腳中產生PWM信號。
這些PWM模擬輸入功能擴展了Arduino與需要可變值（例如燈，發動機和傳感器）的組件相互作用的可能性。
這些功能使您可以在可重複使用的塊中組織代碼，從而促進對程序的理解和維護。在Arduino中，您可以創建自己的功能來執行特定的任務。
// Declaração da função
tipo_retorno nome_da_funcao (tipo_parametro parametro1, tipo_parametro parametro2) {
// Corpo da função
// Código a ser executado
return valor_de_retorno; // Opcional, se a função tiver um valor de retorno
}
// Exemplo de função que retorna a soma de dois inteiros
int soma ( int a, int b) {
int resultado = a + b;
return resultado;
}tipo_retorno ：這是函數將返回的數據類型（如果函數不返回任何值，則可能是void ）。nome_da_funcao ：它是稍後撥打的函數的名稱。tipo_parametro parametro1, tipo_parametro parametro2 ：這些是函數可以接收的參數。它們是可選的。return valor_de_retorno ：根據tipo_retorno中指定的類型返回值。 int ledPin = 13 ;
void setup () {
pinMode (ledPin, OUTPUT);
}
void loop () {
// Chamando a função piscarLed() para fazer o LED piscar três vezes
for ( int i = 0 ; i < 3 ; i++) {
piscarLed ();
}
delay ( 1000 );
}
// Definição da função piscarLed()
void piscarLed () {
digitalWrite (ledPin, HIGH);
delay ( 500 );
digitalWrite (ledPin, LOW);
delay ( 500 );
}在此示例中，創建了piscarLed()函數以閃爍連接到引腳13的LED。該函數在loop()內部調用了3次，越來越多地將LED驅動到循環for 。
功能通過使其更可讀性並促進代碼重用特定任務來幫助組織代碼。
Arduino中的庫是一組規定的代碼，可以將其合併到其項目中以提供特定功能。它們簡化了開發，允許僅使用幾行代碼使用複雜的功能。
Arduino中有兩個主要類別的庫：
它們是與Arduino IDE集成的庫，並提供了與引腳相互作用，進行簡單數學計算，操縱字符串等的基本功能。
標準庫包容的示例：
# include < Servo.h > // Inclusão da biblioteca Servo para controlar motores 它們是由社區或第三方開發的圖書館，以提供更高級的功能，例如特定的傳感器控制，與顯示，通信協議等。
外部庫包容的示例：
# include < LiquidCrystal.h > // Inclusão da biblioteca LiquidCrystal para controlar displays LCD 庫包含：在代碼開頭，使用#include指令，然後使用您要使用的庫名稱。
啟動和使用：在包含庫之後，可以初始化對象，使用庫中其餘代碼的庫中可用的功能和類。
使用外部庫的示例（在這種情況下，庫Servo控制引擎）：
# include < Servo.h >
Servo meuMotor; // Declaração de um objeto do tipo Servo
void setup () {
meuMotor. attach ( 9 ); // Define o pino 9 como controle para o motor
}
void loop () {
meuMotor. write ( 90 ); // Move o motor para a posição 90 graus
delay ( 1000 );
meuMotor. write ( 0 ); // Move o motor para a posição 0 graus
delay ( 1000 );
}在此示例中， Servo庫用於控制連接到引腳9的引腳的位置。
使用庫時，重要的是要諮詢提供的文檔以了解可用功能以及如何正確使用它們。
為了檢測是否在Arduino項目上單擊一個按鈕，您可以使用稱為“ debunch”的技術來處理在按下物理按鈕時可能發生的讀取波動（快速振盪）。
這是一個簡單的示例，說明如何檢查按鈕是否已單擊：
const int botaoPin = 2 ; // Pino digital conectado ao botão
int estadoBotaoAnterior = HIGH; // Estado anterior do botão, começa como HIGH (não pressionado)
long ultimoTempoDebounce = 0 ; // Último tempo que a leitura do botão foi atualizada
long intervaloDebounce = 50 ; // Intervalo de debounce em milissegundos
void setup () {
pinMode (botaoPin, INPUT);
Serial. begin ( 9600 ); // Inicia a comunicação serial para visualização dos resultados
}
void loop () {
int leituraBotao = digitalRead (botaoPin); // Lê o estado atual do botão
if (leituraBotao != estadoBotaoAnterior) {
ultimoTempoDebounce = millis (); // Atualiza o tempo do debounce
if (( millis () - ultimoTempoDebounce) > intervaloDebounce) {
if (leituraBotao == LOW) {
Serial. println ( " Botão pressionado! " );
// Faça o que desejar quando o botão for pressionado
}
}
}
estadoBotaoAnterior = leituraBotao; // Atualiza o estado anterior do botão
}該代碼使用digitalRead()函數來驗證連接到引腳2的按鈕的狀態（您可以根據連接更改引腳號）。在按下按鈕時，實現了Debush技術以避免虛假讀數。
基本上，該代碼驗證按鈕狀態是否發生了變化，忽略按下按鈕時可能發生的快速波動。如果按下按鈕並進行debush的間隔通過，則消息“按下按鈕！”將顯示在串行顯示器上。
您可以在if (leituraBotao == LOW)中替換代碼，以在按下按鈕時執行所需的操作。
請記住，請始終將上拉或下拉電阻連接到按鈕，以確保一致的讀數（取決於所使用的按鈕類型）。
這是一個更簡單的示例，可以檢測到按下按鈕時：
const int botaoPin = 2 ; // Pino digital conectado ao botão
void setup () {
pinMode (botaoPin, INPUT_PULLUP); // Define o pino do botão como entrada com resistor interno pull-up
Serial. begin ( 9600 ); // Inicia a comunicação serial para visualização dos resultados
}
void loop () {
if ( digitalRead (botaoPin) == LOW) {
Serial. println ( " Botão pressionado! " );
// Faça o que desejar quando o botão for pressionado
delay ( 250 ); // Adiciona um pequeno atraso para evitar leituras múltiplas
}
}在此示例中，按鈕引腳被配置為INPUT_PULLUP ，它在內部激活引腳上的上拉電阻。這樣，按下按鈕時，引腳LOW ，因為輸入通過按鈕連接到GND。
在loop()中，代碼檢查按鈕是否按下（ LOW讀數）。如果按下按鈕，它將顯示“按下按鈕！”在串行顯示器上。 delay(250)添加了一個小延遲，以避免按下時多個按鈕讀數。
這是一種更簡單，更簡單的方法，可以檢測Arduino中按鈕的單擊。
當然，我將教您如何使用中斷來檢測何時按下按鈕到Arduino。使用中斷使Arduino可以中斷程序的正常流程並在發生引腳移動時執行特定功能，這對於檢測諸如按下按鈕之類的事件很有用。
但是，並非所有的Arduino引腳都支持中斷。例如，在Arduino Uno中，PIN 2和3可用於中斷。這是如何使用中斷來檢測引腳2上按鈕的按下的示例：
const int botaoPin = 2 ; // Pino digital conectado ao botão
void setup () {
pinMode (botaoPin, INPUT_PULLUP); // Define o pino do botão como entrada com resistor interno pull-up
attachInterrupt ( digitalPinToInterrupt (botaoPin), botaoPressionado, CHANGE); // Configura a interrupção
Serial. begin ( 9600 ); // Inicia a comunicação serial para visualização dos resultados
}
void loop () {
// Seu código principal aqui
}
void botaoPressionado () {
if ( digitalRead (botaoPin) == LOW) {
Serial. println ( " Botão pressionado! " );
// Faça o que desejar quando o botão for pressionado
}
}在此示例中， attachInterrupt()用於在引腳2（ botaoPin ）上配置中斷。只要按下按鈕或鬆動（ CHANGE ），即每當引腳2的狀態發生更改時，將調用botaoPressionado() 。在botaoPressionado()中，如果按下按鈕讀取PIN的狀態，則可以驗證。
請記住，在使用中斷時，重要的是要將動作在中斷功能中迅速而快，因為它們可以影響主程序的行為。
此方法可能對於需要檢測到直接狀態更改的情況下的按鈕輸入可能很有用，但是必須確保正確連接並配置按鈕以避免可能發出虛假中斷的波動或噪聲，這一點很重要。
我明白！讓我們繼續。
脈衝寬度（PWM）調製是一種用於模擬數字引腳中模擬信號的技術。在Arduino中，一些銷釘具有PWM容量，可以更順暢地控制LED的強度或電動機的速度。
const int ledPin = 9 ; // Pino PWM para controle do LED
void setup () {
pinMode (ledPin, OUTPUT);
}
void loop () {
for ( int brilho = 0 ; brilho <= 255 ; brilho++) {
analogWrite (ledPin, brilho); // Define o brilho do LED com um valor entre 0 e 255
delay ( 10 ); // Pequeno atraso para visualizar a mudança de brilho
}
for ( int brilho = 255 ; brilho >= 0 ; brilho--) {
analogWrite (ledPin, brilho); // Define o brilho do LED com um valor entre 0 e 255
delay ( 10 ); // Pequeno atraso para visualizar a mudança de brilho
}
}該代碼使用analogWrite()將LED光滑連接到引腳9，從而改變並降低LED強度。亮度值範圍從0（LED刪除）到255（最大光澤）。
PWM通常用於控制LED燈，發動機速度以及需要強度或速度控制的其他設備。
嘗試修改光澤和延遲的值（ delay() ），以觀察到LED的不同亮度過渡效果。
模擬傳感器提供可變信息，例如溫度，亮度，濕度等。它們通常在連續範圍內產生值，與僅提供離散值的數字傳感器（如打開/關閉）不同。
在此示例中，我們將使用電位計，即通用類型的模擬傳感器類型。
const int potPin = A0; // Pino analógico conectado ao potenciômetro
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
int valorPot = analogRead (potPin); // Lê o valor analógico do potenciômetro
Serial. print ( " Valor do Potenciômetro: " );
Serial. println (valorPot); // Mostra o valor lido do potenciômetro no Monitor Serial
delay ( 500 ); // Pequeno atraso para evitar leituras muito rápidas
}在此示例中，電位計連接到Arduino模擬引腳。 analogRead()函數讀取電位計的模擬值並在串行顯示器上打印。該值範圍為0到1023，對應於可以映射到其他數量的一系列值，例如角度，亮度等。
您可以連接不同的模擬傳感器，並根據需要調整每個特定傳感器的代碼來嘗試讀取。
我們涵蓋了模擬傳感器的基本方面。如果您對特定的傳感器感興趣或想要有關使用不同類型的傳感器的更多詳細信息，請警告我。
串行通信是在Arduino和其他設備之間傳輸數據的一種方式，例如計算機，其他Arduines，傳感器或外圍模塊。 Arduino串行端口用於此端口，允許通過串行通信渠道交換信息。
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial a uma taxa de 9600 bauds por segundo
}
void loop () {
// Seu código aqui
} Serial.begin(9600)以每秒9600波的速度開始Arduino和計算機（或其他設備）之間的串行通信。此速率（波特率）指定了串行通信的速度。
void setup () {
Serial. begin ( 9600 );
}
void loop () {
int valorSensor = analogRead (A0); // Lê um valor do sensor (por exemplo)
Serial. print ( " Valor do Sensor: " );
Serial. println (valorSensor); // Envia o valor lido do sensor para o Monitor Serial
delay ( 1000 ); // Pequeno atraso para espaçar as leituras
} Serial.print()用於將數據發送到Arduino IDE串行顯示器。 Serial.println()在消息後發送一條新線路，從而促進了串行顯示器上的數據讀數。
void setup () {
Serial. begin ( 9600 );
}
void loop () {
if (Serial. available () > 0 ) {
char dadoRecebido = Serial. read (); // Lê um byte recebido pela comunicação serial
Serial. print ( " Dado Recebido: " );
Serial. println (dadoRecebido); // Mostra o byte recebido no Monitor Serial
}
} Serial.available()檢查是否有數據可在串行端口中讀取。 Serial.read()讀取一個串行端口字節，並將其存儲在dadoRecebido變量中，然後將其顯示在串行監視器上。
串行通信是清除，與其他設備通信以及與環境交互的強大工具。它可用於發送和接收數據，從而促進項目開發和測試。
LCD水晶顯示（LCD）顯示用於顯示文本信息或圖形。借助Arduino，您可以控制LCD顯示器以顯示消息，傳感器值或項目的任何其他有用信息。
在此示例中，我正在考慮使用HD44780控制器的LCD 16x2顯示器（每2行16個字符），這是最常見的。
# include < LiquidCrystal.h >
// Pinos do Arduino conectados ao display LCD
const int rs = 12 , en = 11 , d4 = 5 , d5 = 4 , d6 = 3 , d7 = 2 ;
LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Inicializa o objeto LCD
void setup () {
lcd. begin ( 16 , 2 ); // Inicia o display LCD com 16 colunas e 2 linhas
lcd. print ( " Hello, Arduino! " ); // Escreve uma mensagem no display
}
void loop () {
// Seu código aqui
}在此示例中， LiquidCrystal.h庫用於控制LCD顯示。定義了連接到顯示引腳的Arduino引腳，然後使用這些銷釘初始化LiquidCrystal對象。
lcd.begin(16, 2)用16列和2行初始化顯示。然後lcd.print("Hello, Arduino!")寫出消息“你好，arduino！”在顯示屏上。
請確保根據LCD和Arduino顯示器之間的物理連接來調整引腳編號。
使用此基本示例，您可以開始在LCD顯示器上顯示信息。您還可以探索許多其他功能，例如移動光標，清潔顯示屏，以特定位置的寫作等。
RTC模塊是一種設備，即使關閉，Arduino也可以維持時間控制。它提供有關小時，分鐘，秒，每日和年份的信息，並且在需要時間準確性的項目中很有用。
在此示例中，使用RTC DS3231模塊，該模塊被廣泛使用，因為它是需要的，並且能耗低。
您將需要RTClib庫，該庫有助於與RTC模塊進行通信。首先，將此庫安裝在Arduino IDE上（ Sketch > Include Library > Manage Libraries並蒐索RTClib ）。安裝後，您可以使用以下代碼：
# include < Wire.h >
# include < RTClib.h >
RTC_DS3231 rtc; // Inicializa o objeto RTC
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
if (!rtc. begin ()) {
Serial. println ( " Não foi possível encontrar o RTC! " );
while ( 1 );
}
if (rtc. lostPower ()) {
Serial. println ( " RTC perdeu a hora! Recuperando a hora atual... " );
rtc. adjust ( DateTime ( F (__DATE__), F (__TIME__)));
}
}
void loop () {
DateTime now = rtc. now (); // Obtém a hora atual do RTC
Serial. print (now. year (), DEC);
Serial. print ( ' / ' );
Serial. print (now. month (), DEC);
Serial. print ( ' / ' );
Serial. print (now. day (), DEC);
Serial. print ( " " );
Serial. print (now. hour (), DEC);
Serial. print ( ' : ' );
Serial. print (now. minute (), DEC);
Serial. print ( ' : ' );
Serial. print (now. second (), DEC);
Serial. println ();
delay ( 1000 ); // Aguarda um segundo
}該代碼使用RTClib庫，初始化RTC_DS3231對象並將其連接到RTC DS3231模塊。在setup()函數中，可以驗證是否找到RTC模塊，如果能量丟失，則在當前系統時間內調整RTC。
在循環loop()中，代碼獲取當前的RTC時間並將其顯示在串行顯示器上。
確保正確將RTC模塊正確連接到Arduino（通常使用SDA和SCL引腳進行I2C通信），並根據需要更改代碼以適應其配置。
const int temperaturaPin = A0; // Pino analógico conectado ao sensor
float temperatura;
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
int leitura = analogRead (temperaturaPin); // Lê o valor analógico do sensor
temperatura = (leitura * 0.48875855327 ) - 50.0 ; // Converte para temperatura (fórmula específica para o LM35)
Serial. print ( " Temperatura: " );
Serial. print (temperatura);
Serial. println ( " °C " );
delay ( 1000 ); // Atraso para espaçar as leituras
} const int pinSensorGas = A0; // Pino analógico conectado ao sensor de gás
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
int valorSensor = analogRead (pinSensorGas); // Lê o valor analógico do sensor
Serial. print ( " Valor do sensor de gás: " );
Serial. println (valorSensor);
delay ( 1000 ); // Atraso para espaçar as leituras
} const int pinLeituraForca = A0; // Pino analógico conectado ao sensor de força
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
int valorForca = analogRead (pinLeituraForca); // Lê o valor analógico do sensor de força
Serial. print ( " Valor de força: " );
Serial. println (valorForca);
delay ( 1000 ); // Atraso para espaçar as leituras
}請記住，每個傳感器都有不同形式的連接和閱讀形式，並且轉換公式可能會有所不同。重要的是要諮詢每個傳感器的特定數據表，以了解對數據的正確解釋。
const int pinLDR = A0; // Pino analógico conectado ao LDR
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
int valorLuminosidade = analogRead (pinLDR); // Lê o valor analógico do sensor LDR
Serial. print ( " Valor de luminosidade: " );
Serial. println (valorLuminosidade);
delay ( 1000 ); // Atraso para espaçar as leituras
}這是使用的基本示例：
const int trigPin = 9 ; // Pino conectado ao pino TRIG do sensor
const int echoPin = 10 ; // Pino conectado ao pino ECHO do sensor
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
pinMode (trigPin, OUTPUT);
pinMode (echoPin, INPUT);
}
void loop () {
long duracao, distancia;
digitalWrite (trigPin, LOW);
delayMicroseconds ( 2 );
digitalWrite (trigPin, HIGH);
delayMicroseconds ( 10 );
digitalWrite (trigPin, LOW);
duracao = pulseIn (echoPin, HIGH);
distancia = (duracao * 0.0343 ) / 2 ; // Converte o tempo em distância (cm)
Serial. print ( " Distancia: " );
Serial. print (distancia);
Serial. println ( " cm " );
delay ( 1000 ); // Atraso para espaçar as leituras
} const int pinPIR = 2 ; // Pino digital conectado ao sensor PIR
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
pinMode (pinPIR, INPUT);
}
void loop () {
int movimento = digitalRead (pinPIR); // Lê o sensor de movimento
if (movimento == HIGH) {
Serial. println ( " Movimento detectado! " );
} else {
Serial. println ( " Nenhum movimento detectado. " );
}
delay ( 1000 ); // Atraso para espaçar as leituras
}這些只是如何開始閱讀Arduino中不同類型的傳感器的基本示例。每個傳感器具有獨特的特徵，可能需要特定的庫或校準方法。經驗這些示例並根據您的特定設計進行適應。
遠程紅外控件（IR）是用於以電子方式控制電視，音頻系統，空調等設備的設備。他們將調製的紅外脈衝脈衝帶有每個功能的特定代碼（關閉，關閉，更改通道等）的特定代碼，以將其控製到它們正在控制的設備。
當紅外線在紅外頻率範圍內操作時，IR符號是看不見的。當我們按下遙控器上的按鈕時，內部IR LED會發出一個紅外信號，該信號編碼包含有關按下功能的信息。設備上的接收器IR接收此信號，解碼並執行關聯的函數。
要使用Arduino與遙控器進行交互，我們通常使用IR接收模塊，例如IR KY-022模塊，該模塊具有接收器和稱為“ Inremote.H”的庫。該庫允許Arduino接收和解碼IR信號，使您可以在按下按鈕到遙控器時執行特定的操作。
這是如何使用IR接收器接收和打印按下按鈕的代碼的示例：
# include < IRremote.h >
int receptorIR = 11 ; // Pino do receptor IR
IRrecv irrecv (receptorIR);
decode_results resultadosIR;
void setup () {
Serial. begin ( 9600 );
irrecv. enableIRIn (); // Inicia o receptor IR
}
void loop () {
if (irrecv. decode (&resultadosIR)) {
Serial. println (resultadosIR. value , HEX); // Imprime o código IR
irrecv. resume (); // Reinicia o receptor IR para o próximo código
}
}在此示例中，我們使用“ iremote.h”庫。該代碼捕獲了連接到引腳11的接收器收到的信號IR，並在Arduino串行顯示器上顯示IR代碼值。
這使您可以理解遙控器上按下按鈕的代碼，並使用這些代碼觸發項目中的不同操作。
如果您需要有關遙控器使用的更多詳細信息，請與Arduino一起使用或有特定的問題，我可以提供幫助！
示波器是一種用於可視化圖表上電波形狀的設備，顯示電壓隨時間變化。它是用於分析電子電路的寶貴工具，工程師和技術人員經常使用診斷問題並進行準確的測量。
要使用Arduino和圖形顯示（例如OLED或LCD顯示）創建簡單的示波器，您可以將圖形庫（例如“ Adafruit SSD1306”）用於OLED顯示器。但是，值得注意的是，由於更新速率，分辨率和其他硬件限制，該模擬可能與實際示波器相比具有限制。
這是使用OLED顯示的基本示例：
# include < Adafruit_GFX.h >
# include < Adafruit_SSD1306.h >
# define SCREEN_WIDTH 128 // Largura do display OLED em pixels
# define SCREEN_HEIGHT 64 // Altura do display OLED em pixels
Adafruit_SSD1306 display (SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, - 1 );
void setup () {
Serial. begin ( 9600 );
if (!display. begin (SSD1306_SWITCHCAPVCC, 0x3C )) {
Serial. println ( F ( " Falha ao iniciar o display SSD1306 " ));
for (;;);
}
display. display ();
delay ( 2000 ); // Aguarda por 2 segundos antes de iniciar a exibição
display. clearDisplay ();
display. setTextColor (SSD1306_WHITE);
}
void loop () {
for ( int x = 0 ; x < SCREEN_WIDTH; x++) {
int y = analogRead (A0) * SCREEN_HEIGHT / 1023 ;
display. drawPixel (x, y, SSD1306_WHITE);
display. display ();
display. drawPixel (x, y, SSD1306_BLACK); // Apaga o pixel para mover o traço
delay ( 5 ); // Ajusta a velocidade de atualização
}
}此示例捕獲了模擬引腳（A0）的讀數，並在OLED顯示屏上繪製一個簡單的波形，根據模擬讀數改變了點的高度。但是，與實際示波器相比，該模擬非常基本，準確性和功能可能受到限制。
如果您正在尋找更高級的模擬，或者您對使用Arduino示波器有具體的疑問，請告訴我以提供更多信息或詳細示例。
在此示例中，我們將創建一個計時器，該計時器以自初始化，以測量時間。我們將使用millis()函數來計算自程序開始以來經過的毫秒。
unsigned long tempoInicial = 0 ;
void setup () {
Serial. begin ( 9600 );
tempoInicial = millis (); // Marca o tempo inicial
}
void loop () {
unsigned long tempoAtual = millis (); // Tempo atual em milissegundos
unsigned long tempoDecorrido = tempoAtual - tempoInicial; // Calcula o tempo decorrido
Serial. print ( " Tempo decorrido (ms): " );
Serial. println (tempoDecorrido);
delay ( 1000 ); // Atraso de 1 segundo entre leituras
}此代碼使用millis()函數在程序開頭啟動時間。在主循環中，它從開始時測量時間，並每秒在串行顯示器上顯示它。
重要的是要注意， millis()函數具有時間限制，在連續操作大約50天后，它將返回到零。如果您需要測量更長的時間間隔，則可能需要其他其他技術或硬件。
這是如何使用Arduino創建計時器的一個基本示例。根據您的特定設計，您可以添加按鈕以啟動，暫停並重新啟動計時器，或創建更複雜的顯示器以顯示經過的時間。
鹼性電池：它們很常見，可訪問且具有標準尺寸，例如AA，AAA，C和D。它們的壽命很好，很方便，但不可充電。
可重新加載的電池（NIMH，NICD）：它們可以多次充電，但與鹼性相比，容量往往較小。
鋰離子電池（鋰離子或Lipo）：它們具有較高的能量密度，很輕，用於智能手機，筆記本電腦和無人機。有特定的模塊可以將Lipo電池與Arduino連接。
鉛酸電池：它們較重，用於高電流應用，例如車輛和電源備用系統。由於其重量和尺寸，在Arduino項目中不太常見。
要用電池餵養Arduino，您可以使用電動門或VIN引腳連接器，通常接受7-12V電壓範圍。根據Arduino型號，可以直接用9V電池饋電或使用較大的電池（例如Lipo包），帶有電壓調節器（例如LM7805）來提供恆定的電壓。
電壓：檢查Arduino所需的電壓，並使用兼容電池。有些Arduines比其他Arduines接受更大的電壓範圍。
容量：考慮電池容量（MAH或AH），以確定可以為您的項目提供多長時間。消耗大量能量的項目可以快速排放容量較小的電池。
連接器和調節器：有時可能需要電壓連接器或調節器來使電池輸出適應Arduino的需求。
充電：如果您使用的是可充電電池，請確保使用正確的充電器並遵循製造商的安全說明以避免損壞。
始終檢查Arduino和電池的規格，以確保安全和正確的連接。如果您有特定的電池類型或需要有關如何與Arduino一起使用電池的更多信息，我可以提供幫助！
DC（直流）發動機：這些是簡單且通用的發動機，並且可以根據功率的極性向兩個方向旋轉。可以使用發動機驅動器或H輕鬆控制它們。
步進電動機：以謹慎的步驟移動，可以精確控制位置和速度。它們非常適合精確定位，但與DC發動機相比，控制可能更複雜。
伺服電機：這些是用於以一定角度進行精確定位的位置反饋引擎。它們通常用於機器人臂等精確機制。
為了控制Arduino發動機，通常使用發動機驅動器或控制模塊（例如H橋）或特定的盾牌（例如Adafruit或L298N）。這些組件有助於提供必要的電流和控制引擎轉向和速度。
這是如何使用L298N模塊控制直流引擎的基本示例：
// Exemplo de controle de motor DC com módulo L298N
int enablePin = 9 ; // Pino de habilitação do motor
int in1 = 8 ; // Pino de controle 1
int in2 = 7 ; // Pino de controle 2
void setup () {
pinMode (enablePin, OUTPUT);
pinMode (in1, OUTPUT);
pinMode (in2, OUTPUT);
}
void loop () {
// Gira o motor para frente por 2 segundos
digitalWrite (in1, HIGH);
digitalWrite (in2, LOW);
analogWrite (enablePin, 200 ); // Define a velocidade do motor (0 a 255)
delay ( 2000 );
// Para o motor por 1 segundo
analogWrite (enablePin, 0 ); // Desliga o motor
delay ( 1000 );
}在此示例中，使用連接到Arduino控制引腳的L298N模塊。該代碼使發動機向前旋轉2秒鐘，持續1秒鐘，然後重複週期。
根據引擎類型，可能有必要調整控制邏輯，功率方法和其他組件。始終諮詢引擎和控制組件的數據表，以安全有效使用。
如果您有特定的引擎類型或需要有關如何控制Arduino發動機的更多信息，我可以提供幫助！
傾斜傳感器（也稱為坡度或傾斜開關傳感器）是檢測傾斜或位置變化的設備。當傳感器位置達到一定角度時，它們通常會驅動內部開關，改變其輸出狀態。
坡度傳感器的類型不同，但最簡單的是汞開關之一，該開關由帶有觸點引腳和少量汞的膠囊組成。當以特定角度傾斜時，汞移動並與銷釘接觸，關閉或打開電路。
也有基於坡度的彈簧尺度或基於固態的斜率傳感器，可檢測方向變化。
使用Arduino使用簡單坡度傳感器的一個示例涉及使用數字引腳的基本狀態閱讀電路（或傾斜）。
對於開關類型傾斜傳感器（例如傾斜開關），我們可以創建一個簡單的代碼來檢測傳感器何時傾斜：
const int sensorPin = 2 ; // Pino digital conectado ao sensor de inclinação
void setup () {
Serial. begin ( 9600 );
pinMode (sensorPin, INPUT);
}
void loop () {
int estadoSensor = digitalRead (sensorPin);
if (estadoSensor == HIGH) {
Serial. println ( " O sensor está inclinado! " );
} else {
Serial. println ( " O sensor está na posição normal. " );
}
delay ( 1000 ); // Atraso para espaçar as leituras
}在此示例中，坡度傳感器連接到Arduino的數字引腳2。它會連續檢查傳感器狀態，如果檢測到斜坡，則在串行監視器上顯示消息，表明傳感器已傾斜。
重要的是要記住，靈敏度和準確性可能會根據所使用的斜率傳感器的類型而有所不同。
如果您需要有關特定類型的坡度傳感器或有其他問題的更多信息，我可以提供幫助！
傾斜傳感器（也稱為坡度或傾斜開關傳感器）是檢測傾斜或位置變化的設備。當傳感器位置達到一定角度時，它們通常會驅動內部開關，改變其輸出狀態。
坡度傳感器的類型不同，但最簡單的是汞開關之一，該開關由帶有觸點引腳和少量汞的膠囊組成。當以特定角度傾斜時，汞移動並與銷釘接觸，關閉或打開電路。
也有基於坡度的彈簧尺度或基於固態的斜率傳感器，可檢測方向變化。
使用Arduino使用簡單坡度傳感器的一個示例涉及使用數字引腳的基本狀態閱讀電路（或傾斜）。
對於開關類型傾斜傳感器（例如傾斜開關），我們可以創建一個簡單的代碼來檢測傳感器何時傾斜：
const int sensorPin = 2 ; // Pino digital conectado ao sensor de inclinação
void setup () {
Serial. begin ( 9600 );
pinMode (sensorPin, INPUT);
}
void loop () {
int estadoSensor = digitalRead (sensorPin);
if (estadoSensor == HIGH) {
Serial. println ( " O sensor está inclinado! " );
} else {
Serial. println ( " O sensor está na posição normal. " );
}
delay ( 1000 ); // Atraso para espaçar as leituras
}在此示例中，坡度傳感器連接到Arduino的數字引腳2。它會連續檢查傳感器狀態，如果檢測到斜坡，則在串行監視器上顯示消息，表明傳感器已傾斜。
重要的是要記住，靈敏度和準確性可能會根據所使用的斜率傳感器的類型而有所不同。
傾斜傳感器（也稱為傾斜開關）是用於檢測方向或位置變化的設備。它們可以基於機械或固態技術。
要使用坡度傳感器，通常您將傳感器連接到Arduino Pin之一（通常是數字引腳）。使用簡單的傾斜傳感器（例如傾斜開關），您可以使用基本代碼在傾斜時檢測狀態更改：
const int sensorPin = 2 ; // Pino digital conectado ao sensor de inclinação
void setup () {
Serial. begin ( 9600 );
pinMode (sensorPin, INPUT);
}
void loop () {
int estadoSensor = digitalRead (sensorPin);
if (estadoSensor == HIGH) {
Serial. println ( " O sensor está inclinado! " );
} else {
Serial. println ( " O sensor está na posição normal. " );
}
delay ( 1000 ); // Atraso para espaçar as leituras
}在此示例中，坡度傳感器連接到Arduino的數字引腳2。當傳感器傾斜或返回正常位置時，它會連續檢查傳感器狀態並在串行監視器上顯示消息。
坡度傳感器的選擇取決於項目的精度，檢測範圍和特定應用的水平。
如果您有更多疑問或需要有關特定類型的坡度傳感器的信息，我可以提供幫助！
當然，距離傳感器是用於測量傳感器和物體之間距離的設備。 Arduino有幾種類型的距離傳感器，包括HC-SR04超聲傳感器和VL530X激光距離傳感器。
HC-SR04超聲傳感器是用於測量Arduino的最常見和最簡單的傳感器之一。它通過發射超聲波聲波並測量到達物體後返回的時間來起作用。根據往返時間，可以計算距離。
要將HC-SR04傳感器與Arduino一起使用，您需要四個引腳：VCC，GND，Trigger和Echo。
這是用HC-SR04傳感器測量距離的代碼的基本示例：
const int trigPin = 9 ; // Pino de Trigger
const int echoPin = 10 ; // Pino de Echo
void setup () {
Serial. begin ( 9600 );
pinMode (trigPin, OUTPUT);
pinMode (echoPin, INPUT);
}
void loop () {
long duracao, distancia;
digitalWrite (trigPin, LOW);
delayMicroseconds ( 2 );
digitalWrite (trigPin, HIGH);
delayMicroseconds ( 10 );
digitalWrite (trigPin, LOW);
duracao = pulseIn (echoPin, HIGH);
distancia = (duracao * 0.0343 ) / 2 ; // Fórmula para calcular a distância em centímetros
Serial. print ( " Distancia: " );
Serial. print (distancia);
Serial. println ( " cm " );
delay ( 1000 ); // Atraso entre leituras
}該代碼使Arduino通過扳機引腳發送超聲波手腕，並測量Echo Pin中接收到的脈衝持續時間。根據脈衝持續時間，計算以厘米為單位的距離，並在串行顯示器上顯示此距離。
另一個選擇是VL53L0X傳感器，該傳感器使用超聲波傳感器比較準確地測量距離。操作原理相似，但它使用激光束計算距離。
根據項目的測量範圍，準確性和特定要求選擇距離傳感器。這些是開始與Arduino一起使用這些傳感器的簡單示例，還有許多其他功能和可能的配置需要探索！
如果您需要有關某些特定傳感器或有更多問題的更多詳細信息，我可以提供幫助！
水分傳感器是測量空氣或特定環境中濕度水平的設備。在Arduino的背景下，最常見的濕度傳感器之一是土壤水分傳感器，通常用於自動化園藝或植物監測項目。
要使用土壤水分傳感器，您可以將傳感器輸出連接到Arduino的模擬入口並讀取水分值。這是讀取傳感器的模擬值的基本代碼的示例：
int sensorPin = A0; // Pino analógico conectado ao sensor
int umidade; // Variável para armazenar a leitura de umidade
void setup () {
Serial. begin ( 9600 );
}
void loop () {
umidade = analogRead (sensorPin);
Serial. print ( " Umidade do solo: " );
Serial. println (umidade);
delay ( 1000 ); // Atraso entre leituras
}在此代碼中，土壤水分傳感器連接到Arduino模擬引腳。它讀取傳感器的模擬值，並在串行顯示器上打印它們。
如果您需要有關某些特定類型的濕度傳感器或有更多問題的更多詳細信息，我可以提供幫助！
氣體傳感器是用於檢測環境中特定氣體存在的設備。它們在安全系統，空氣質量控制甚至污染監測設備中至關重要。
氣體傳感器使用不同的檢測原理來識別特定的氣體。一些常見的氣體傳感器包括：
紅外氣體傳感器（IR）：使用某些氣體使用紅外光吸收來識別它們。每種氣體在特定波長中吸收光，從而可以精確識別。
催化氣體傳感器：它們基於氣體和催化劑之間的化學反應，以產生電阻的變化，從而檢測出氣體的存在。
電化學氣體傳感器：包含與目標氣體反應的電極，產生與氣體濃度成正比的電流。
MQ-2傳感器是氣體傳感器的常見示例，可以在特定濃度下檢測易燃氣體，煙氣和有毒氣體。
int pinSensor = A0; // Pino analógico conectado ao sensor MQ-2
int valorSensor;
void setup () {
Serial. begin ( 9600 );
}
void loop () {
valorSensor = analogRead (pinSensor);
Serial. print ( " Valor do sensor: " );
Serial. println (valorSensor);
delay ( 1000 ); // Atraso entre leituras
}該基本代碼讀取連接到Arduino模擬引腳的MQ-2傳感器的模擬值，並在串行顯示器上顯示這些值。但是，解釋這些值並將它們與特定氣體的存在相關聯可能需要適當的校準，並對所使用的傳感器有更詳細的了解。
如果您需要有關特定氣體傳感器或有更多疑問的更多信息，我可以提供幫助！
當然，微僕人是小型和輕型發動機，用於需要精確和受控運動的應用。它們通常用於機器人技術，自動化，航空編碼和其他設備項目中，需要控制小機制的位置。
微僕人由發動機，齒輪箱和內部控制電路組成。他們能夠在有限的角度範圍內旋轉（通常從0到180度），從而可以精確控制位置。
微型僕人很容易由Arduino控制。通常，它們連接到PWM（脈衝寬度調製）引腳，以發送確定僕人所需位置的信號。
# include < Servo.h >
Servo meuServo; // Cria um objeto do tipo Servo
int angulo = 0 ; // Variável para armazenar a posição do servo
void setup () {
meuServo. attach ( 9 ); // Conecta o servo ao pino 9
}
void loop () {
for (angulo = 0 ; angulo <= 180 ; angulo += 1 ) { // Varia de 0 a 180 graus
meuServo. write (angulo); // Define a posição do servo
delay ( 15 ); // Atraso para suavizar o movimento
}
for (angulo = 180 ; angulo >= 0 ; angulo -= 1 ) { // Varia de 180 a 0 graus
meuServo. write (angulo); // Define a posição do servo
delay ( 15 ); // Atraso para suavizar o movimento
}
}Servo.h庫簡化了對僕人的控制，允許使用諸如attach() ， write()和writeMicroseconds()之類的功能來控制僕人的位置。如果您需要有關使用Arduino的微僕人或有更多問題的更多信息，我可以提供幫助！
當然，矩陣鍵盤（例如4x4鍵盤）是允許數據輸入Arduino或其他微控制器的設備。 4x4鍵盤由4列矩陣中組織的16個鍵組成。
每個4x4鍵盤鍵是瞬時的開關，並且矩陣中的鍵的佈置使它們可以使用Arduino中的幾個引腳進行有效讀取。基本原理是使用PIN來定義線條和其他引腳的狀態以讀取列的狀態。
要讀取帶有Arduino的4x4鍵盤的鍵，您可以使用“ keypad.h”之類的庫來簡化過程。
首先，通過“草圖”菜單 - >“ inclage Library” - >“管理Liberies ...”並蒐索“鍵盤”，在其Arduino IDE上安裝鍵盤庫（如果未安裝）。
這是一個基本的代碼示例，用於使用鍵盤庫的4x4鍵盤：
# include < Keypad.h >
const byte linhas = 4 ;
const byte colunas = 4 ;
char teclas[linhas][colunas] = {
{ ' 1 ' , ' 2 ' , ' 3 ' , ' A ' },
{ ' 4 ' , ' 5 ' , ' 6 ' , ' B ' },
{ ' 7 ' , ' 8 ' , ' 9 ' , ' C ' },
{ ' * ' , ' 0 ' , ' # ' , ' D ' }
};
byte pinoLinhas[linhas] = { 9 , 8 , 7 , 6 }; // Pinos conectados às linhas
byte pinoColunas[colunas] = { 5 , 4 , 3 , 2 }; // Pinos conectados às colunas
Keypad meuTeclado = Keypad(makeKeymap(teclas), pinoLinhas, pinoColunas, linhas, colunas);
void setup (){
Serial. begin ( 9600 );
}
void loop (){
char tecla = meuTeclado. getKey ();
if (tecla){
Serial. println (tecla);
}
}開關是簡單的電子組件，用於控制電路中電流的流動。它們通常用於打開或關閉電氣設備。
簡單的開關：也稱為聯賽開關，它是最基本的類型。它具有兩個狀態：連接（封閉）和關閉（打開），用於控制單電路。
三向開關：與其他三向開關結合使用，它允許從兩個不同位置轉動設備。
切換開關：它具有可以向上或向下移動以打開或關閉電路的槓桿。
按鈕開關）：按下時會激活並在釋放時返回初始狀態。
蘆葦開關：使用磁場來控制電路。它通常用於需要低消耗開關並禁止外部環境的應用中使用。
開關可以輕鬆地集成到Arduino項目中以控制電流流。例如，可以使用簡單的開關打開或關閉連接到Arduino的任何其他設備。
const int interruptorPin = 2 ; // Pino digital onde o interruptor está conectado
int estadoInterruptor;
void setup () {
Serial. begin ( 9600 );
pinMode (interruptorPin, INPUT);
}
void loop () {
estadoInterruptor = digitalRead (interruptorPin);
if (estadoInterruptor == HIGH) {
Serial. println ( " Interruptor pressionado! " );
// Execute alguma ação quando o interruptor for pressionado
}
delay ( 100 ); // Atraso para evitar leituras falsas
}理解，我將解釋這些組件中的每一個。
邏輯端口是數字電子中的基本電路。他們基於數字信號（0和1）執行基本的邏輯操作（例如和，或，不等等）。
例如，如果高高或B高（或兩個都高），則一兩個端口（A和B）將產生高輸出。
觸發器或觸發器是用於存儲信息位的順序存儲元素。有幾種類型，例如RS，D，JK等。他們有能力存儲狀態（0或1），同時適合有關觸發器類型的類型。
寄存器是用於將數據存儲在數字系統中的觸發器集。根據寄存器設置，他們可以以串行或併行存儲和移動數據。它們通常用於CPU，通信界面和數據處理電路中。
擴展器是擴展系統的I/O（輸入/輸出）容量的組件。它們允許在微控制器或其他設備中有限數量的I/O引腳擴展到大量的引腳。
例如，平行門的擴展器可能會允許幾乎沒有I/O引腳的微控制器的行為，好像您有更多可用的引腳一樣。
繼電器是機電設備，用於借助低功率電路或電壓來控制高功率或高電流。
繼電器由線圈和一組觸點組成。當將電流應用於線圈時，它會生成一個磁場，該磁場觸發了繼電器接觸的開關機構。這允許繼電器打開或關閉單獨的電路。
通用繼電器繼電器：它們是最常見的，可用於各種應用程序。可以在簡單的開關版本（通常打開或正常關閉）或多個觸點版本中找到它們。
固態繼電器-SSRS）：它們沒有運動部件，並且使用半導體設備（通常是跨軸向器或Triacs）進行切換。它們是交替交替切換（AC）並具有高耐用性的理想選擇。
保護繼電器：它們用於保護電路免受超負荷，超值，缺乏相位以及可能損壞電氣系統的其他事件。
繼電器通常與Arduino一起用於控制燈，發動機，電器等高功率設備。它們允許Arduino控制更高的電路，而無需直接連接到高電流設備。
使用Arduino繼電器的繼電器的基本示例：
# define PINO_RELE 8 // Pino do Arduino conectado ao relé
void setup () {
pinMode (PINO_RELE, OUTPUT);
}
void loop () {
digitalWrite (PINO_RELE, HIGH); // Liga o relé
delay ( 1000 ); // Aguarda 1 segundo
digitalWrite (PINO_RELE, LOW); // Desliga o relé
delay ( 1000 ); // Aguarda 1 segundo
}在此示例中，繼電器連接到Arduino Pin 8。代碼每秒打開和關閉中繼，創建一個轉彎週期。
當然，七個細分遮陽板是用於顯示0到9，字母或其他字母數字字符的數字顯示設備。每個數字由以風格的“ 8”配置排列的七個片段（或LED）組成，每個段可以打開或關閉以形成數字或字母。
每個細分市場根據其位置任命，並指定點亮或已刪除的段的特定組合形式的數字或字母。通常，這些段是從“ A” A'g'和一個可選的小數點（'dp'）任命的：
a
---
| |
f| |b
| g |
---
| |
e| |c
| |dp
---
d
要控制一個七個Arduino段顯示，通常需要一個驅動程序或多路復用器，因為僅Arduino就沒有足夠的引腳直接控制所有段。
此外，還顯示了七個常見陰極段（與負面段相關）或陽極段（段為正），並且控制每個段的代碼可能會略有不同。
// Exemplo de ligação de um display de sete segmentos comum catódico ao Arduino
# include < SevSeg.h > // Biblioteca para controlar o display de sete segmentos
SevSeg meuDisplay; // Cria um objeto do tipo SevSeg
void setup () {
byte pinosSegmentos[] = { 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 }; // Pinos conectados aos segmentos a-g
byte pinoPontoDecimal = 10 ; // Pino conectado ao ponto decimal (se aplicável)
meuDisplay. Begin (COMMON_CATHODE, pinosSegmentos, NULL , pinoPontoDecimal); // Inicializa o display
meuDisplay. SetBrightness ( 50 ); // Define o brilho (0-100%)
}
void loop () {
meuDisplay. DisplayString ( " 1234 " ); // Exibe a sequência "1234" no display
delay ( 1000 ); // Atraso de 1 segundo
}在此示例中， SevSeg.h庫用於控制七個段的顯示。它允許顯示數字，字母或其他字符的顯示。
要使用Arduino和七個細分顯示器創建時鐘，您將需要：
# include < Wire.h >
# include < RTClib.h >
# include < SevSeg.h >
RTC_DS1307 rtc;
SevSeg display;
void setup () {
Wire. begin ();
rtc. begin ();
byte segmentPins[] = { 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 }; // Pinos conectados aos segmentos a-g
byte digitPins[] = { 10 , 11 , 12 , 13 }; // Pinos conectados aos dígitos (comum catódico)
display. Begin (COMMON_CATHODE, 4 , segmentPins, digitPins);
display. SetBrightness ( 50 ); // Define o brilho (0-100%)
}
void loop () {
DateTime now = rtc. now ();
int hora = now. hour ();
int minuto = now. minute ();
char horaStr[ 5 ];
sprintf (horaStr, " %02d%02d " , hora, minuto);
display. DisplayString (horaStr); // Exibe a hora e o minuto no display
delay ( 1000 ); // Atraso de 1 segundo
}在此示例中， RTClib庫用於獲取RTC時間，並使用SevSeg庫在七部分顯示器上顯示。
讓我們談談不同類型的電池，包括其特性和應用：
每種電池都有其獨特的特性，其電壓，電壓，尺寸和施用。考慮到必要的電壓和容量，為特定應用選擇適當的電池。
當然，通常稱為“壓電”的壓電元件是一種將機械能轉換為電力的設備，反之亦然。由於其能夠產生能量或充當振動傳感器的能力，它被用於多種應用中。
壓電效應：壓電材料具有機械變形（直接效應）時產生電荷的能力，或者在相反的情況下，當將電荷施加到其上時會發生機械變形（反效應）。
用作傳感器：當用作傳感器時，壓電元件在受到振動或機械壓力時會產生電壓。在觸摸傳感器中探索了此屬性，擊敗探測器等。
用作傳感器：將電壓應用於壓電元件時，它會收縮或擴展，從而產生機械振動。這用於電鍍揚聲器或超聲發電機等設備。
您可以使用帶有Arduino的壓電元件來檢測振動或產生簡單的聲音。例如，要檢測觸摸或節拍，您可以將壓電元件連接到Arduino的模擬引腳。
int pinoPiezo = A0; // Pino analógico conectado ao elemento piezoelétrico
void setup () {
Serial. begin ( 9600 );
}
void loop () {
int leituraPiezo = analogRead (pinoPiezo); // Lê o valor do piezo
Serial. println (leituraPiezo); // Exibe o valor lido no Monitor Serial
delay ( 100 ); // Atraso entre leituras
}該基本代碼讀取連接到arduino模擬引腳的壓電元件檢測到的振動值，並在串行顯示器上顯示這些值。
壓電元素用於多種應用中，包括振動傳感器，警報，揚聲器，超聲發電機等。
對於涉及振動檢測或產生的各種應用，它們簡單，耐用且有效。
當然，我將簡要解釋這些被動組成部分：
液晶顯示器（LCD-液晶顯示屏）是使用液晶的光學特性來顯示文本信息，數字甚至圖形的設備。它們在電子設備上很常見，例如音頻，視頻，測量儀器，手錶等。
像素矩陣： LCD由由液晶形成的像素基質（點）組成。每個像素可以單獨控制以顯示信息。
輕度極化： LCD像素會在將電流施加到它們時會改變光極化。這會導致光線通過或阻塞，從而顯示可見的標準。
要與Arduino一起使用LCD顯示屏，通常使用特定的庫來促進顯示的像素和字符的控制。一個常見的例子是LiquidCrystal庫，它簡化了Arduino和顯示器之間的通信。
遵循一個基本示例，說明如何使用LiquidCrystal庫在LCD顯示器上顯示簡單文本：
# include < LiquidCrystal.h >
// Inicialização do objeto LiquidCrystal
LiquidCrystal lcd ( 12 , 11 , 5 , 4 , 3 , 2 ); // Pinos conectados ao LCD (RS, E, D4, D5, D6, D7)
void setup () {
lcd. begin ( 16 , 2 ); // Inicializa o LCD com 16 colunas e 2 linhas
lcd. print ( " Hello, World! " ); // Exibe o texto no display
}
void loop () {
// Seu código aqui, caso queira atualizar a exibição do LCD continuamente
}當然，我將解釋有關功能生成器和電源的解釋：
函數生成器可用於創建測試信號，以檢查對不同頻率或波形的電路響應。例如，要測試通過過濾器，可以應用一個可變的頻率正弦信號來分析濾波器如何減輕最高頻率。
電源源用於供應電子設備，例如電路原型，電子設備，甚至在組件實驗或測試中提供穩定和受控的能量。例如，在測試電子電路時，可調節電源使您可以改變電壓以在不同條件下檢查電路行為。
晶體管可用於控制通過機器人，風扇或照明控制電路中電動機的電流。
電壓調節器（例如LM7805）可用於在需要穩定功率的電子電路上保持恆定電壓（例如5V）。
在對照電路中，可以使用Optuacoplator將高壓部件的敏感部件（例如微控制器）電氣隔離（例如，電動系統）。
Arduino有不同的藍牙模塊，是HC-05和HC-06最常見的兩個。它們是藍牙的串行模塊，可在Arduino和其他設備之間進行無線通信。
Serial.begin()用於在Arduino中啟動序列通信。Serial.print()和Serial.read()用於在Arduino和藍牙設備之間發送和接收數據。# include < SoftwareSerial.h >
SoftwareSerial bluetooth ( 10 , 11 ); // RX, TX
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial com o computador
bluetooth. begin ( 9600 ); // Inicia a comunicação serial com o módulo Bluetooth
}
void loop () {
if (bluetooth. available ()) {
char received = bluetooth. read ();
Serial. print (received); // Envia o que foi recebido para o monitor serial
}
if (Serial. available ()) {
char toSend = Serial. read ();
bluetooth. print (toSend); // Envia o que foi recebido do computador para o módulo Bluetooth
}
}嘗試在藍牙和Arduino模塊之間建立連接，並從智能手機（使用藍牙終端應用程序）將消息發送到Arduino。將此消息顯示給Arduino串行顯示器。
始終記住要檢查用於確保正確操作並正確連接到Arduino的藍牙模塊規格。
// Definição dos pinos para controle dos motores
const int pinoMotorEsquerda = 5 ;
const int pinoMotorDireita = 6 ;
const int pinoVelocidadeEsquerda = 9 ;
const int pinoVelocidadeDireita = 10 ;
void setup () {
// Define os pinos como saída
pinMode (pinoMotorEsquerda, OUTPUT);
pinMode (pinoMotorDireita, OUTPUT);
pinMode (pinoVelocidadeEsquerda, OUTPUT);
pinMode (pinoVelocidadeDireita, OUTPUT);
}
void loop () {
// Movimento para a frente
moverFrente ();
delay ( 2000 ); // Aguarda por 2 segundos
// Movimento de rotação para a direita
girarDireita ();
delay ( 1000 ); // Aguarda por 1 segundo
// Movimento para trás
moverTras ();
delay ( 2000 ); // Aguarda por 2 segundos
// Movimento de rotação para a esquerda
girarEsquerda ();
delay ( 1000 ); // Aguarda por 1 segundo
}
// Função para mover para a frente
void moverFrente () {
digitalWrite (pinoMotorEsquerda, HIGH);
digitalWrite (pinoMotorDireita, HIGH);
analogWrite (pinoVelocidadeEsquerda, 200 ); // Ajuste a velocidade conforme necessário
analogWrite (pinoVelocidadeDireita, 200 );
}
// Função para mover para trás
void moverTras () {
digitalWrite (pinoMotorEsquerda, LOW);
digitalWrite (pinoMotorDireita, LOW);
analogWrite (pinoVelocidadeEsquerda, 200 ); // Ajuste a velocidade conforme necessário
analogWrite (pinoVelocidadeDireita, 200 );
}
// Função para girar para a direita
void girarDireita () {
digitalWrite (pinoMotorEsquerda, HIGH);
digitalWrite (pinoMotorDireita, LOW);
analogWrite (pinoVelocidadeEsquerda, 200 ); // Ajuste a velocidade conforme necessário
analogWrite (pinoVelocidadeDireita, 200 );
}
// Função para girar para a esquerda
void girarEsquerda () {
digitalWrite (pinoMotorEsquerda, LOW);
digitalWrite (pinoMotorDireita, HIGH);
analogWrite (pinoVelocidadeEsquerda, 200 ); // Ajuste a velocidade conforme necessário
analogWrite (pinoVelocidadeDireita, 200 );
}delay時間決定機器人將執行每個運動的時間。 analogWrite功能調節發動機的速度。這是一個簡單的示例，它的前部向前移動並進行基本旋轉。這是創建功能和可擴展機器人的起點。
通過電阻將LED連接到Arduino引腳：
Conecte o terminal positivo (+) de cada LED a um pino do Arduino e o terminal negativo (-) a um resistor de 220Ω e, em seguida, conecte o outro lado do resistor ao terra (GND) do Arduino.
void setup () {
pinMode ( 12 , OUTPUT); // Configura o LED Vermelho como saída
pinMode ( 11 , OUTPUT); // Configura o LED Amarelo como saída
pinMode ( 10 , OUTPUT); // Configura o LED Verde como saída
}
void loop () {
// Vermelho (STOP)
digitalWrite ( 12 , HIGH);
delay ( 5000 ); // Aguarda 5 segundos
// Amarelo (PREPARE TO GO)
digitalWrite ( 12 , LOW);
digitalWrite ( 11 , HIGH);
delay ( 2000 ); // Aguarda 2 segundos
// Verde (GO)
digitalWrite ( 11 , LOW);
digitalWrite ( 10 , HIGH);
delay ( 5000 ); // Aguarda 5 segundos
// Amarelo piscando (CLEAR THE ROAD)
digitalWrite ( 10 , LOW);
for ( int i = 0 ; i < 5 ; i++) {
digitalWrite ( 11 , HIGH);
delay ( 500 );
digitalWrite ( 11 , LOW);
delay ( 500 );
}
}setup() , configuramos os pinos dos LEDs como saída.loop() controla o funcionamento do semáforo com diferentes delays para cada estado (vermelho, amarelo, verde e amarelo piscando).Conecte os LEDs e execute o código no Arduino para ver o funcionamento do semáforo. Este projeto oferece uma introdução prática aos conceitos de controle de LEDs e temporização com Arduino.
Conecte o sensor PIR ao Arduino da seguinte forma:
int sensorPin = 2 ; // Pino de entrada do sensor PIR
int ledPin = 13 ; // Pino do LED embutido no Arduino
void setup () {
pinMode (sensorPin, INPUT); // Configura o pino do sensor como entrada
pinMode (ledPin, OUTPUT); // Configura o pino do LED como saída
Serial. begin ( 9600 ); // Inicializa a comunicação serial para debug (opcional)
}
void loop () {
int movimento = digitalRead (sensorPin); // Lê o valor do sensor
if (movimento == HIGH) {
digitalWrite (ledPin, HIGH); // Acende o LED se movimento for detectado
Serial. println ( " Movimento Detectado! " ); // Imprime mensagem no monitor serial
delay ( 1000 ); // Aguarda 1 segundo para evitar múltiplas leituras do sensor
} else {
digitalWrite (ledPin, LOW); // Apaga o LED se nenhum movimento for detectado
}
}setup() , configuramos o pino do sensor PIR como entrada e o pino do LED como saída.loop() , lemos o valor do sensor PIR. Se movimento for detectado (o sensor retorna HIGH), acendemos o LED e imprimimos uma mensagem no monitor serial.Após conectar o circuito e carregar o código no Arduino, experimente se movimentar na frente do sensor PIR para ver o LED acender quando detectar movimento. Este projeto é um bom ponto de partida para entender o funcionamento básico dos sensores de movimento com o Arduino.
Conecte o sensor de temperatura LM35 ao Arduino da seguinte maneira:
int sensorPin = A0; // Pino analógico para leitura do sensor
float temperaturaC; // Variável para armazenar a temperatura em graus Celsius
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
int sensorValor = analogRead (sensorPin); // Lê o valor analógico do sensor
temperaturaC = (sensorValor * 5.0 / 1024 ) * 100 ; // Converte o valor para graus Celsius
Serial. print ( " Temperatura: " );
Serial. print (temperaturaC);
Serial. println ( " graus Celsius " );
delay ( 1000 ); // Aguarda 1 segundo antes da próxima leitura
}setup() , iniciamos a comunicação serial para visualizar os dados no monitor serial.loop() , lemos a tensão analógica do sensor, a convertemos em temperatura e a exibimos no monitor serial.Após conectar o circuito e carregar o código no Arduino, abra o Monitor Serial para visualizar a temperatura lida pelo sensor. Este projeto é um exemplo básico de como capturar dados de temperatura com um sensor simples usando o Arduino.
Conecte o display de 7 segmentos ao Arduino da seguinte maneira:
Aqui está um exemplo básico para contar de 0 a 9 no display de 7 segmentos:
// Define os pinos dos segmentos do display de 7 segmentos
int segmentos[] = { 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };
// Números correspondentes aos segmentos para exibir de 0 a 9
int numeros[ 10 ][ 8 ] = {
{ 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 }, // 0
{ 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 }, // 1
// ... (defina os outros números até 9)
};
void setup () {
for ( int i = 0 ; i < 8 ; i++) {
pinMode (segmentos[i], OUTPUT); // Define os pinos como saída
}
}
void loop () {
for ( int num = 0 ; num < 10 ; num++) {
exibirNumero (num);
delay ( 1000 ); // Aguarda 1 segundo antes de exibir o próximo número
}
}
void exibirNumero ( int num) {
for ( int i = 0 ; i < 8 ; i++) {
digitalWrite (segmentos[i], numeros[num][i]); // Exibe o número no display
}
}setup() , configuramos os pinos dos segmentos como saída.loop() , chamamos a função exibirNumero() para mostrar cada número de 0 a 9 no display, aguardando 1 segundo entre cada número.numeros[][] com as combinações corretas para exibir os números de 0 a 9 no seu display.Ao montar o circuito e carregar o código no Arduino, você verá os números de 0 a 9 sendo exibidos sequencialmente no display de 7 segmentos. Este é um projeto introdutório para entender como controlar e exibir números em um display deste tipo.
Conecte o sensor de luz LDR ao Arduino da seguinte maneira:
int sensorPin = A0; // Pino analógico para leitura do sensor de luz
int valorLuz; // Variável para armazenar o valor lido pelo sensor
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
valorLuz = analogRead (sensorPin); // Lê o valor analógico do sensor
Serial. print ( " Valor de Luz: " );
Serial. println (valorLuz); // Exibe o valor lido no monitor serial
delay ( 1000 ); // Aguarda 1 segundo antes da próxima leitura
}setup() , iniciamos a comunicação serial para visualizar os dados no monitor serial.loop() , lemos a intensidade da luz utilizando o sensor LDR e exibimos o valor lido no monitor serial.Após conectar o circuito e carregar o código no Arduino, abra o Monitor Serial para visualizar os valores lidos pelo sensor de luz. Este projeto é uma forma simples de entender como capturar dados de luz com um sensor LDR utilizando o Arduino.
Para criar um projeto simples de controle remoto por infravermelho (IR), utilizaremos um receptor IR junto com um controle remoto comum para enviar comandos para o Arduino. Vou explicar como montar o circuito e fornecer um código básico para este projeto.
Conecte o módulo receptor infravermelho ao Arduino da seguinte maneira:
Para este projeto, é necessário instalar a biblioteca IRremote no Arduino IDE. Siga os passos abaixo para instalar:
Sketch -> Incluir Biblioteca -> Gerenciar Bibliotecas .# include < IRremote.h >
int receptorPin = 11 ; // Pino de conexão do módulo receptor IR
IRrecv receptor (receptorPin);
decode_results comandos;
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial
receptor. enableIRIn (); // Inicializa o receptor IR
}
void loop () {
if (receptor. decode (&comandos)) {
// Exibe o código do botão pressionado no controle remoto
Serial. println (comandos. value , HEX);
receptor. resume (); // Continua a receber sinais IR
}
}setup() , iniciamos a comunicação serial e habilitamos o receptor IR.loop() , verificamos se há sinais infravermelhos recebidos pelo módulo receptor e exibimos o código do botão pressionado no controle remoto no Monitor Serial.Aponte o controle remoto para o módulo receptor infravermelho e pressione os botões. Os códigos dos botões pressionados serão exibidos no Monitor Serial. Este projeto simples demonstra como ler códigos de um controle remoto usando um módulo receptor IR com o Arduino.
Conecte o servo motor e o botão ao Arduino da seguinte maneira:
# include < Servo.h >
Servo meuServo; // Cria um objeto servo para controlar o motor
int angulo = 0 ; // Variável para armazenar a posição do servo
int botaoPin = 2 ; // Pino digital do botão
int botaoEstadoAnterior = LOW; // Estado anterior do botão
void setup () {
meuServo. attach ( 9 ); // Conecta o servo ao pino 9
pinMode (botaoPin, INPUT_PULLUP); // Define o pino do botão como entrada com resistor de pull-up interno
Serial. begin ( 9600 ); // Inicia a comunicação serial
}
void loop () {
int botaoEstado = digitalRead (botaoPin); // Lê o estado atual do botão
if (botaoEstado != botaoEstadoAnterior && botaoEstado == HIGH) {
// Se o botão foi pressionado, altera a posição do servo
if (angulo == 0 ) {
angulo = 180 ; // Muda para 180 graus
} else {
angulo = 0 ; // Muda para 0 graus
}
meuServo. write (angulo); // Move o servo para o ângulo especificado
Serial. print ( " Posicao do Servo: " );
Serial. println (angulo);
}
botaoEstadoAnterior = botaoEstado; // Atualiza o estado anterior do botão
}Servo.h para controlar o servo motor.setup() , configuramos o pino do botão como entrada e inicializamos a comunicação serial.loop() , lemos o estado atual do botão. Se o botão foi pressionado, o servo muda de posição (0° para 180° e vice-versa).Depois de montar o circuito, carregue o código no Arduino. Ao pressionar o botão, o servo motor deve se mover de uma posição (0°) para outra (180°) e vice-versa, conforme especificado no código. Este projeto é um exemplo básico de como controlar um servo motor com um botão utilizando o Arduino.
Conecte o buzzer ao Arduino da seguinte forma:
# define BUZZER_PIN 8 // Define o pino do buzzer
void setup () {
pinMode (BUZZER_PIN, OUTPUT); // Configura o pino do buzzer como saída
}
void loop () {
// Frequências das notas musicais (em Hz)
int notas[] = { 262 , 294 , 330 , 349 , 392 , 440 , 494 , 523 };
// Duração das notas (em milissegundos)
int duracaoNota = 500 ;
for ( int i = 0 ; i < 8 ; i++) {
tone (BUZZER_PIN, notas[i]); // Gera a frequência da nota no buzzer
delay (duracaoNota); // Mantém a nota por um tempo
noTone (BUZZER_PIN); // Desliga o som do buzzer
delay ( 50 ); // Pequena pausa entre as notas
}
delay ( 1000 ); // Pausa entre as repetições da melodia
}setup() , configuramos o pino do buzzer como saída.loop() , usamos a função tone() para gerar frequências correspondentes a notas musicais no buzzer.Após carregar o código no Arduino e conectar o buzzer, ele reproduzirá a sequência de notas musicais definidas no código. Isso é um exemplo básico de como criar músicas simples usando um buzzer com o Arduino.
Para estabelecer a comunicação entre um smartphone e o Arduino via Bluetooth, usaremos um módulo Bluetooth como o HC-05/HC-06. Aqui está um exemplo básico que permite enviar dados do smartphone para o Arduino via Bluetooth.
Conecte o módulo Bluetooth ao Arduino:
Este é um código simples que recebe dados enviados do smartphone via Bluetooth e os exibe no Monitor Serial.
# include < SoftwareSerial.h >
SoftwareSerial bluetooth ( 2 , 3 ); // Define os pinos de RX e TX para comunicação com o módulo Bluetooth
void setup () {
Serial. begin ( 9600 ); // Inicia a comunicação serial para o Monitor Serial
bluetooth. begin ( 9600 ); // Inicia a comunicação serial para o módulo Bluetooth
}
void loop () {
if (bluetooth. available ()) { // Verifica se há dados disponíveis para leitura
char dado = bluetooth. read (); // Lê o dado recebido
Serial. print ( " Dado recebido: " );
Serial. println (dado); // Exibe o dado no Monitor Serial
}
}Você precisará de um aplicativo de terminal serial ou Bluetooth para enviar dados para o módulo Bluetooth do Arduino.
Após carregar o código no Arduino e conectar o módulo Bluetooth, use o aplicativo em seu smartphone para enviar dados para o Arduino. Os dados enviados serão exibidos no Monitor Serial do Arduino IDE. Este é um ponto de partida para entender a comunicação básica entre um smartphone e o Arduino via Bluetooth.
