Stap 10: Communicatie met de computer
Tot op dit punt, we de USB-aansluiting alleen gebruikt voor het uploaden van nieuwe programma's aan de Arduino. Maar we kunnen ook de verbinding gebruiken om gegevens te verzenden van en naar de computer.
Sommige Arduino boards zoals het Leonardo hebben een microcontroller die de USB communicatie alle door haar eigen verzorgt, maar de meeste platen hebben een tweede, kleinere microcontroller, uitsluitend voor de communicatie. Op de Arduino Uno is dit het zwarte vierkantje tussen de USB-connector en de TX-RX LEDs. De communicatie tussen deze chip en de belangrijkste microcontroller wordt gedaan met behulp van een seriële verbinding, dan de tweede chip vertelt de computer 'Hey, ik ben een seriële poort', en dan gewoon de seriële data van de belangrijkste chip omgezet in USB-formaat, en omgezet in de berichten van de computer voor de belangrijkste microcontroller seriële.
Seriële betekent dat bits worden verzonden via de dezelfde draad, een na de ander, overwegende dat parallelle verbindingen 8 bits verzenden of meer gelijktijdig, op afzonderlijke draden (zoals de grote parallel printer-poort op de achterkant van sommige oudere computers).
De Arduino gebruikt twee seriële lijnen: één van de Arduino voor de USB-chip, de verzendlijn (TX) en één regel van de USB-chip aan de Arduino, de lijn van de receive (RX). Deze brieven zijn geschreven naast pin 0 en 1. Dit betekent dat deze pennen gebruikt worden wanneer u de verbinding met de computer, zodat u ze niet kunt voor LEDs of knoppen enz gebruiken. Als u de communicatie weer stopt, kunt alleen u hen als normaal I/O pinnen.
Als u de Arduino verbinden met een ander apparaat dat gebruik maakt van seriële communicatie wilt, moet u ook gebruiken deze twee pinnen.
Ingangen naar de computer verzenden
Open voorbeeld serialButton en uploaden.
De breadboard configuratie is hetzelfde als in de vorige stap.
Open vervolgens de seriële monitor: Tools > seriële Monitor, klik op het vergrootglas in de rechterbovenhoek of hit CTRL + SHIFT + M. maken zeker autoscroll is ingeschakeld en de baudrate is ingesteld op 9600.
Hier ziet u een bos van enen. Nu druk op de drukknop op pin 3 aangesloten, en ziet u nullen. Dit is alleen de ruwe inbreng van de pin.
Open nu de seriële plotter: Tools > seriële Plotter of CTRL + SHIFT + L. Dit zal de waarden uitzetten in een grafiek.
Neem een blik bij de code:
In het Configuratiemenu, voegen we een nieuwe opdracht: Serial.begin(9600). Dit is gewoon om te beginnen de mededeling en de 9600 is de baud-rate, het aantal pulsen per seconde, dus de snelheid van de seriële aansluiting. 9600 is gewoon de standaardwaarde. Als je dit op een andere waarde instelt, hebt u om het te veranderen in de seriële monitor evenals. Anders, zal het worden synchroon, en geven u zeer vreemde karakters. Het tegenovergestelde van Serial.begin(...) is Serial.end(). U kunt dit gebruiken als u pin 1 en 0 als normale I/O om opnieuw te gebruiken hebt, na het gebruik van de seriële aansluiting, maar het wordt niet echt aangeraden.
In de lus ziet u hetzelfde seriële trefwoord, ditmaal met de functie println(...) gebruikt. Dit drukt gewoon de waarde die opgegeven tussen de haakjes, gevolgd door een nieuwe regel (ln).
(Merk op dat dit niet alleen converteren naar een binair getal te sturen over seriële, in plaats daarvan, het wordt geconverteerd naar ASCII, en stuurt het via de seriële poort, zodat de computer kan uitprinten. Als u wilt verzenden van binaire bytes via seriële, gebruik de functie van Serial.write(...) .)
Als u een nieuwe regel, kunt u ook Serial.print(...) samen met de \n (nieuwe regel) of de \r (regelterugloop) tekens, die duiden op een regel die eindigt, in plaats van de ln.
Serial.print(digitalRead(3)); Serial.print('\n'); De enkele aanhalingstekens aangeven dat er een teken.
Een ander speciaal teken is de \t (tabblad), laten we het gebruiken voor het afdrukken van de ingangen van beide schakelaars. Dit is de voorbeeld serial2Buttons. Uploaden en open de seriële monitor om het resultaat te zien.
Verzenden van opdrachten naar de Arduino
De mededeling werkt ook andersom: laten we een programma schrijven naar besturingselement LEDs van de computer.
Open de voorbeeld serialLEDs.
Uploaden, open de seriële monitor en proberen het verzenden van waarden tussen 0 en 3. Nu verzenden 4. Krijgen hoe het werkt?
Laten we check de code:
De setup ziet er vrij vertrouwd, behalve één opdracht: dit is een while-lus. Een while-lus wordt herhaald, zolang de voorwaarde tussen de haakjes waar is (je kan vergelijken met een for-lus, maar zonder het eerste en het laatste argument, alleen de toestand.) Ik expliciet de gekromde haken wordt gebruikt om aan te geven is een lus, maar u kunt ook gewoon een puntkomma in plaats daarvan: tijdje (! Serieel);
Seriële methode retourneert true als de seriële communicatie actief is (wanneer u de seriële monitor, bijvoorbeeld opent). Dus als we een niet-operator (!) toevoegt, wordt met de expressie waar is als de mededeling niet actief is. Zo houdt de while-lus herhalen terwijl de mededeling niet actief is, en in wezen wacht deze actief worden. We weten dan dat kunnen we beginnen met het verzenden van gegevens met de functie println(...). Als we niet zou de while-lus gebruiken om te wachten, verliezen sommige boards zoals het Leonardo (en andere platen met USB-mogelijkheden in de belangrijkste chip) zal enkel de eerste gegevens. Het probeert te sturen naar de computer, maar niets er luistert voor seriële input.
In de lus, er is een andere nieuwe verklaring: de if-statement, dit is waarschijnlijk de meest belangrijke verklaring in computerwetenschappen. Het doet precies wat de naam al aangeeft: het wordt uitgevoerd een stukje code, alleen wanneer een bepaalde voorwaarde voldaan wordt. Anders wordt de code tussen de gekromde haken genegeerd.
Nu neem ik een moment om te verklaren hoe de Arduino seriële berichten ontvangt:
Zoals ik al eerder heb uitgelegd, stuurt seriële een beetje na de andere, byte voor byte. Dit betekent dat uw bericht, "test", bijvoorbeeld, wordt opgesplitst in stukken van 1 byte. Een karakter is een byte in grootte, zodat het iets als 't kijken zal ' 'e' van ' 't' wanneer u het via seriële verzendt. Wanneer de Arduino deze bytes ontvangt, zal het hen slaan in een buffer (maar een klein stukje van het geheugen naar het tijdelijk op te slaan). Het ontvangt het byte voor byte, zodat de buffer er iets als dit ziet "" (lege) "t", "te", "tes" "test".
Wanneer de buffer leeg is, de Serial.available() -functie als resultaat 0 als er gegevens in de buffer heeft ontvangen, het geeft het aantal bytes in de buffer, dus 4 in dit geval. Als u de functie Serial.read() aanroept, zal het lezen van de eerste byte ('t ') uit de buffer, verwijdert u deze uit de buffer en verschuiven van de buffer, dat daarin nu "est" en Serial.available() als 3 resultaat. Als u Serial.read() aanroept opnieuw, 'e' wordt geretourneerd, en de buffer zullen "st". U kunt blijf lezen totdat Serial.available() gelijk is aan nul. (Als u weten van de eerste byte wilt zonder daarbij zo te verwijderen, kunt u de functie van Serial.peek() .)
Zo de eerste if(Serial.available > 0) zal controleren of er geen gegevens in de buffer. Als dat zo is, zal het lezen van de eerste byte en opgeslagen in de variabele serialValue. Het zal dan controleren of de waarde die het alleen lezen is '0'. Opmerking de enkele aanhalingstekens, geeft dit teken nul (ASCII: ' 0' = 48), en niet 0 als waarde, aangezien de seriële monitor als tekst verzonden. Als de waarde '0' is, dooft het beide LED's. Als de waarde niet '0', code in de sectie 'anders is' zal uitvoeren: dus het nu controleren zal als de waarde is '1', zo ja, hij draait op de eerste LED en verandert van de tweede. Als er geen '1' ofwel, zal het controleren als het is '2', als zo, het draait op de tweede LED en u de eerste schakelt. Als er geen '2', zal het controleren als het '3', zo ja, blijkt op beide LEDs, anders wordt de code uitgevoerd in de laatste anders sectie en drukt welke waarden u moet invoeren.
U kunt het stroomdiagram in de afbeelding als de verklaring niet duidelijk genoeg was.
Merk op dat een dubbele gelijkheidsteken wordt gebruikt om te controleren of twee waarden hetzelfde. Als u een enkele gelijkteken, zou gebruiken (als (serialValue = '0')) het zal niet iets te controleren, het zal slechts een waarde van '0' toewijzen aan de variabele serialValue. Dit is een zeer vaak voorkomende fout.
Andere operatoren te testen waarden zijn < (minder dan) > (groter dan) < = (minder dan of gelijk aan) > = (groter dan of gelijk aan)! = (niet gelijk aan).
Binnenkant van de if-instructie, ook kunt u logische operatoren (Booleaanse operatoren), meerdere voorwaarden controleren: & & (en) || (of)
Enkele voorbeelden:
5 > 3 → waar
5 < 3 → onwaar
3 > 3 → onwaar
3 > = 3 → true
5! = 3 → true
3 == 3 → waar
om te controleren als een waarde is x tussen 1 en 100:
(1 < = x) & & (x < = 100)
een andere manier van schrijven van dit (niet aanbevolen, net als een voorbeeld)
! ((x < 1) || (x>100))
U kunt proberen om erachter te komen hoe het werkt zelf, en neem vervolgens contact op met de tabellen van de waarheid in de afbeelding hierboven.
Opmerking: Net als in de wiskunde, haakjes worden gebruikt om aan te geven de volgorde van bewerkingen, bijvoorbeeld in de laatste uitdrukking, ' x < 1' zal getest worden eerst, vervolgens ' x > 100', vervolgens ' ||', en tot slot '!'.
Arduino Referentie: als (en vergelijkings-operatoren)
Arduino Referentie: Booleaanse operatoren
_
Samenvatting
- Meeste Arduinos hebben een tweede chip voor USB-communicatie. Deze chip communiceert met de belangrijkste microcontroller met behulp van een seriële verbinding.
- Seriële betekent dat een beetje na de andere, één filter tegelijk wordt verzonden. Er is een verzendlijn en een lijn ontvangen (TX en RX respectievelijk).
- Hier kunt u de seriële Monitor (CTRL + SHIFT + M) en de seriële Plotter (CTRL + SHIFT + L) te laten zien van de gegevens dat is het verzenden van de Arduino, en gegevens te sturen naar de Arduino.
- Serial.begin(baud); begint de seriële communicatie met de computer. De standaard-baudrate is 9600.
- Serial.end(); Hiermee beëindigt u de seriële communicatie.
- Serial.Print(text); tekst wordt afgedrukt op de computer, het kan worden gelezen in de seriële monitor/plotter. Merk op dat de getallen worden geconverteerd naar ASCII: b.v. Serial.print(0); stuurt een seriële waarde van 48 (ASCII-code voor het nul karakter).
- Serial.println(text); hetzelfde als het afdrukken, maar zal een nieuwe regel toevoegen na het bericht.
- '\n' is een nieuwe-regelteken, '\r' is een harde return, en "\t" is het tab-teken (voor inspringingen)
- Serial.write(byte); geeft een ruwe byte via seriële. Bijvoorbeeld, Serial.write(48); een 0-teken in de seriële monitor afgedrukt.
- while(Condition) {...} is de while-lus genoemd. Code tussen de accolades zal worden uitgevoerd en herhaald zolang de voorwaarde tussen gewone haakjes waar is.
- Seriële methode retourneert true als de seriële communicatie actief is (wanneer u de seriële monitor, bijvoorbeeld opent).
- tijdje (! Serieel); Herhaal 'niets' (Lees ' wachten') zal zolang de seriële communicatie niet actief.
- if(condition) {if-code} else {anders-code} zal het als-code uitvoeren als de voorwaarde waar is, en de anders-code uitvoeren als de voorwaarde onwaar is.
- Seriële data ontvangen door de Arduino is opgeslagen in een buffer, het blijft daar totdat je het lezen of totdat de buffer overloopt.
- Serial.available(); Deze eigenschap retourneert het aantal bytes dat beschikbaar is in de buffer.
- Serial.Read(); zal u terug de eerste byte in de buffer en daarna verwijderen.
- Serial.Peek(); geeft de eerste byte in de buffer, zonder het te verwijderen.
- In uw voorwaarden, kunt u deze testen exploitanten: == (gelijk aan), < (minder dan), > (groter dan), < = (kleiner dan of gelijk aan), > = (groter dan of gelijk aan),! = (niet gelijk aan).
- En u kunt ook de logische gebruiken & & (en) en || (of) exploitanten.
Extra: Switch
In het laatste voorbeeld, gebruikten we een heleboel als... anders verklaringen. Dit is de snelste manier om het te doen, maar het is niet gemakkelijk te lezen. Als u een variabele sommige bepaalde waarden vergelijken wilt, kunt u een schakelen.
Open de voorbeeld serialLEDsSwitch.
Zoals u zien kunt, wordt de schakeloptie begint met de 'schakelaar' sleutelwoord, gevolgd door de variabele die u wilt controleren tussen haakjes. Tussen de gekromde haken, worden onze cases gedefinieerd. Ze gebruiken de syntaxis ' waarde van dezaak : ", gevolgd door de code die u uitvoeren wilt als de opgegeven variabele gelijk is aan de waarde in dit 'geval'. Na de zaak-specifieke code, de 'pauze;' wordt sleutelwoord gebruikt om te sluiten van de 'case'.
Merk op dat de waarde die u invoert niet een variabele kan worden. Als u vergelijken 2 variabelen wilt, moet je als-instructies gebruiken.
De code in de 'standaard:' geval wordt uitgevoerd als de variabele niet overeenkomt met een van de waarden van andere gevallen. Deze draagtas is optioneel en kan worden weggelaten.
