Arduino

Drie manieren voor seriële communicatie tussen verschillende arduino's

Laatst bijgewerkt: 30/07/2020

Dit voorbeeld bevat temperatuurmeting met een Dallas DS18B20-sonde op een Arduino (Nano1), terwijl een andere Arduino (Nano2) is uitgerust met een 128 × 32 monochroom OLED display dat de metingen toont.

Overzicht

Soms beperkt het aantal beschikbare pinnen op een Arduino in een project de ambities. Dit kan bijvoorbeeld gebeuren wanneer een aantal sensoren zijn gepland waarvan de gegevens moeten worden weergegeven op een scherm met veel pins. Onder deze omstandigheden kan het handig zijn om een ​​Arduino toe te wijzen aan het bewaken van de sensoren, terwijl de taak om de resultaten weer te geven is toegewezen aan een andere Arduino.

Gegevens van een Arduino kunnen via seriële communicatie naar een buur worden verzonden.

In dit artikel spelen we met drie soorten seriële communicatie:

  1. standaard TX RX Seriële communicatie
  2. Met de hulp van de SoftwareSerial bibliotheek
  3. I2C

Seriële communicatie vereist twee pinnen van het microcontrollerbord. Voor een goede werking moeten de GND pinnen van beide Arduino's worden verbonden.

Invoering

Er kunnen zich omstandigheden voordoen waarbij het aantal beschikbare pinnen op een Arduino een project beperkt. Een voorbeeld is de constructie van een weerstation met barometer , temperatuur en vochtigheidssondes, terwijl men de resultaten tegelijkertijd op een TFT scherm wil laten zien.

Natuurlijk kan men een Arduino Mega gebruiken die veel meer pins beschikbaar heeft dan een bescheiden Arduino Uno of Nano, maar de uitdaging is om zo veel mogelijk uit een standaard Arduino te persen. Gelukkig heeft elke Arduino seriële communicatiepinnen die kunnen worden gebruikt om gegevens uit te wisselen met een ander apparaat, bijvoorbeeld een tweede Arduino.

We kunnen deze functionaliteit gebruiken om taken over twee Arduino's te verdelen: Arduino1 metingen en met Arduino2 de gegevens weergeven op een display.

Arduino's kunnen communiceren met elkaar en de buitenwereld via een verbluffend spectrum aan mogelijkheden:

  1. Seriële communicatie
  2. Bluetooth
  3. Wifi
  4. Infrarood

We behandelen in dit artikel enkel seriële communicatie.

Er zijn drie verschillende soorten seriële communicatie voor de Arduino:

  1. De standaardmanier waarbij de TX en RX pinnen worden gebruikt
  2. Met de hulp van de SoftwareSerial bibliotheek waarmee programmeurs vrije pennen kunnen selecteren om de communicatietaak uit te voeren
  3. I2C communicatie met pennen A4 en A5

In dit voorbeeld zijn twee Arduino Nano's verbonden. Nano1 (links) leest temperatuurgegevens van een Dallas DS18B20 temperatuursonde en communiceert vervolgens de gegevens naar Nano2 (rechts), die de temperatuurwaarde vervolgens weergeeft op een 128 × 32 monochroom OLED scherm.

Elektronica en benodigdheden

Bibliotheken

Nano1: een Dallas DS18B20 temperatuursonde aansluiten

Draadgebonden Dallas DS18B20 temperatuursondes hebben drie draden: rood, zwart en wit (soms geel). Rood is 5V, zwart is GND en de witte of gele draad is de datakabel.

In dit voorbeeld is de datakabel verbonden met pin 8 van Nano1. Een 4.7 kΩ weerstand functioneert als een pullup weerstand tussen de datapin van de sensor en 5V (figuur 1).

Apparaatadres:

Elke DS18B20 die de fabriek verlaat, heeft een specifiek apparaatadres. De sensor die in dit voorbeeld wordt gebruikt, heeft apparaatadres: 0x28, 0xFF, 0xD7, 0x91, 0x92, 0x16, 0x04, 0x69. U kunt het apparaatadres van uw DS18B20 identificeren met de schets DS18B20_address_finder.ino.

Nano2: bedrading van het I2C OLED display

Het 128 x 32 monochrome OLED scherm is standaard met Nano2 verbonden:

Extra

Elke Nano heeft een led op pin 6 die functioneert als een 'cyclusindicator' tijdens communicatie.

