Les 3: Seriële Communicatie

Seriële Communicatie

Communicatie met de Arduino

UART

SPI

I2C

BitBanging

Communicatie met de Arduino

Arduino is een USB Device op onze computer

ATmega328p heeft geen USB Functionaliteit

ATmega328p gebruikt UART om te communiceren met een PC

Er is een extra chip aanwezig

Hoe communiceren

Serial object

Serial.print en println

Seriële Monitor

UART

Universal Asynchronous Receiver Transmitter

Asynchrone Interface

Geen gemeenschappelijke klok

Vereist wel een correcte instelling

Vereist 2 draden

Full Duplex mogelijk

Werkt op TTL levels

Simpel

Altijd aanwezig op een microcontroller

UART Frame

IDLE - Lijn in rust

St - Start bit

(n) - Data bits

P - Parity Bit

Sp - Stop Bits

UART Frame

IDLE

Lijn in rust

Altijd een logisch hoog signaal

St

Start Bits

Signaleert de start van een frame

Altijd een logisch laag signaal

UART Frame

(n)

Aantal data bits

Min 5 - Max 9

Meestal 8

P

Parity bits

Error controle

≠ Error correctie

Meestal niet gebruikt

Parity Berekening

Berekening

Mode

Odd

`P_(even) = d_(n - 1) \oplus ... \oplus d_(2) \oplus d_(1) \oplus d_(0) \oplus 0`

`P_(even) = \sum_{i=0}^n [i = 1] % 2`

Even

`P_(odd) = d_(n - 1) \oplus ... \oplus d_(2) \oplus d_(1) \oplus d_(0) \oplus 0`

`P_(odd) = (\sum_{i=0}^n [i = 1] + 1) % 2`

Voorbeeld

Data	`\sum_{i=0}^n [i = 1]`	Even	Odd
00000000	0	0	1
01010100	3	1	0
01011110	5	1	0
11111111	8	0	1

UART Frame

Stop Bits

Altijd een logisch hoog signaal

Min: 1 - Max: 2

Meestal 1

2 Stop bits is een artifact

St/IDLE

Volgend frame of stoppen met verzenden

UART Configuratie

Uit opbouw van een UART Frame leiden we volgende configuratie mogelijkheden af:

Aantal data bits
Parity bit
Stop Bits
...

Baud Rate

Modulatie snelheid

Aantal symbool veranderingen per seconde

In digitale systemen = bits per second (bps)

Keuze afhankelijk van kloksnelheid

Voor meer info zie pagina 199 datasheet ATmega328p

Vaak voorkomende waarden

9600

19200

57600

115200

UART Configuratie

Uit opbouw van een UART Frame leiden we volgende configuratie mogelijkheden af:

Aantal data bits

Parity bit

Stop Bits

Baud Rate

UART Notatie

9600 8N1

9600 Baudrate - 8 Data Bits - No Parity Bit - 1 Stop Bit

115200 8E2

115200 Baudrate - 8 Data Bits - Even Parity Bit - 2 Stop Bits

9600 5O1

9600 Baudrate - 5 Data Bits - Odd Parity Bit - 1 Stop Bit

UART Synchronisatie

Asynchroon

Geen klok

Afhankelijk van de correcte instellingen

Reciever moet weten wanneer te stoppen met sampelen

d.m.v. Stop Bit

Reciever moeten weten wanneer te sampelen

d.m.v. Start Bit

Er wordt meestal gesampeld op 16x de baud rate

UART Synchronisatie

Start Synchronisatie

Start synchronisatie door detectie start bit

Start op de failing edge van de start bit

Start bit moet gedurdende een halve periode laag blijven

UART Synchronisatie

Einde Synchronisatie

Einde synchronisatie door detectie stop bit

Geweten door configuratie

Correcte start

Wordt gedetecteerd door frame error

RS - 232

Uitbreiding op UART

Andere signaal niveaus

Flow Control

Buiten de scope van dit vak

Off gebruiken

Ondanks oude standaard nog steeds terug te vinden

RS - 232

UART Levels

RS - 232 Levels

UART & Arduino

USB To UART

Meerdere seriële poorten mogelijk

Serial Monitor

Seriële Data

Formaat

Line Endings

Serial

Niet elke Arduino is hetzelfde

FT232R (Orginele Arduino)

