På senare år har programmerings- och robotcirklar blivit extremt populära och är tillgängliga även för grundskoleelever. Detta blev möjligt tack vare användningen av grafiska programmeringsmiljöer, som, det bör noteras, används aktivt av stora företag. För att prata om grafiska programmeringsmiljöer har vi valt ut tre av de mest populära av dem.

Visuino

Visuino är en gratis grafisk miljö som körs på Arduino-kompatibla Controllino industrikontroller (PLC). Det gör det möjligt att skapa komplexa automationssystem och IoT-lösningar (Internet of Things, Internet of Things), och detta kan göras helt enkelt genom att flytta och koppla ihop visuella block. Programvarumiljön genererar automatiskt kod för industriella styrenheter.

Så vad behöver göras. Välj komponenter (moduler) från komponentpanelen och flytta dem till designområdet. Sedan behöver de kopplas ihop och sätta upp fastigheter. Detta görs med hjälp av objektinspektören.

Fördelarna med Visuino inkluderar en stor uppsättning komponenter för matematiska och logiska funktioner, servon, displayer, internet osv.

När PLC:n är programmerad frågar den grafiska miljön överkomligt sätt anslutning till styrenheten. Det kan vara en seriell port, Ethernet, Wi-Fi eller GSM.

Äntligen är ditt projekt klart: alla kontroller är registrerade, allt fungerar. Nu genom att klicka på Arduino-logotypen som finns på topppanel, kommer du att tvinga Visuino att skapa koder för Arduino och öppna dess utvecklingsmiljö (Arduino IDE), genom vilken du redan kan kompilera koden och ladda ner den till PLC:n.

Råd. Om det installerade kortet inte matchar din Arduino kan du ändra det med kommandot "Select Board".

Repa

Denna grafiska programmeringsmiljö skapades 2003 när en grupp MIT Media Lab-anställda bestämde sig för att utveckla ett programmeringsspråk som är tillgängligt för absolut alla. Som ett resultat, efter en tid, introducerades Scratch för allmänheten.

Mest av allt kanske det ser ut som Lego. Åtminstone är principen densamma: det är en objektorienterad miljö där program är sammansatta av detaljer, färgstarka och ljusa. Dessa detaljer kan flyttas, modifieras, fås att interagera på olika sätt. Grunden för Scratch är block av kommandon såsom sensorer, variabler, rörelse, ljud, operatörer, utseende, penna, kontroller etc. Inbyggd grafikredigerare gör det möjligt att rita vilket föremål som helst. Mindre än fem år efter skapandet av Scratch föddes Scratch for Arduino-projektet (förkortat S4A), vilket låter dig programmera Arduino PLC.

Fördelarna med systemet inkluderar det faktum att det är russifierat och helt lokaliserat - alla som vill hitta mycket data om det. Dessutom är arbete i denna grafiska miljö tillgängligt även för grundskoleelever som ännu inte är alltför säkra på att läsa.

Råd. För de som är nya med Scratch finns det en speciell resurs: https://scratch-ru.info .

ArduBlock

När en person redan har behärskat Scratch fullt ut, men ännu inte vuxit upp till Wiring, där Arduino-kompatibla kort är programmerade, är det dags att ge honom råd om ArduBloсk-verktyget skrivet i Java. Det är särskilt bra för dem som är förtjusta i robotik.

Vad är skillnaden? Faktum är att Scratch inte vet hur man flashar Arduino, den styr bara sin PLC via USB. Arduino kan alltså inte fungera på egen hand, eftersom det beror på datorn.

Faktum är att ArduBloсk är ett mellansteg mellan barnens Scratch och den ganska professionella, om än prisvärda Visuino, eftersom den, liksom den senare, har förmågan att flasha Arduino-kompatibla kontroller.

Råd. Glöm inte att installera Java Machine på din PC. Det tar inte mycket tid.

Alltså, mer grafiska miljöer – bra och annorlunda. Må Arduino vara med dig.

Foto: tillverkningsföretag, pixabay.com