1. Standaard seriële communicatie

Figuur 1 toont de bedrading.
De TX pin van Nano1 is verbonden met pin RX van Nano2 en pin RX van Nano1 is verbonden met de TX pin van Nano2. GND van beide Nano's is met elkaar verbonden.

De schakelaar is nodig in de communicatielijn om seriële communicatie tussen de Arduinos te ontkoppelen tijdens het uploaden van een schets via de usb poort naar een van de nanos.

Het alternatief is om de nanos los te koppelen tijdens een upload activiteit.

Nano1 ontvangt via zijn pin 8 temperatuurgegevens van een DS18B20 sensor en verzendt de gemeten gegevens via seriële communicatie op pinnen TX en RX naar Nano2. De laatste geeft de gemeten temperatuur weer op een I2C apparaat, een 128 × 32 OLED display.

Werking

Nano1: De Dallas DS18B20 temperatuursonde leest temperaturen in twee decimalen, waarbij de tweede decimaal niet relevant is omdat deze onder de resolutie van de sonde ligt.
Niettemin is het type variabele dat nodig is om te werken met decimale metingen zoals temperaturen een float.

Serieel verzenden van een float is vrij complex. Daarom bevatten de schetsen een truc: in Nano1 wordt de float vermenigvuldigd met 10 om de waarde om te zetten in een geheel getal. Het gehele getal wordt verzonden naar Nano2 en hier wordt de waarde gedeeld door 10 en omgezet in een float.

Hieronder staat de complete schets. Een up and running Arduino IDE op uw computer is noodzakelijk.

Nano_1_Serial_Comm_DS18B20.ino

Nano2: De microcontroller ontvangt gegevens over zijn RX pin, converteert naar een float variabele met de naam 'DS18B20_01' en geeft de waarde van die float op de OLED weer via I2C.

Nano_2_Serial_Comm_OLED.ino

2. Soft seriële communicatie met SoftwareSerial

Figuur 2 toont de bedrading voor deze configuratie.
Zoals u kunt zien, is er niet veel verschil tussen Soft Serial en Standard Serial.

Merk op dat alleen op Nano1 de draden die in Standaard Seriële communicatie zijn verbonden met TX en RX nu zijn verbonden met pennen 3 en 4.

Op Nano2 is niets veranderd. Dus, op Nano1, werkt pin 3 als Soft TX en werkt pin 4 als Soft RX.

Al het andere in de bedrading is ongewijzigd. Wat nodig is voor het compileren is de bibliotheek SoftwareSerial.h.

Werking

Nano1 ontvangt via zijn pin 8 temperatuurgegevens van een DS18B20 sensor en verzendt de gemeten gegevens via SoftwareSerial communicatie naar Nano2.

De laatste geeft de gemeten temperatuur weer op een I2C apparaat, een 128 × 32 OLED display.

Alleen voor Nano1 wordt hier een schets gepresenteerd, aangezien de schets voor Nano2 identiek is aan de schets hierboven.

Hieronder staat de schets voor Nano1. Een up and running Arduino IDE op uw computer is noodzakelijk.

Nano_1_Soft_Serial_Comm_DS18B20.ino

3. I2C seriële communicatie

Nano2 maakt al gebruik van I2C communicatie om de ontvangen gegevens naar het OLED scherm te verzenden.

Omdat I2C een 'bus' communicatietype is, waarbij elk apparaat op de bus een uniek adres heeft, is de uitwisseling van informatie van en naar de Arduino en randapparatuur, of het nu een OLED of een' slave 'Arduino is, naar apparaten met een specifiek adres.

I2C en one wire bussen werken onafhankelijk van elkaar.

Figuur 3 toont de bedrading van de twee nanos in de I2C configuratie. De pennen A4 en A5 van Nano1 zijn verbonden met pennen A4 en A5 van Nano2. De pennen A4 en A5 van Nano2 zijn verbonden met pennen SDA en SCK op het OLED scherm.

Een schakelaar in de communicatiekabels is niet nodig. Deskundigen in de I2C communicatie benadrukken dat twee 4.7kΩ pullup weerstanden op de A4 en A5 lijnen nodig zijn.

De gegevenspin van de Dallas DS18B20 sonde is verbonden met pen 8, net als in de configuraties Standaardserie en Softserie.