CH340G (Chinese Variant)

CP2102 (Chinese Variant

Niet elke Arduino is hetzelfde

Arduino Micro

Arduino gebaseerd op ATMega32u4

Native USB poort op microcontroller

Geen host capaciteit wel device

Heeft een vrije seriele poort

Meerdere boards gebaseerd op de ATMega32u4

Arduino Leonardo

Arduino LilyPad

Sparkfun Pro Micro

USB to UART

Een arduino verbonden met een computer is zichtbaar in

Device Manager

Apparaatbeheer

Naamgeving:

Windows - COMX

Linux / Mac - /dev/ttyX

Serial Monitor

Uitlezen van data

Sturen van seriële data

Instellen van

Line ending

Baud rate

Je beste vriend in het ontwikkelen van microcontroller applicaties

Debugging door print statements

Seriële Data: Formaat

Alle data over de uart lijn is reeks van 8 bits
De reeks bits wegschrijven in een datatype geeft context


//reeks bits over de seriele poort - 00110001
char x = Serial.read()
Serial.println(x)
//1

//reeks bits over de seriele poort - 00110001
unsigned int x = Serial.read()
Serial.println(x)
//49

Hoeveel tekens telt de tekst in de bovenstaande afbeelding?

4

Seriële Data: Line Ending

Het teken dat je mee geeft op het einde van een regel meegeeft

"Enteren"

2 mogelijkheden / 4 combinaties

CR - Carriage Return

LF (NL) - Line Feed (Newline)

OS Afhankelijk in tekstfiles

Windows - LF

Linux / OSX - LF + CR

Serial

begin
available
read
print
println

Begin

Meegeven baudrate

Mogelijkheid voor uitgebreide UART config

Standaard 8N1

Serial.begin(9600,SERIAL_8N2)

Available

Elke loop de buffer uitlezen?

Efficienter om bit te controleren

Geeft het aantal beschikbare bytes weer

Read

Leest maar 1 teken uit

Na uitlezen is het teken verwijderd uit de buffer

Blijven uitlezen totdat de RX Buffer leeg is

RX Buffer is maar 64 chars

Een string is een char array

Een UART module kan niet detecteren hoeveel frames er gaan aankomen

Data casten of ingebouwde read variaties gebruiken

Print(ln)

Vele varianten

Verstopt in de libraries

Functie overload van de write functie

Voorbeeld


int BAUDRATE = 19200;

void setup()
{
  Serial.begin(BAUDRATE);
  Serial.println("Setup Complete");
}

void loop(){
  if (Serial.available() > 0){
    Serial.print("Data Ontvangen: " );
    Serial.println(Serial.read());
  }
}

Formateren van print statements


void setup(){
  //setup all the things
  Serial.begin(9600);
}

void loop(){
  //dothis
  Serial.print(valueOfThis);
  //dothat
  Serial.println(valueOfThat);
}


valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat
valueOfThisvalueOfThis
valueOfThisvalueOfThat


void setup(){
  //setup all the things
  Serial.begin(9600);
}

void loop(){
  //dothis
  Serial.print("The Value of This is: ");
  Serial.println(valueOfThis);
  //dothat
  Serial.print("The Value of That is: ");
  Serial.println(valueOfThat);
  Serial.println("");
  //
}


The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

The Value of This is: 85
The Value of That is: Charel

Oefening #1

Maak een programma waarbij je wacht tot dat er een integer word ingegeven op de seriële monitor. Hierna lees je 3 integers uit.

Oefening #2

Maak een programma waarmee je een string naar je programma kan wegschrijven op de Arduino. De string word ingegeven via de seriele monitor. Je mag enkel gebruik maken van Serial.read(). De uitgelezen string word weggeschreven in een char array.

Oefening #3

Maak de functie Serial.parseInt() na door gebruik te maken van Serial.read(). Dit voor getallen van tot 999.

SPI

Serial Peripheral Interface

Master / Slave

Een master

Meerde slaves

Synchrone communicatie

Maakt gebruikt van vier lijnen

CLK (SCLK, SCK)

MOSI

MISO

Het sturen en ontvangen word volledig door de master bepaald.

Response moeten handmatige geprogrammeerd worden

Frequent gebruik voor communicatie met IC

SPI Modes

CPHA = 0 - Sample eerste edge clock

CPHA = 1 - Sample op eerste edge clock

CPOL = 0 - Sample op rising edge clock

CPOL = 1 - Sample op failing edge clock

I²C

Inter - Integrated Circuit

a.k.a. Two Wire Interface

SDA - Serial Data

SCL - Serial Clock

Synchrone communicatie

Multi - Master / Multi - Slave

Multi Master

Elke master kan met elke slave communiceren

Master kunnen niet met elkaar communiceren

Master moeten om te beurt communiceren

Slaves kunnen niet met elkaar communiceren

I²C Data Transfer

Idle State
Start Signal
Clock Signal
Send Address

Read / Write
Acknowledge
Data Transfer
Acknowledge
Stop Signal

I²C Valid Data

Data is geldig als de klok hoog is
Uitgezonderd

Start Signal
Stop Signal

I²C Data Transfer

Idle State

Logisch hoog signaal in rust

Pull Up weerstanden

Klok pulst niet

Start Signal

SDA gaat naar een laag signaal
Klok start nog niet

I²C Data Transfer

Clock Signal

Puls begint

Send Address

Adres van de slave word verstuurd
Bit 1 - 7

I²C Data Transfer

Read / Write

Master geeft de actie aan

0 = Write
1 = Read

Bit 8

Acknowledge

Slave bevestigd ontvangst
Slave verstuurd een 0
Bit 9

I²C Data Transfer

Data Transfer

Master of slave verstuurd de data
Afhankelijk van read or write actie
8 Bits

Acknowledge

Verstuurd door ontvanger
Logisch laag signaal

Stop Signaal

Verstuurd door master
SDA gaat hoog als SCL hoog is

I²C Arduino voorbeeld

Master Reader


#include <Wire.h>

void setup() {
  Wire.begin();        
  Serial.begin(9600);  
}

void loop() {
  Wire.requestFrom(8, 6);    
  while (Wire.available()) {
  char c = Wire.read(); 
  Serial.print(c);     
  }

  delay(500);
}

Slave Sender


#include 

void setup() {
  Wire.begin(8);
  Wire.onRequest(requestEvent); 
}

void loop() {
  delay(100);
}

void requestEvent() {
  Wire.write("hello "); 
}

Bit Banging

Een hardware probleem, software matig oplossen
Geen dedicated hardware beschikbaar, emuleren

UART
SPI
...

Mogelijk door sneller MCU


// transmit byte serially, MSB first
void send_8bit_serial_data(unsigned char data)
{
   int i;

   // select device
   output_high(SD_CS);

   // send bits 7..0
   for (i = 0; i < 8; i++)
               {
               // consider leftmost bit
               // set line high if bit is 1, low if bit is 0
               if (data & 0x80)
               output_high(SD_DI);
               else
               output_low(SD_DI);

               // pulse clock to indicate that bit value should be read
               output_low(SD_CLK);
               output_high(SD_CLK);

               // shift byte left so next bit will be leftmost
               data <<= 1;
               }

               // deselect device
               output_low(SD_CS);
               }

SoftwareSerial

Bitbangen van een seriële poort
Arduino kan gebruikt worden voor het aansturen van een andere device

AT commandos

Software Serial


SoftwareSerial esp8266(2, 3);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("Started");

  // set the data rate for the SoftwareSerial port
  esp8266.begin(115200);
  esp8266.write("AT\r\n");
}

void loop() {
  if (esp8266.available()) {
    Serial.write(esp8266.read());
  }
  if (Serial.available()) {
    esp8266.write(Serial.read());
  }
}

Waar te gebruiken

Communicatie tussen een Arduino en Bluetooth module

Waarom maken we geen gebruik van D0 en D1?

Oefening #4: Bluetooth Echo

Het is vrij eenvoudig om commandos van onze GSM naar een Arduino te sturen

Wat hebben we nodig:

Arduino

Bluetooth Module (HC - 05 3.3V Module)

Serial Monitor App (Gratis te vinden in de Play Store)

Bluetooth Terminal

Apple users vallen uit de boot

Oefening #4: Bluetooth Echo

Aansluiten: Waar moeten we rekening mee houden

TTL Niveaus

TX en RX omwisselen

Opdracht:

Maak een echo applicatie waarmee je de string die verstuurd word over bluetooth getoond word op de seriele monitor