Stăpânirea comunicării seriale cu Arduino

Când lucrați la proiecte mari Arduino, este destul de obișnuit să rămâneți fără pinii disponibili pentru a conecta componente. Să presupunem că doriți să conectați mai mulți senzori/actuatori cu necesitatea urgentă de a păstra în continuare pini suplimentari pentru a alimenta un modul de afișare care așteaptă pini.

Dacă nu faci ceva magie, uneori este dificil să gestionezi toate aceste conexiuni pe o singură placă Arduino - mai ales atunci când decizi să folosești plăci mai mici pentru că ești presat de spațiu. Atunci intră în joc comunicarea în serie.

Să explorăm ce este comunicarea în serie și modalitățile în care o puteți configura cu Arduino pentru sarcini precum procesarea distribuită și integrarea generală.

Ce este comunicarea în serie?

Comunicarea în serie este o metodă de trimitere și primire a datelor între două sau mai multe dispozitive electronice, câte un bit, pe o singură linie de comunicație. După cum sugerează și numele, datele sunt trimise în „serie

".

Chiar și doar posibilitatea de a încărca schițe pe placa Arduino preferată folosește comunicarea în serie prin USB.

Protocoale de comunicații seriale pe Arduino

Plăcile Arduino sunt incredibil de versatile și pot comunica cu o gamă largă de dispozitive. Aceștia acceptă patru protocoale de comunicație serială: Soft Serial, SPI (Serial Peripheral Interface), UART standard (Universal Asynchronous Receiver-Transmitter) și I2C (Inter-Integrated Circuit). Pentru mai multe detalii, consultați ghidul nostru cuprinzător cum funcționează comunicațiile seriale UART, SPI și I2C.

Acest tutorial folosește schițe de bază pentru a arăta cum puteți configura o conexiune serială între două plăci Arduino Uno folosind diferite protocoale. Adaptați codul pentru a satisface cerințele dumneavoastră specifice.

SPI (Interfață periferică serială)

SPI este un protocol de comunicare serială sincronă care permite comunicarea de mare viteză între microcontrolere și dispozitive periferice. Acest protocol necesită patru fire pentru comunicare: SCK (Ceas serial), MOSI (Master Out Slave In), MISO (Master In Slave Out) și SS (Selectare sclav).

The SPI.h biblioteca este foarte utilă pentru acest tip de comunicare și trebuie inclusă în partea de sus a schiței.

#include

Iată pinii SPI de pe placa Arduino Uno:

După inițializarea comunicației seriale, va trebui să configurați pinii de comunicare.

golînființat(){
SPI.ÎNCEPE(115200);
// Setați modurile pin pentru SS, MOSI, MISO și SCK
pinMode(SS, IEȘIRE);
pinMode(MOSI, IEȘIRE);
pinMode(MISO, INTRARE);
pinMode(SCK, IEȘIRE);
// Setați pinul de selectare slave (SS) la mare pentru a dezactiva dispozitivul slave
digitalWrite(SS, ÎNALT);
}

Semnalul SS este folosit pentru a spune dispozitivului slave când sunt transferate date.

// Selectați sclavul
digitalWrite(SS, SCĂZUT);
// Trimite date către dispozitivul slave
SPI.transfer(date);
// Deselectați dispozitivul slave
digitalWrite(SS, ÎNALT);

Iată cum să conectați două plăci Arduino folosind SPI.

Cod pentru placa principală:

#include
constint slaveSelectPin = 10;
golînființat(){
SPI.ÎNCEPE(115200);
pinMode(slaveSelectPin, IEȘIRE);
}
golbuclă(){
digitalWrite(slaveSelectPin, SCĂZUT);
SPI.transfer('H');
digitalWrite(slaveSelectPin, ÎNALT);
întârziere(1000);
}

Cod pentru placa slave:

#include
constint slaveSelectPin = 10;
golînființat(){
SPI.ÎNCEPE(115200);
pinMode(slaveSelectPin, IEȘIRE);
}
golbuclă(){
dacă (digitalRead(slaveSelectPin) == SCĂZUT) {
char date primite = SPI.transfer(„L”);
Serial.println(Date primite);
 }
}

Asigurați-vă că dispozitivele dvs. au o bază comună pentru configurarea corectă.

UART (receptor-transmițător asincron universal)

UART este un protocol de comunicație serială asincronă care permite comunicarea între dispozitive folosind doar două fire: TX (Transmit) și RX (Receive). UART este utilizat în mod obișnuit pentru comunicarea cu dispozitive precum modulele GPS, modulele Bluetooth și alte microcontrolere. Fiecare placă Arduino este echipată cu cel puțin un port pentru UART.

Pinii UART de pe plăcile Arduino populare includ:

Puteți obține masa completă de la Documentația online Arduino despre comunicarea în serie.

Mai întâi, conectați-vă plăcile astfel:

Apoi utilizați acest cod pentru placa expeditorului:

golînființat(){
Serial.ÎNCEPE(9600);
}
golbuclă(){
// Trimite un mesaj prin serie în fiecare secundă
Serial.println("Salut din partea expeditorului!");
întârziere(1000);
}

Cod pentru placa receptorului:

golînființat(){
Serial.ÎNCEPE(9600);
}
golbuclă(){
// Verificați dacă există date primite
dacă (Serial.disponibil() > 0) {
// Citiți datele primite și imprimați-le pe monitorul serial
Şir incomingData = Serial.readString();
Serial.println(incoming Data);
 }
}