Nano1 (de I2C slave) ontvangt via zijn pin 8 temperatuurgegevens van een DS18B20 sensor en verzendt op verzoek van de I2C master (Nano2) de gemeten gegevens naar de I2C master. Nano2 geeft de gemeten temperatuur weer op een OLED display van een I2C apparaat (128 × 32).

In tegenstelling tot de Standaard Seriële communicatie waar de partners gelijk zijn, werkt I2C communicatie tussen Arduino’s met 'meesters' en 'slaven'. Er kan slechts één meester zijn die maximaal 32 slaven kan aansturen.

In onze configuratie is Nano1 met de temperatuursensor de slaaf en Nano2 de meester. Het I2C OLED display is ook een soort slave apparaat voor de meester Nano.

Werking

Vanwege de master slave configuratie moeten schrijf of leesverzoeken van de master naar een bepaalde slave worden geadresseerd aan die specifieke slave. De slaafidentiteit van Nano1 in dit voorbeeld is '8'. De meester heeft geen identiteit nodig omdat er maar één meester is. Een ander probleem dat verschilt van standaard serieel dataverkeer is het concept van communicatie.

I2C kan alleen getallen verzenden tussen 0 en 255, dat wil zeggen dat I2C typisch ASCII tekens verzendt. Een truc om iets van de ene Arduino naar de andere te sturen met het I2C protocol is om nummers te 'vermommen' als ASCII tekens. Dit proces wordt 'codering' genoemd. De slaaf leest dus de temperatuur van de sensor, codeert de waarde als een reeks tekens en wacht geduldig totdat de master gegevens opvraagt. De master ontvangt de tekenreeks, decodeert de tekenreeks in een waarde en verzendt deze waarde naar de display.

Zelfs 'floats' zoals gepresenteerd door een DS18B20 sensor kunnen worden gecodeerd en gedecodeerd in I2C communicatie. In de huidige opstelling communiceren we 'floats'. De instructie in de slave die verantwoordelijk is voor codering wordt dtostrf genoemd en de instructie in de master die verantwoordelijk is voor decodering wordt 'atof' genoemd.

Nano1: (slave)de Dallas DS18B20 temperatuursensor bevestigd aan Nano1 leest temperaturen in twee decimalen, om te worden opgeslagen in een variabele die moet worden gedeclareerd als een 'float'. Het is mogelijk om de zwevende waarde om te zetten in een geheel getal, maar omdat we toch naar een reeks tekens ('string') moeten coderen, kunnen we de float rechtstreeks in een tekenreeks coderen, wat geheugenallocaties bespaart.

Sommige experimenten gaven als resultaat dat het verzenden van de hele float van Nano1 naar Nano2 en vervolgens het verwijderen van de tweede decimaal nauwkeuriger is dan het verwijderen van de tweede decimaal voordat de float is gecodeerd.

Als gevolg hiervan wordt in de Nano1 schets een reeks van 5 tekens samengesteld en verzonden naar Nano2, dat wil zeggen twee tekens, één met de 10s van graden en de volgende met de eenheidsgraden, gevolgd door een punt (de komma vertegenwoordigt ) en de volgende twee tekens vertegenwoordigen de decimalen. (vb.25.36)

Hieronder staat ​​de schets voor Nano1. Een up and running Arduino IDE op uw computer is noodzakelijk.

Nano_1_I2C_comm_slave_DS18B20.ino

Nano2 (master): deze Nano vraagt om een tekenreeks van de slave die de gecodeerde temperatuur informatie bevat, converteert de tekenreeksen naar een float en bestuurt het OLED LCD scherm dat de temperatuur met één decimaal weergeeft.

Hieronder staat de schets voor Nano2.

Nano_2_I2C_comm_master_OLED.ino

Besluit

Seriële communicatie kan erg handig zijn om taken over twee Arduino's te verdelen, waar anders meerdere taken op één Arduino de microcontroller kunnen overbelasten, geheugen overbelasten of eenvoudig meer pinnen nodig hebben dan beschikbaar.

Standaardserie, zoals de naam al aangeeft, is het klassieke communicatieprotocol met veel voorbeelden die beschikbaar zijn op internet.

Soft Serial biedt flexibiliteit bij de keuze van pinnen. Seriële communicatie is in principe tussen twee Arduino's.

I2C is vooral handig als er meer dan twee Arduino's in de configuratie zitten.

De code van dit project kan je hier downloaden.