Efter att ha bekantat sig med de grundläggande delarna av Arduino, samt skrivit programmet "Hello World!" det är dags att bekanta sig med programmeringsspråket.

Språkets struktur bygger i första hand på C/C++, så de som tidigare har programmerat på detta språk kommer inte att ha några svårigheter att bemästra Arduino-programmering. Resten ska lära sig grundläggande information om kontrollkommandon, datatyper och funktioner.

Mycket av informationen som finns här kommer att vara kompatibel med alla C/C++-kurser, med förbehåll för skillnader i datatyper, såväl som några specifika instruktioner angående programmering av I/O-portar.

Grunderna i grunderna

Några formella saker, det vill säga de som alla vet om, men ibland glömmer de ...

Material: ABS + metall + akryllinser. Led-lampor...

I Arduino IDE, som i C/C++, måste du vara medveten om skiftläge. Nyckelord, som om, för skrivs alltid med små bokstäver. Varje instruktion slutar med ";". Semikolonet talar om för kompilatorn vilken del som ska tolkas som ett uttalande.

Parenteser (..) används för att beteckna programblock. Vi använder dem för att avgränsa kroppen av en funktion (se nedan), loopar och villkorliga uttalanden.

Det är bra att lägga till kommentarer till programinnehållet, detta gör koden lätt att förstå. En rad kommentarer börjar med // (dubbelt snedstreck). Flerradiga kommentarer börjar med /* och avsluta med */

Om vi ​​vill inkludera något bibliotek i vårt program använder vi kommandot include. Här är exempel på att ansluta bibliotek:

#omfatta // standardbibliotek #inkludera "svoya_biblioteka.h" // bibliotek i projektkatalogen

Funktioner i Arduino

En funktion (subrutin) är en separat del av ett program som utför någon operation. Funktioner används för att förenkla huvudprogrammet och förbättra kodläsbarheten. Det är användbart att använda funktioner då vi enkelt kan använda dem i många av våra projekt.

Standardprogrammeringskursen innehåller information om de funktioner som vi kommer att presentera i följande artiklar. När det gäller Arduino kommer funktionerna att diskuteras i början, eftersom till och med det enklaste programmet måste ha två specialfunktioner. Detta har redan nämnts i tidigare artiklar, men här systematiserar vi denna information.

Funktionsdeklaration

Funktionsdeklarationsschemat ser ut så här:

Skriv funktionsnamn(parameter) ( // instruktioner för att köra (funktionskropp) return (/* returvärde*/); )

typär namnet på alla tillgängliga datatyper i det givna programmeringsspråket. Listan över tillgängliga typer vid programmering av Arduino kommer att ges i en separat artikel.

Efter exekvering kommer funktionen att returnera värdet för den deklarerade typen. Om funktionen inte accepterar något returvärde kommer datatypen att vara "void".

funktionsnamn gör att den kan identifieras unikt. För att anropa (köra) en funktion ger vi den ett namn.

parameter— parameter för funktionsanrop. Parametrar är valfria, men ofta användbara. Om vi ​​skriver en funktion som inte har några argument lämnar vi parenteserna tomma.

Inom parenteserna innehåller "(...)" själva kroppen av funktionen eller instruktionen som vi vill utföra. Beskrivningen av specifika instruktioner kommer att anges i en separat artikel.

Alla funktioner som returnerar ett värde slutar med en retursats följt av returvärdet. Endast funktioner som deklareras med en nollpekare ("void") innehåller inte en retursats. Du måste veta att return-satsen avslutar exekveringen av funktionen, oavsett plats.

Nedan följer några exempel på funktionsdeklarationer.

Void f1() ( //funktionskropp ) —————————————— int minus() ( //funktionskropp retur (0); ) ———————————— ——— int plus(int a, int b) ( return (a+b); )

Som du kan se av exemplen kan en funktionsdeklaration ta olika former beroende på dina behov.

Vi rekommenderar starkt att du lär dig och använder funktioner när du skriver dina egna program. Med tiden har varje programmerare sitt eget bibliotek med funktioner "för alla tillfällen", vilket gör det enklare och snabbare att skriva nya program.

Nu när vi vet hur man skriver vår egen funktion måste vi lära oss hur man använder den.

Funktionsanrop

Vi skriver alla funktioner i en fil/program. Det finns givetvis en mer elegant lösning, men vi ska försöka beskriva den nästa gång.

Genom att deklarera en funktion kan vi använda den i andra funktioner med rätt namn och eventuella nödvändiga parametrar. Följande är exempel på anrop av funktionerna vi gav ovan:

F1(); plus(2,2); y=plus(1,5);

Som du kan se i exemplen görs anropet av en funktion genom att ange dess namn och det antal parametrar som krävs. Det är viktigt att alltid anropa en funktion enligt dess deklaration.

Om funktionen f1() deklareras utan parametrar så kan inga parametrar anges när den anropas, dvs. att anropa funktionen f1(0) blir felaktigt.

Funktionen plus(int a, int b) kräver exakt två parametrar, så det är inte möjligt att anropa med en eller tre parametrar.

Att anropa y=plus(1,5) kommer att utföra "plus"-funktionen med parametrarna "1" och "5" och lagra returvärdet i variabeln "y".

setup() och loop() funktioner.

Med kunskapen om att deklarera och anropa funktioner kan vi gå vidare till Arduino-systemfunktionerna: uppstart() Och slinga(). Arduino IDE krävs för att deklarera dessa två funktioner.

setup() är en funktion som anropas automatiskt när strömmen slås på eller RESET-knappen trycks ned.

Som namnet antyder används det för att ställa in de initiala värdena för variabler, deklarationer av ingångar och utgångar från systemet, som vanligtvis anges i de initiala parametrarna. På grund av dess specificitet returnerar inte denna funktion ett värde och anropas inte med parametrar. Den korrekta deklarationen av setup()-funktionen ges nedan:

Void setup () ( // function body - system initialization )

loop() är en funktion som anropas i en oändlig loop. Denna funktion returnerar inte heller ett värde och anropas inte med parametrar. Följande är den korrekta deklarationen av loop()-funktionen:

Void loop () ( // function body - program code )

Som du kan se är deklarationen av loop()-funktionen identisk med deklarationen av setup()-funktionen. Skillnaden ligger i hur mikrokontrollern presterar dessa funktioner.

Vi kommer nu att analysera följande pseudokod:

void setup () ( on_led1 (); // slå på led1 off_led1 (); // stäng av led1 ) void loop () ( on_led2 (); // slå på led2 off_led2 (); // stäng av led2 )

Det finns två instruktioner i setup()-funktionen, den första tänder led1 som är ansluten till kortet (till exempel stift 13), och den andra stänger av led1.

Loop()-funktionen har identiska instruktioner för att slå på och av led2 som är ansluten till kortet (t.ex. stift 12).

Som ett resultat av att programmet körs kommer led1 att blinka en gång, medan led2 kommer att slås på och stängas av så länge som Arduino är påslagen.

Om du trycker på RESET-knappen kommer lysdiod1 att blinka en gång till och lysdiod2 att börja blinka igen.

Sammanfatta:

• Funktionerna setup() och loop() är systemfunktioner, som måste definieras i varje projekt. Även i en situation där vi inte skriver någon kod i en av dem måste vi ändå deklarera dessa två funktioner;
• Funktionen setup() körs en gång, loop() körs kontinuerligt;
• Vi skapar våra egna funktioner i en fil;
• Vi kan anropa våra funktioner både från setup () och loop (), och från andra funktioner;
• Våra egna funktioner kan anropas med parametrar och returnera ett värde;
• Ett funktionsanrop måste göras i enlighet med dess deklaration.

Du kommer behöva

• - Arduino UNO-bräda,
• - USB-kabel(USB A - USB B),
• - Personlig dator,
• - Ljusdiod,
• - 220 ohm motstånd,
• - ett par ledningar 5-10 cm,
• - om tillgängligt - brödbräda.

Instruktion

Ladda ner Arduinos utvecklingsmiljö för ditt operativsystem (Windows, Mac OS X, Linux stöds) på http://arduino.cc/en/Main/Software, installer, . Den nedladdade filen innehåller även drivrutiner för Arduino-kort.

Installera drivrutinen. Överväg alternativet för Windows OS. För att göra detta, vänta tills operativ system kommer att uppmana dig att installera drivrutinen. Vägra. Tryck på Win + Paus, starta Enhetshanteraren. Hitta avsnittet "Portar (COM & LPT)". Du kommer att se en port där som heter "Arduino UNO (COMxx)". Högerklicka på den och välj "Uppdatera drivrutin". Välj sedan platsen för drivrutinen du just laddade ner.

Utvecklingsmiljön innehåller redan många exempel för att studera styrelsens verksamhet. Öppna "Blink"-exemplet: Arkiv > Exempel > 01.Basics > Blink.

Ange din styrelse för utvecklingsmiljön. För att göra detta, välj "Arduino UNO" i menyn Verktyg > Styrelse.

Välj den port som Arduino-kortet är tilldelat till. För att ta reda på vilken port kortet är anslutet till, öppna Enhetshanteraren och leta efter avsnittet Portar (COM & LPT). Inom parentes efter namnet på tavlan kommer porten att indikeras. Om kortet inte finns i listan, prova det från datorn och efter att ha väntat några sekunder, anslut det igen.

Koppla bort kortet från datorn. Montera kretsen enligt bilden. Observera att det korta benet på lysdioden måste anslutas till GND-stiftet, det långa benet genom ett motstånd till digitalt stift 13 på Arduino-kortet. Det är bekvämare att använda en brödbräda, men om den inte är tillgänglig kan du ansluta ledningarna med en vridning.
Viktig notering! Digital pin 13 har redan ett eget motstånd på kortet. Därför, när du ansluter lysdioden till kortet, är ett externt motstånd inte nödvändigt. När du ansluter lysdioden till andra Arduino-stift är användningen av ett strömbegränsande motstånd obligatoriskt!

Nu kan du ladda ner programmet till kortets minne. Anslut kortet till datorn, vänta några sekunder medan kortet initieras. Klicka på knappen "Ladda upp" så kommer din skiss att skrivas till Arduino-kortets minne. Arduino-programmering är väldigt intuitivt och inte alls svårt. Titta på bilden - i kommentarerna till programmet finns små förklaringar. Detta är tillräckligt för att ta itu med ditt första experiment.

Introduktion

Freeduino/Arduino är programmerad på speciellt språk programmering - den är baserad på C / C ++ och låter dig använda någon av dess funktioner. Strängt taget finns det inget separat Arduino-språk, precis som det inte finns någon Arduino-kompilator - skrivna program konverteras (med minimala ändringar) till ett C/C++-program och kompileras sedan av AVR-GCC-kompilatorn. Så faktiskt används en C / C ++-variant specialiserad för AVR-mikrokontroller.

Skillnaden är att du får en enkel utvecklingsmiljö, och en uppsättning grundläggande bibliotek som gör det lättare att komma åt kringutrustningen "ombord" på mikrokontrollern.

Håller med, det är väldigt bekvämt att börja arbeta med en seriell port med en hastighet av 9600 bitar per sekund, ringa ett samtal på en rad:

Serial.begin(9600);

Och när du använder "bar" C / C ++, skulle du behöva ta itu med dokumentationen för mikrokontrollern och ringa något så här:

UBRROH = ((F_CPU / 16 + 9600 / 2) / 9600 - 1) >> 8;
UBRR0L = ((F_CPU / 16 + 9600 / 2) / 9600 - 1);
sbi(UCSROB, RXENO);
sbi(UCSROB, TXENO);
sbi(UCSROB, RXCIEO);

Här är en kort översikt över huvudfunktionerna och funktionerna i Arduino-programmering. Om du inte är bekant med syntaxen för C/C++-språk, rekommenderar vi att du hänvisar till all litteratur om det här problemet eller Internetkällor.

Å andra sidan är alla exemplen som presenteras väldigt enkla, och troligen kommer du inte att ha några svårigheter att förstå källtexterna och skriva dina egna program även utan att läsa ytterligare litteratur.

Mer komplett dokumentation engelska språket) presenteras på projektets officiella webbplats - http://www.arduino.cc. Det finns också ett forum, länkar till ytterligare bibliotek och deras beskrivning.

I analogi med beskrivningen på den officiella webbplatsen för Arduino-projektet hänvisar "porten" till kontakten på mikrokontrollern, utgång till kontakten under motsvarande nummer. Dessutom finns en seriell dataport (COM-port).

Programstruktur

I ditt program måste du deklarera två huvudfunktioner: setup() och loop().

Setup()-funktionen anropas en gång, efter varje start eller återställning av Freeduino-kortet. Använd den för att initiera variabler, ställa in digitala portlägen och så vidare.

Funktionen loop() exekverar sekventiellt kommandona som beskrivs i dess kropp om och om igen. De där. efter att funktionen avslutas kommer den att anropas igen.

Låt oss ta ett enkelt exempel:

void setup() // initiala inställningar
{
beginSerial(9600); // ställ in serieportens hastighet till 9600 bps
pinMode(3, INPUT); // ställer in den 3:e porten för datainmatning
}

// Programmet kontrollerar den 3:e porten för en signal på den och skickar ett svar till
// som ett textmeddelande till datorns seriella port
void loop() // programkropp
{
if (digitalRead(3) == HIGH) // villkor för pollingport 3
serialWrite("H"); // skicka ett meddelande i form av bokstaven "H" till COM-porten
annan
serialWrite("L"); // skicka ett meddelande i form av bokstaven "L" till COM-porten
fördröjning(1000); // fördröjning 1 sek.
}

pinMode(port, läge);

Beskrivning:

Konfigurerar den angivna porten för att mata in eller mata ut en signal.

Alternativ:

port – numret på den port vars läge du vill ställa in (heltalsvärde från 0 till 13).

läge - antingen INPUT (ingång) eller OUTPUT (utgång).

pinMode(13, OUTPUT); //13th pin kommer att vara utgången
pinMode(12, INPUT); //och den 12:e är ingången

Notera:

Analoga ingångar kan användas som digitala ingångar/utgångar när de nås av nummer 14 (analog ingång 0) till 19 (analog ingång 5)

digitalWrite(port, värde);

Beskrivning:

Ställer in spänningsnivån på hög (HIGH) eller låg (LOW) på den angivna porten.

Alternativ:

port: portnummer

värde: HÖG eller LÅG

digitalWrite(13, HIGH); // sätt stift 13 till "högt" tillstånd

värde = digitalRead(port);

Beskrivning:

Läser ett värde på den angivna porten

Alternativ:

port: pollad portnummer

Returvärde: returnerar det aktuella värdet på porten (HÖG eller LÅG) av typen int

int värde;
val = digitalRead(12); // fråga den 12:e utgången

Notera:

Om ingenting är anslutet till läsporten kan digitalRead()-funktionen slumpmässigt returnera HÖG eller LÅG.

Analog in-/utgångssignal

värde = analogRead(port);

Beskrivning:

Läser ett värde från den angivna analoga porten. Freeduino innehåller 6 kanaler, 10 bitars A/D-omvandlare vardera. Detta innebär att en inspänning på 0 till 5V omvandlas till ett heltalsvärde på 0 till 1023. Läsupplösningen är: 5V/1024 värden = 0,004883V/värde (4,883mV). Det tar ungefär 100 nS (0,0001 S) att läsa det analoga ingångsvärdet, så den maximala avläsningshastigheten är ungefär 10 000 gånger per sekund.

Alternativ:

Returvärde: Returnerar en int i intervallet 0 till 1023, läst från den angivna porten.

int värde;
val = analogRead(0); // läs värde på analog ingång 0

Notera:

Analoga portar är signalingångsdefinierade som standard och, till skillnad från digitala portar, behöver de inte konfigureras genom att anropa pinMode-funktionen.

analogWrite(port, värde);

Beskrivning:

Matar ut ett analogt värde till porten. Den här funktionen fungerar på: 3, 5, 6, 9, 10 och 11 Freeduino digitala portar.

Den kan användas för att ändra ljusstyrkan på lysdioden, för att styra motorn, etc. Efter anrop av analogWrite-funktionen kommer motsvarande port att fungera i pulsbreddsmodulerat spänningsläge tills nästa anrop till analogWrite-funktionen (eller digitalRead/digitalWrite-funktionerna på samma port) sker.

Alternativ:

port: nummer på den avfrågade analoga ingången

värde: heltal mellan 0 och 255. Ett värde på 0 genererar 0 V på den angivna porten; ett värde på 255 genererar +5 V på den angivna porten. För värden mellan 0 och 255 kommer porten snabbt att växla mellan 0 och +5V - ju högre värde, desto oftare genererar porten HIGH (5V).

analogWrite(9, 128);// ställ in stift 9 till ett värde motsvarande 2,5V

Notera:

Det är inte nödvändigt att anropa pinMode-funktionen för att ställa in porten på pin innan du anropar analogWrite-funktionen.

Signalgenereringsfrekvensen är cirka 490 Hz.

tid = millis();

Beskrivning:

Returnerar antalet millisekunder sedan körningen av Freeduino nuvarande program. Räknaren kommer att svämma över och nollställas efter cirka 9 timmar.

Returvärde: returnerar ett värde av typen unsigned long

osignerad lång tid; // deklarerar tidsvariabeln av typen unsigned long
tid = millis(); // passerar antalet millisekunder

delay(tid_ms);

Beskrivning:

Pausar programmet i det angivna antalet millisekunder.

Alternativ:

time_ms – programfördröjningstid i millisekunder

fördröjning(1000); //pausa 1 sekund

fördröjning Mikrosekunder

delayMicroseconds(tid_µs);

Beskrivning:

Pausar programmet under det angivna antalet mikrosekunder.

Alternativ:

time_µs – programfördröjningstid i mikrosekunder

delayMicroseconds(500); //paus 500 mikrosekunder

pulseIn(port, värde);

Beskrivning:

Läser en puls (hög eller låg) från en digital port och returnerar pulsens varaktighet i mikrosekunder.

Till exempel, om parametern "värde" är inställd på HÖG när funktionen anropas, väntar pulseIn() på att porten ska ta emot en hög signalnivå. Från det ögonblick den anländer börjar nedräkningen tills porten får en låg signalnivå. Funktionen returnerar pulslängden ( hög nivå) i mikrosekunder. Fungerar med pulser från 10 mikrosekunder till 3 minuter. Observera att denna funktion inte returnerar ett resultat förrän en puls har detekterats.

Alternativ:

port: nummer på porten från vilken vi läser pulsen

värde: pulstyp HÖG eller LÅG

Returvärde: returnerar pulsens varaktighet i mikrosekunder (typ int)

int varaktighet; // deklaration av varaktighetsvariabeln av typen int
varaktighet = pulsIn(stift, HÖG); // mät pulslängd

Seriell kommunikation

Freeduino har en inbyggd seriell kontroller som kan användas för att kommunicera mellan Freeduino/Arduino-enheter eller till en dator. På en dator representeras motsvarande anslutning av en USB COM-port.

Kommunikation sker på digitala portar 0 och 1, och därför kan du inte använda dem för digital I/O om du använder de seriella datafunktionerna.

Serial.begin(baudhastighet);

Beskrivning:

Ställer in baudhastigheten för COM-porten i bitar per sekund för seriell kommunikation. För att kommunicera med en dator, använd en av dessa standardhastigheter: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 eller 115200. Du kan också definiera med andra portar när du kommunicerar med en annan mikrokontroller och 1.

Alternativ:

baudrate: datahastighet i bitar per sekund.

Serial.begin(9600); //ställ in hastigheten till 9600 bps

seriell.tillgänglig

count = serial.available();

Beskrivning:

De byte som tas emot via serieporten går in i mikrokontrollerns buffert, varifrån ditt program kan läsa dem. Funktionen returnerar antalet byte som ackumulerats i bufferten. Den seriella bufferten kan lagra upp till 128 byte.

Returvärde:

Returnerar ett int-värde, antalet byte tillgängliga för läsning i den seriella bufferten, eller 0 om inget är tillgängligt.

if (Serial.available() > 0) ( // Om det finns data i bufferten
// här ska ta emot och bearbeta data
}

char = Serial.read();

Beskrivning:

Läser nästa byte från den seriella bufferten.

Returvärde:

Den första tillgängliga byten med inkommande data från serieporten, eller -1 om det inte finns några inkommande data.

incomingByte = Serial.read(); // läs byte

Beskrivning:

Rensar ingångsbufferten för den seriella porten. Den buffrade datan går förlorad och ytterligare anrop till Serial.read() eller Serial.available() kommer att vara meningsfulla för data som tas emot efter anropet till Serial.flush().

Serial.flush(); // Rensa bufferten - börja ta emot data "från grunden"

Beskrivning:

Datautgång till seriell port.

Alternativ:

Funktionen har flera anropsformulär beroende på typ och format för utdata.

Serial.print(b, DEC) skriver ut en ASCII-sträng, decimalrepresentationen av b.

int b = 79;

Serial.print(b, HEX) skriver ut en ASCII-sträng, den hexadecimala representationen av talet b.

int b = 79;

Serial.print(b, OCT) skriver ut en ASCII-sträng, den oktala representationen av talet b.

int b = 79;
serietryck (b, okt); // kommer att mata ut strängen "117" till porten

Serial.print(b, BIN) skriver ut en ASCII-sträng, den binära representationen av talet b.

int b = 79;
Serial.print(b, BIN); // kommer att mata ut strängen "1001111" till porten

Serial.print(b, BYTE) skriver ut den låga byten av b.

int b = 79;
Serial.print(b, BYTE); //skriver ut talet 79 (en byte). I monitorn
//serieport vi får tecknet "O" - dess
//koden är 79

Serial.print(str) om str är en sträng eller en array av tecken, skickar str till COM-porten byte för byte.

char bytes = (79, 80, 81); //array på 3 byte med värden 79,80,81
Serial.print("Här våra bytes:"); //skriver ut strängen "Här våra bytes:"
Seriell utskrift(bytes); //matar ut 3 tecken med koder 79,80,81 -
//detta är tecknen "OPQ"

Serial.print(b) om b är av typen byte eller char, skrivs själva numret b till porten.

charb = 79;
Serietryck (b); //kommer att ge tecknet "O" till porten

Serial.print(b) om b är ett heltal, skriver decimalrepresentationen av b till porten.

int b = 79;
Serietryck (b); // kommer att mata ut strängen "79" till porten

Beskrivning:

Serial.println-funktionen liknar Serial.print-funktionen och har samma anropsalternativ. Den enda skillnaden är att ytterligare två tecken matas ut efter data - en vagnretur (ASCII 13 eller "\r") och ett nyradstecken (ASCII 10 eller "\n").

Exempel 1 och exempel 2 kommer att mata ut samma sak till porten:

int b = 79;
Serial.print(b, DEC); // kommer att mata ut strängen "79" till porten
Serial.print("\r\n"); //kommer att visa tecknen "\r\n" - nyrad
Serial.print(b, HEX); // kommer att mata ut strängen "4F" till porten
Serial.print("\r\n");//skriver ut tecknen "\r\n" - nyrad

int b = 79;
Serial.println(b, DEC); //kommer att mata ut strängen "79\r\n" till porten
Serial.println(b, HEX); // kommer att mata ut strängen "4F\r\n" till porten

I serieportmonitorn får vi.