Arduino Uno funcționează la un nivel logic de 5V, în timp ce portul RS232 al computerului folosește un nivel logic de +/-12V.

Conectarea directă a unui Arduino Uno la un port RS232 poate și vă va deteriora placa.

I2C (circuit inter-integrat)

I2C este un protocol de comunicare serială sincronă care permite comunicarea între mai multe dispozitive folosind doar două fire: SDA (Serial Data) și SCL (Serial Clock). I2C este utilizat în mod obișnuit pentru comunicarea cu senzori, EEPROM-uri și alte dispozitive care trebuie să transfere date pe distanțe scurte.

Pinii I2C de pe Arduino Uno sunt SDA (A4) și SCL (A5).

Vom crea un program simplu pentru a stabili o conexiune între două plăci Arduino folosind comunicarea I2C. Dar mai întâi, conectați-vă plăcile astfel:

Cod pentru placa principală:

#include
golînființat(){
Sârmă.ÎNCEPE(); // se alătură magistralei I2C ca master
Serial.ÎNCEPE(9600);
}
golbuclă(){
Sârmă.începeTransmisie(9); // transmite către dispozitivul slave cu adresa 9
Sârmă.scrie('A'); // trimite un octet către dispozitivul slave
Sârmă.finalTransmisie(); // nu mai transmite
întârziere(500);
}

Cod pentru placa slave:

#include
golînființat(){
Sârmă.ÎNCEPE(9); // se alătură magistralei I2C ca slave cu adresa 9
Sârmă.onReceive(receiveEvent);
Serial.ÎNCEPE(9600); 
}
golbuclă(){
întârziere(100);
}
golreceiveEvent(int octeți){
in timp ce(Sârmă.disponibil()) { // parcurge toți octeții primiți
char primitByte = Sârmă.citit(); // citește fiecare octet primit
Serial.println(receivedByte); // imprimă octetul primit pe monitorul serial
 }
}

Ce este SoftwareSerial?

Biblioteca Arduino SoftwareSerial a fost dezvoltată pentru a emula comunicarea UART, permițând comunicarea în serie prin oricare doi pini digitali de pe plăcile Arduino. Este util atunci când hardware-ul UART este deja utilizat de alte dispozitive.

Pentru a configura SoftwareSerial, includeți mai întâi biblioteca SoftwareSerial în schiță.

#include

Apoi creați o instanță a obiectului SoftwareSerial specificând codul RX și TX pini care vor fi utilizați pentru comunicare.

SoftwareSerialmySerial(2, 3); // Pini RX, TX

Iată un exemplu de cod pentru Arduino care demonstrează utilizarea SoftwareSerial:

#include
SoftwareSerialmySerial(2, 3); // Pini RX, TX
golînființat(){
Serial.ÎNCEPE(9600); // pornește serialul hardware
 mySerial.ÎNCEPE(9600); // începe soft serial
}
golbuclă(){
dacă (Serialul meu.disponibil()) {
Serial.scrie(Serialul meu.citit()); // trimite datele primite către seria hardware
 }
dacă (Serial.disponibil()) {
 mySerial.scrie(Serial.citit()); // trimite date de la serialul hardware la serialul soft
 }
}

Biblioteca Serial

Biblioteca Serial este un instrument puternic în Arduino care permite comunicarea între microcontroler și un computer sau alte dispozitive printr-o conexiune serială. Unele funcții comune includ:

Baud Rate și Serial Data Format

Baud rate se referă la viteza cu care datele sunt transferate prin conexiunea serială. Acesta reprezintă numărul de biți care sunt transmisi pe secundă. Rata baud trebuie setată la fel atât pe dispozitivul emițător, cât și pe cel receptor, altfel comunicarea poate fi deranjată sau să nu funcționeze deloc. Ratele baud obișnuite pentru Arduino includ 9600, 19200, 38400 și 115200.

Formatul datelor seriale se referă la structura datelor trimise prin conexiunea serială. Există trei componente principale pentru formatul de date seriale: biți de pornire, biți de date și biți de oprire.

• Biți de date: numărul de biți utilizați pentru a reprezenta un singur octet de date.
• Paritate: Un bit opțional utilizat pentru verificarea erorilor. Poate fi setat la nici unul, paritate sau paritate impară, în funcție de cerințele canalului de comunicare.
• Stop Bits: Numărul de biți utilizați pentru a semnala sfârșitul unui octet de date.

Formatul datelor trebuie să fie același atât pe dispozitivele de transmisie, cât și pe cele de recepție, pentru a asigura o comunicare adecvată. Iată un exemplu despre cum puteți seta anumite formate de date:

golînființat(){
// Configurați comunicația serială cu 9600 baud rate, 8 biți de date, fără paritate și 1 bit de oprire
Serial.ÎNCEPE(9600, SERIAL_8N1); 
}

Aici, SERIAL_8N1 reprezintă formatul de date cu 8 biți de date, fără paritate și 1 oprește puțin. Alte opțiuni precum SERIAL_7E1, SERIAL_8O2, etc., pot fi utilizate în funcție de cerințele specifice ale proiectului.

Discuție în serie

Plăcile Arduino oferă diverse opțiuni de comunicare serială care permit schimbul de date eficient și fiabil între dispozitive. Înțelegând cum să configurați protocoale de comunicație serială pe Arduino IDE, puteți profita de puterea procesării distribuite sau puteți reduce foarte mult numărul de fire utilizate în proiectele dvs.