Serial Monitor: Forskelle mellem versioner

Fra HTX Arduino
Spring til navigation Spring til søgning
htx_>Bar
Ingen redigeringsopsummering
 
 
(4 mellemliggende versioner af 2 andre brugere ikke vist)
Linje 1: Linje 1:
Serial Monitor<ref>[https://www.arduino.cc/en/Guide/Environment#toc12 Serial Monitor beskrivelse]</ref> er et dejligt enkelt hjælpeværktøj man kan anvende i programmeringen af en Arduino. Porten der anvendes til dette er den serielle port som er beskrevet under [[Arduino Seriel]].
USB-forbindelsen mellem computeren og Arduinoen bliver brugt til upload af kode, men den kan også fungere som seriel kommunikation mellem Arduinoen og computeren, hvilket kan bruges i program-afviklingen, så man kan udskrive resultater til computeren, og man kan indtaste noget på computeren der sendes til Arduinoen.


Formålet er at man kan sende information fra Arduinoen til PC-en og få det vist PC-ens skærm løbende som programmet i Arduinoen afvikles.
Den serielle monitor startes ved at klikke den markerede ikon i figur 1:


Man kan også sende beskeder fra PC-en til Arduinoen.
[[Fil:Serial-fig1.png|600px|Markering af ikonen der starter den serielle monitor]]<br />
''Figur 1 Markering af ikonen der starter den serielle monitor.''


==Visning==
Når man gør det kommer følgende vindue op som vist i figur 2
Man får vist den serielle monitor ved at klikke på knappen som vist i IDE-et<br />
[[Fil:Serial_Monitor_Button.png]]


Alternativt kan man anvende genvejstasten '''Shift-Ctrl-M'''
[[Fil:Serial-fig2.png|600px|Den serielle monitor med BaudRate markeret]]<br />
 
''Figur 2 Den serielle monitor med BaudRate markeret.''
Den serielle monitor ser ud som vist her:<br />
[[Fil:Serial_Monitor_Window.png]]
 
==Forbindelse til Serial Monitor==
For at arbejde med den serielle monitor skal man etablere forbindelse til den via den serielle port<ref>[https://www.arduino.cc/en/Reference/Serial Seriel port på Arduino]</ref> med en angivet hastighed. Dette skal initialiseres på følgende måde i [[setup()]]:


I den serielle monitor skal kommunikationshastigheden (BaudRate) angives, så den svarer til den BaudRate som Arduinoen kommunikerer med - til normale programmer et 9600 fint.
==Simpel udskrift fra Arduino==
For at vise hvordan den simple udskrift fungerer, så tages der udgangspunkt i blink-eksemplet, hvor der skrives ud hver gang udgangen er ændret. Dette kan se ud som følger:
<source lang="C">
<source lang="C">
void setup()
void setup() {
{
   pinMode(13, OUTPUT);
   // Open serial communications and wait for port to open:
   Serial.begin(9600);
   Serial.begin(9600);
   delay(100);
   delay(100);
   Serial.println("Welcome to My Program");
   Serial.println("Test af Serial Monitor");
   Serial.println("---------------------");
}
   Serial.println();
 
void loop() {
  digitalWrite(13, HIGH);
   Serial.println("Output ON");
  delay(1000);
  digitalWrite(13, LOW);
   Serial.println("Output OFF");
  delay(1000);
}
}
</source>
</source>


===Hastighed===
I seriel Monitor vil det give resultatet som vist i figur 3:
Som angivet i Serial.begin skal der angives en kommunikations-hastighed (i det viste eksempel 9600). Dette antal angiver bit pr. sekund der kommunikeres over den serielle port, hvilket også angives som Baud - denne hastighed skal være den samme som angives nederst til højre i vinduet med den serielle monitor.


Hastigheden skal angives i nogle specielle trin:
[[Fil:Serial-fig3.png|600px|Visning fra testprogrammet lige efter reset]]<br />
*300
''Figur 3 Visning fra testprogrammet lige efter reset.''
*1200
*2400
*4800
*9600
*19200
*38400
*57600
*115200


Ved en standard hastighed på 9600 Baud tager det ca. 1 ms at få hver karakter sendt til den serielle monitor.
Der udskrives en start-besked en gang, og herefter udskrives ON/OFF hver gang der er gået et sekund.


Hvis man sender begrænset information (mindre end 64 bytes ad gangen der er bufferstørrelsen i modulet), så vil det ikke tage 1 ms for hver karakter i programmet, da karaktererne bare placeres i bufferen, og sendes når det er tid til det.
==Kodeeksempler==
Eksemplerne på denne side kan findes i en [[media:Serial-eksempler.zip|ZIP-fil]].
==Indlæsning i Arduino fra Computeren==
Man kan også sende tekst fra computeren ned i Arduinoen, så man kan rette på noget i Arduinoen. Det gør man ved at indtaste noget i det øverste indtastningsfelt og klikke Send.


Sender man større mængder data efter hinanden, så vil bufferen løbe fuld, og så vil programmet vente på at der er plads i bufferen inden den næste karakter sendes. Fortsætter man på den måde vil programmet begrænses som om man havde en delay(1) inde for hver karakter man sender.
For at illustrere dette laves følgende tilføjelse i loop():
<source lang="C">
boolean blink = true;


En mulighed for at gøre det mere effektivt kan være at sætte hastigheden op.
void loop() {
 
  if (Serial.available() > 0) {
==Udskrift til Serial Monitor==
    char ch = Serial.read();
For at udskrive til den serielle monitor anvendes '''Serial.print()''' eller '''Serial.println()'''
    if (ch == 'A') {
 
      blink = true;
Man kan både skrive tekster og indholdet af variabler ud som vist her:
    } else if (ch == 'D') {
<source lang="C">
      blink = false;
int antal = 34;
    }
Serial.print("Antallet er:");
  }
Serial.print(antal);
  if (blink) {
Serial.println(" stk");
    digitalWrite(13, HIGH);
// Udskriv  Antallet er:34 stk
    Serial.println("Output ON");
    delay(1000);
  }
  digitalWrite(13, LOW);
  Serial.println("Output OFF");
  delay(1000);
}
</source>
</source>


==Indlæsning af tekst fra PC til Arduino==
Ved at taste D og klikke Send så vil koden kun give OFF indtil man taster A og klikker Send. Dette er vist i figur 4:
Man kan også læse tekst fra den serielle monitor ind i Arduinoen.


Her skal man hele tiden tjekke om der er kommet noget med '''Serial.available()''' før man kan læse noget med '''Serial.read()'''
[[Fil:Serial-fig4.png|600px|Visning af hvor et D har slået blink fra, og der skal sendes A for at slå til igen]]<br />
''Figur 4 Visning af hvor et D har slået blink fra, og der skal sendes A for at slå til igen.''


Man skriver ind i toppen af den serielle monitor og der sendes først til Arduinoen når der trykkes Enter.
Reaktionen kan ses både i den serielle monitor, og ved at LED’en på Arduinoen holder op med at blinke.


Koden til at læse kan se ud som følger:
==Indlæse værdier i Arduino==
I mange tilfælde er det ikke nok med en enkelt karakter, men i stedet ønskeligt at kunne sende tal til Arduinoen - dette kræver noget type-konvertering, hvor man kan konvertere den serielt modtagne streng til et tal<ref>[https://www.arduino.cc/en/Tutorial/StringToIntExample Arduino - StringToIntExample] 2018</ref>, så det kan anvendes.


Her illustreres et eksempel hvor der kan indtastes et tal, så delayet i blink-eksemplet kan indstilles til det man ønsker:
<source lang="C">
<source lang="C">
char ch;
int tal = 1000;


if (Serial.avaliable() > 0) {
void loop() {
  ch = Serial.read();
  if (Serial.available() > 0) {
  if (ch == '2') {
    String str = Serial.readStringUntil('\n');
     Serial.println("Du trykkede 2");
    str.trim();
    tal = str.toInt();
     Serial.print("Delay: ");
    Serial.println(tal);
   }
   }
  digitalWrite(13, HIGH);
  Serial.println("Output ON");
  delay(tal);
  digitalWrite(13, LOW);
  Serial.println("Output OFF");
  delay(tal);
}
}
</source>
</source>
Der bliver lige udskrevet det nye delay i den serielle monitor, som det kan ses i figur 5
[[Fil:Serial-fig5.png|300px|Visning af hvordan den nye delay udskrives i serial monitor]]<br />
''Figur 5 Visning af hvordan den nye delay udskrives i serial monitor.''
Det mest markante at ser er at hastigheden ændrer sig, specielt hvis man indtaster en lav værdi. Det kan også ses på lysdioden.
==Anvendelser af Seriel Monitor==
Der serielle monitor kan anvendes til forskelligt - umiddelbart, så er den rigtig god til test, når man udvikler programmer - at man lige kan se indholdet af en variabel, og at man kan spore om programkoden kommer ind i en betingelse.
Den serielle monitor kan også, som det er illustreret her, anvendes til betjening af et program i Arduinoen, hvor man kan have sit output til at komme på computeren, og man har mulighed for at sende kommandoer til Arduinoen fra computeren, så hele betjeningen af programmet sker via den serielle monitor. Det er måske ikke det mest brugervenlige, men det er relativt enkelt at opbygge.
En anden relateret anvendelse er at man kan sende og modtage værdier på den serielle port. Det kan være til anden elektronik (fx simple RFID-moduler sender en tekststreng med ID’et) eller det kan være til at kommunikere med med et program på computeren som det er beskrevet i [[Arduino kombineret med Processing]].
I nogle anvendelser kan det også være en fordel hvis man ikke bruger den serielle hardware-port (ben 0 og 1), men i stedet anvender SoftwareSerial<ref>[https://www.arduino.cc/en/Reference/SoftwareSerial Arduino - SoftwareSerial] 2018</ref>, så man stadig kan anvende den serielle monitor (virker ikke med SoftwareSerial) til fejlfinding. Software Serial kan fungere på alle digitale ben på Arduinoen - der er begrænsninger på andre processorer - se dokumentationen.
==Specielle forhold omkring Serial Monitor [[fil:svaert.png|80px]]==
Den serielle forbindelse er angivet i Baud, hvilket er bit pr. sekund, så for hver karakter går der 10 bit<ref>[http://www.robotroom.com/Asynchronous-Serial-Communication-1.html Asynchronous Serial Communication - Robot Room] 2011</ref>, så det tager ca. et millisekund for hver karakter med 9600 Baud. Det gør at man ikke bare kan sende ubegrænset datamængde uden at det sløver processen. Umiddelbart så sinker det ikke processen voldsomt at man sender en streng på 20 karakterer, da der ikke ventes til de 20 karakterer er sendt inden der returneres. Der sker i praksis det at de 20 karakterer lægges i en buffer, og så sørger kernen i Arduinoen for at karaktererne sendes, så længe der er noget i bufferen.
Arduinoen har dog kun 64 karakter i sin buffer (både sending og modtagelse), så hvis man hurtigt bliver ved at fylde i bufferen, så vil den løbe fuld.
For afsending af karakterer vil det betyde at der ventes til karaktererne er sendt, inden der returneres, så det kan sløve koden ret voldsomt, hvis man skriver for meget.
For modtagelse af karakterer, så vil det betyde at man mister karakterer hvis bufferen bliver fyldt (hvis koden ikke kan nå at læse det der modtages) - det er der ikke meget at gøre ved - man kan ændre størrelsen med Serial.buffer(size), men med den begrænsede hukommelse Arduinoen har, så er det begrænset hvor meget man kan udvide (realistisk set ikke over 1024).
En hjælp kan være at arbejde med en højere BaudRate, men det kan gøre kommunika- tionen mere støjfølsom. Det har dog også sine begrænsninger, da det også tager noget processortid at håndtere bufferen og at sende karaktererne ud af bufferen igen (sker i interrupt).
En anden indstilling man skal være opmærksom på er hvordan Enter sendes - det kan være “Carriage return”, “Newline” eller begge (CR & NL). Det kan også undlades, men det kan så være svært at skille tingene ad.


==Referencer==
==Referencer==
<references />
<references />
[[Kategori:Arduino]]
 
{{start-Arduino}}
 
[[Kategori:Oprindelige Dokumenter]]
[[Kategori:Grundlæggende forståelse for Arduino]]

Nuværende version fra 31. okt. 2022, 21:22

USB-forbindelsen mellem computeren og Arduinoen bliver brugt til upload af kode, men den kan også fungere som seriel kommunikation mellem Arduinoen og computeren, hvilket kan bruges i program-afviklingen, så man kan udskrive resultater til computeren, og man kan indtaste noget på computeren der sendes til Arduinoen.

Den serielle monitor startes ved at klikke på den markerede ikon i figur 1:

Markering af ikonen der starter den serielle monitor
Figur 1 Markering af ikonen der starter den serielle monitor.

Når man gør det kommer følgende vindue op som vist i figur 2

Den serielle monitor med BaudRate markeret
Figur 2 Den serielle monitor med BaudRate markeret.

I den serielle monitor skal kommunikationshastigheden (BaudRate) angives, så den svarer til den BaudRate som Arduinoen kommunikerer med - til normale programmer et 9600 fint.

Simpel udskrift fra Arduino

For at vise hvordan den simple udskrift fungerer, så tages der udgangspunkt i blink-eksemplet, hvor der skrives ud hver gang udgangen er ændret. Dette kan se ud som følger:

void setup() {
  pinMode(13, OUTPUT);
  Serial.begin(9600);
  delay(100);
  Serial.println("Test af Serial Monitor");
}

void loop() {
  digitalWrite(13, HIGH);
  Serial.println("Output ON");
  delay(1000);
  digitalWrite(13, LOW);
  Serial.println("Output OFF");
  delay(1000);
}

I seriel Monitor vil det give resultatet som vist i figur 3:

Visning fra testprogrammet lige efter reset
Figur 3 Visning fra testprogrammet lige efter reset.

Der udskrives en start-besked en gang, og herefter udskrives ON/OFF hver gang der er gået et sekund.

Kodeeksempler

Eksemplerne på denne side kan findes i en ZIP-fil.

Indlæsning i Arduino fra Computeren

Man kan også sende tekst fra computeren ned i Arduinoen, så man kan rette på noget i Arduinoen. Det gør man ved at indtaste noget i det øverste indtastningsfelt og klikke Send.

For at illustrere dette laves følgende tilføjelse i loop():

boolean blink = true;

void loop() {
  if (Serial.available() > 0) {
    char ch = Serial.read();
    if (ch == 'A') {
      blink = true;
    } else if (ch == 'D') {
      blink = false;
    }
  }
  if (blink) {
    digitalWrite(13, HIGH);
    Serial.println("Output ON");
    delay(1000);
  }
  digitalWrite(13, LOW);
  Serial.println("Output OFF");
  delay(1000);
}

Ved at taste D og klikke Send så vil koden kun give OFF indtil man taster A og klikker Send. Dette er vist i figur 4:

Visning af hvor et D har slået blink fra, og der skal sendes A for at slå til igen
Figur 4 Visning af hvor et D har slået blink fra, og der skal sendes A for at slå til igen.

Reaktionen kan ses både i den serielle monitor, og ved at LED’en på Arduinoen holder op med at blinke.

Indlæse værdier i Arduino

I mange tilfælde er det ikke nok med en enkelt karakter, men i stedet ønskeligt at kunne sende tal til Arduinoen - dette kræver noget type-konvertering, hvor man kan konvertere den serielt modtagne streng til et tal[1], så det kan anvendes.

Her illustreres et eksempel hvor der kan indtastes et tal, så delayet i blink-eksemplet kan indstilles til det man ønsker:

int tal = 1000;

void loop() {
  if (Serial.available() > 0) {
    String str = Serial.readStringUntil('\n');
    str.trim();
    tal = str.toInt();
    Serial.print("Delay: ");
    Serial.println(tal);
  }
  digitalWrite(13, HIGH);
  Serial.println("Output ON");
  delay(tal);
  digitalWrite(13, LOW);
  Serial.println("Output OFF");
  delay(tal);
}

Der bliver lige udskrevet det nye delay i den serielle monitor, som det kan ses i figur 5

Visning af hvordan den nye delay udskrives i serial monitor
Figur 5 Visning af hvordan den nye delay udskrives i serial monitor.

Det mest markante at ser er at hastigheden ændrer sig, specielt hvis man indtaster en lav værdi. Det kan også ses på lysdioden.

Anvendelser af Seriel Monitor

Der serielle monitor kan anvendes til forskelligt - umiddelbart, så er den rigtig god til test, når man udvikler programmer - at man lige kan se indholdet af en variabel, og at man kan spore om programkoden kommer ind i en betingelse.

Den serielle monitor kan også, som det er illustreret her, anvendes til betjening af et program i Arduinoen, hvor man kan have sit output til at komme på computeren, og man har mulighed for at sende kommandoer til Arduinoen fra computeren, så hele betjeningen af programmet sker via den serielle monitor. Det er måske ikke det mest brugervenlige, men det er relativt enkelt at opbygge.

En anden relateret anvendelse er at man kan sende og modtage værdier på den serielle port. Det kan være til anden elektronik (fx simple RFID-moduler sender en tekststreng med ID’et) eller det kan være til at kommunikere med med et program på computeren som det er beskrevet i Arduino kombineret med Processing.

I nogle anvendelser kan det også være en fordel hvis man ikke bruger den serielle hardware-port (ben 0 og 1), men i stedet anvender SoftwareSerial[2], så man stadig kan anvende den serielle monitor (virker ikke med SoftwareSerial) til fejlfinding. Software Serial kan fungere på alle digitale ben på Arduinoen - der er begrænsninger på andre processorer - se dokumentationen.

Specielle forhold omkring Serial Monitor

Den serielle forbindelse er angivet i Baud, hvilket er bit pr. sekund, så for hver karakter går der 10 bit[3], så det tager ca. et millisekund for hver karakter med 9600 Baud. Det gør at man ikke bare kan sende ubegrænset datamængde uden at det sløver processen. Umiddelbart så sinker det ikke processen voldsomt at man sender en streng på 20 karakterer, da der ikke ventes til de 20 karakterer er sendt inden der returneres. Der sker i praksis det at de 20 karakterer lægges i en buffer, og så sørger kernen i Arduinoen for at karaktererne sendes, så længe der er noget i bufferen.

Arduinoen har dog kun 64 karakter i sin buffer (både sending og modtagelse), så hvis man hurtigt bliver ved at fylde i bufferen, så vil den løbe fuld.

For afsending af karakterer vil det betyde at der ventes til karaktererne er sendt, inden der returneres, så det kan sløve koden ret voldsomt, hvis man skriver for meget.

For modtagelse af karakterer, så vil det betyde at man mister karakterer hvis bufferen bliver fyldt (hvis koden ikke kan nå at læse det der modtages) - det er der ikke meget at gøre ved - man kan ændre størrelsen med Serial.buffer(size), men med den begrænsede hukommelse Arduinoen har, så er det begrænset hvor meget man kan udvide (realistisk set ikke over 1024).

En hjælp kan være at arbejde med en højere BaudRate, men det kan gøre kommunika- tionen mere støjfølsom. Det har dog også sine begrænsninger, da det også tager noget processortid at håndtere bufferen og at sende karaktererne ud af bufferen igen (sker i interrupt).

En anden indstilling man skal være opmærksom på er hvordan Enter sendes - det kan være “Carriage return”, “Newline” eller begge (CR & NL). Det kan også undlades, men det kan så være svært at skille tingene ad.

Referencer

Kom i gang med Arduino
Grundlæggende forståelse for Arduino Arduino Hardware - Arduino Prototype Print - Blink Eksempel - Overblik - Serial Monitor - Simple Komponenter - Software og Udviklingsmiljø
Programmering af Arduino Anvendelse af Eksempler - Klasser og Objekter - Programafvikling i Arduino - Test af Programmer
Dokumentationsformer Dokumentation med Kode og Flowchart - Dokumentation med State-machines - Flowchart - Pseudokode - Program-kommentarer - Systemdokumentation - Syntaksfarvning - Blokdiagram - Pulsplaner - UML
Opkoblinger til Arduino Moduler og Biblioteker - Driver - Opkobling af Hardware - Simple Komponenter - Tips til anvendelse af ben på Arduino UNO
Kompliceret Programmering Arduino kombineret med Processing - Kommunikation fra Arduino til Processing - Kommunikation fra Processing til Arduino - CopyThread Multitasking - Dokumentation med State-machines - Tid og Samtidighed i Software - Arduino Memory
Kompliceret Hardware I2C - Andre Processorboards - Internet of Things (IoT)
Oprindelige Dokumenter PDF-Version - Forfattere
Software Udviklingsteknikker Agile metoder - Brugertest - SCRUM

Fasemodellen - Kravspecifikation - Databasedesign - Struktur eller Arkitektur - Softwaretest

Projekter Afstand programforslag - Lysmåling - Projektforslag - Prototyper
Undervisningsforløb 4t Valgfag til Folkeskolen - Læsevejledning 4t Valgfag - Materialer til 4t Valgfag - Undervisningsnoter 4t Valgfag - Undervisningsplan 4t Valgfag - Slides til Undervisning

Kort Valgfag til Folkeskolen - Læsevejledning Kort Valgfag - Materialer til Kort Valgfag - Undervisningsnoter Kort Valgfag - Undervisningsplan Kort Valgfag