Ca în toate lucrările de inginerie, bug-uri pot și vor apărea si în sisteme incorporate. În condiții de funcționare, este important să avem o modalitate de comunicare cu dispozitivul integrat. Pentru o imagine de ansamblu asupra metodelor de depanare posibile, vom face o scurtă introducere, apoi vom studia în detaliu interfața serială USART, folosită în mod uzual pentru comunicația serială dintre două dispozitive.

Motivul pentru care depanarea embedded este mai dificilă decât depanarea obișnuită a software-ului provine din mai multe probleme:

• Un începător este obișnuit cu instrumente de nivel înalt generice, de cele mai multe ori gratuite (de ex. IDE-uri, debuggere etc). Pentru sistemele embedded, este posibil ca user-ul sa nu aibă acces la instrumente hardware si software dedicate.
• Dacă nu aveți un debugger specializat și încercați să utilizați unul generic (să spunem Remote GDB), ce vă face să credeți că aveți stiva de rețea necesară pentru acel debugger? Dacă ați implementat o astfel de stivă, cât de sigur sunteți că funcționează corect?
• Chiar dacă ați avut un debugger specializat (de exemplu, o sondă Lauterbach), cel mai probabil veți avea nevoie de configurații specializate pentru debugger, pentru a lucra cu hardware-ul vostru (de exemplu, Practice Scripting Language for Lauterbach T32)
• Depanarea invazivă poate afecta comportamentul codului vostru - gândiți-vă la RTOS (sisteme de operare în timp real), SMP (sisteme multiprocesor) sau la circuitul dvs. (de exemplu, modificați circuitul pentru a măsura intensitatea curentului).
• Hardware-ul dvs. ar putea avea erori.
• Chiar și tipărirea mesajelor de eroare ar putea să nu funcționeze, deoarece uneori trebuie să implementați o astfel de funcție și ar putea avea bug-uri în sine.

Cu toate acestea, principiile de debugging sunt aceleasi ca si în cazul software-ul de nivel înalt: Trebuie sa comparați ce se dorește de la sistem (cod / circuit) cu ceea ce, de fapt, face si, pentru asta, ai nevoie de vizibilitate.

Vizibilitatea la nivel hardware se realizează printr-o formă de InputOutput (dacă este disponibilă):

• Depanare LED - verificarea stării true/false
• mesaje pe interfața serială / USART - depanare prin USART, bluetooth, etc
• Debuggere avansate pentru afisarea si modificarea memoriei / registrelor (a se vedea JTAG de mai jos)
• Loopbacking (conectarea ieșirilor la intrări) poate oferi informații despre modul în care comenzile sunt trimise dispozitivelor externe.

Instrumente de măsurare:

• Multimetre (pentru valori statice)
  • Rezistență: Doar conectați o componentă de circuit între sonde.
  • Tensiune: conectați în paralel - sonda pozitivă (roșie) la punctul potențial mai mare, sonda negativă (neagră) la punctul potențial mai mic. Pentru potențialul într-un singur punct: sonda negativă la GND, sonda pozitivă în punctul dorit.
  • Curent: conectați-vă în serie.
  • Începeți întotdeauna prin a seta scara multimetrului la maxim, apoi corectați progresiv scara până când aveți cea mai precisă măsurare.
  • Pentru a verifica polaritatea diodelor: Selectați verificare diodă. Daca plasați sonda negativă pe anod și sonda pozitivă pe catod, multimetrul va face un sunet.
  • Pentru a verifica scurtcircuite/conectivitate: Utilizați verificare diodă – daca aparatul emite un sunet atunci înseamnă că există un scurtcircuit/conexiune între acele două puncte.

• Osciloscoape (pentru valori dinamice - Electroboom explică mai bine decât noi)

• Analizoare logice (pentru semnale digitale)
• Analizoare de protocol (pentru protocoale încorporate, ar fi I2C, SPI, etc)
• Debuggere bazate pe JTAG - pot avea funcții foarte avansate: citire/modificare memorie, interoperarea cu kernelul, oprire ceas sistem, etc

Un exemplu de flux de depanare ar putea fi următorul:

• Verificați de două ori foaia de catalog și schema. Accesați registrele potrivite? Sunt perifericele conectate la pinii la care am crezut că sunt?
• Este posibilă depanarea prin mesaje de debug (echivalent printf)?:
• Ai o stivă ethernet? Dacă da, ia în considerare SSH, NFS, etc pentru a realiza debugging printf.
• În cazul în care aveti o stiva de rețea, poate sunt disponibile protocoale mai simple: UART? Putem conecta ceva prin UART? Poate un PC, modul HC-05 Bluetooth, un LCD?
• Se poate lua în considerare depanarea cu LED-uri.
• Izolați problema folosind instrumente de măsura: multimetre, osciloscoape, analizoare logice.
• Încercați un debugger JTAG sau orice alt depanator despre care știți că funcționează cu dispozitivul dvs.

Interfața serială este cel mai facil mod de a comunica cu microcontroller-ul vostru pentru citirea de date sau trimiterea de comenzi. Din perspectiva microcontroller-ului, comunicația serială se bazează pe doar două linii de date:

• linie pentru transmisie, notată Tx,
• linie pentru recepție, notată Rx.

Comunicația este full-duplex, se poate transmite concomitent cu recepția.

Transmisia asincronă de date se face la nivel de cadre (frames), fiecare cadru fiind format din mai mulți biți, având formatul descris în figură.

Se transmite un bit de start, apoi un cuvânt de date. Urmează un bit de partitate, opțional, cu rolul de a face o verificare simplă a corectitudinii datelor, și unul sau doi biți de stop.

Microcontroller-ul Atmega328p include un periferic USART (Universal Synchronous-Asynchronous Receiver/Transmitter) pentru interfața serială. În partea de inițializare a acestui periferic trebuie efectuați următorii pași:

• alegerea vitezei pentru transmisia de date - baud rate-ul (valori uzuale: 9600, 19200, 38400, 57600, 115200)
• alegerea formatului cadrului (câți biți de date, de stop, dacă va conține sau nu bit de partitate)
• activarea transmisiei și recepției datelor pe liniile RX și TX.

RXB și TXB sunt buffer-ele de recepție, respectiv transmisie. Ele folosesc aceeași adresă de I/O. Deci RXB este accesat citind din UDRn, TXB scriind în UDRn. Buffer-ul de transmisie poate fi scris numai atunci când bitul UDRE (USART Data Register Empty) din portul UCSRnA este 1. În caz contrar, scrierile vor fi ignorate.

UCSRnA este registrul de stare al controller-ului de comunicație. Biții cei mai importanți sunt:

• RXCn – Receive Complete – devine 1 când există date primite și necitite. Când buffer-ul de recepție este gol, bitul este resetat automat
• TXCn – Transmit Complete – devine 1 când buffer-ul de transmisie devine gol
• UDREn – Data Register Empty – devine 1 când buffer-ul de transmisie poate accepta noi date

UCSRnB este un registru de control. Biții importanți:

• RXCIEn – Receive Complete Interrupt Enable – când este 1, controller-ul de comunicație va genera o întrerupere când au fost primite date
• TXCIEn – Transmit Complete Interrupt Enable – când este 1, controller-ul de comunicatie va genera o întrerupere când buffer-ul de transmisie devine gol
• UDRIEn – Data Register Empty Interrupt Enable – când este 1, controller-ul de comunicație va genera o întrerupere când buffer-ul de transmisie mai poate accepta date
• RXENn – Receiver Enable – dacă este 0, nu se pot recepta date
• TXENn – Transmitter Enabler – dacă este 0, nu se pot transmite date
• UCSZn2 – împreună cu UCSZ1 și UCSZ0 din portul UCSRC, selectează dimensiunea unui cuvânt de date

UCSRnC este tot un registru de control. Biții importanți:

• UMSELn – Mode Select – 0 pentru funcționare asincronă, 1 pentru funcționare sincronă
• UPMn1, UPMn0 – Parity Mode - Fiind vorba de doi biți, împreună pot avea 4 valori posibile, detaliate în tabelul ce urmează:

• USBSn – Stop Bit Select – 0 pentru un bit de stop, 1 pentru doi biți de stop

• UCSZn1, UCSZn0 – împreună cu UCSZn2 din portul UCSRnB, selectează dimensiunea cuvântului de date

UBRRn este registrul care selectează baud rate-ul. Are 12 biți. Primii 4 se află în UBRRnH, ceilalți 8 în UBRRnL. Valoarea pe care o scriem în UBRRn depinde de frecvența procesorului și de baud rate-ul dorit. În tabelul următor găsiți valorile pentru cele mai uzuale viteze de transmisie pentru o frecvență de ceas de 16 MHz.

void USART0_init()
{
  /* seteaza baud rate la 9600 */
  UBRR0 = 103;
 
  /* porneste transmitatorul */
  UCSR0B = (1 << TXEN0) | (1 << RXEN0);
 
  /* seteaza formatul frame-ului: 8 biti de date, 1 bit de stop, fara paritate */
  UCSR0C &= ~(1 << USBS0);
  UCSR0C |= (3 << UCSZ00);
}
 
void USART0_transmit(unsigned char data) {
    /* așteaptă până când buffer-ul e gol */
    while(!(UCSR0A & (1<<UDRE0)));
 
    /* pune datele în buffer; transmisia va porni automat în urma scrierii */
    UDR0 = data;
}

(3 << x)

Pentru biți de configurație care se găsesc întotdeauna unul după altul se folosește și o mască cu mai mulți biți shiftați cu index-ul celui mai din dreapta: (3 << UCSZ00) înlocuiește astfel (1 << UCSZ01) | (1 << UCSZ00)

(1 << x) | (1 << y) De cele mai multe ori o să facem măști compuse, pe care le vom aplica unui registru I/O în același timp. Atenție! Pot doar să compun măști pentru aceeași operație, nu pot aplica o mască SAU în același timp cu o mască ȘI pentru că rezultatul ar fi complet eronat!

Arduino UNO se conecteaza la PC prin intermediul interfetei seriale, dar utilizeaza un convertor USB-UART integrat pe placa. Prin intermediul acestei interfete si utilizand IDE-ul dedicat Arduino se poate programa microprocesorul, dar se poate asigura si un canal de debug. Astfel, prin mesaje simple, se poate afla starea sistemului, se pot afisa valorile variabilelor, sau chiar se pot trimite comenzi, interfata functionand bidirectional. Mai multe detalii se pot gasi aici

Următorul program poate trimite mesaje de la Arduino către PC, prin USB (sau folosind emulatorul din Tinkercad)

void setup()
{
  Serial.begin(9600);
  Serial.println("in function setup");
}
 
void loop()
{
  Serial.println("in function loop");
  delay(1000);
}

Următorul program poate primi mesaje trimise de PC, prin USB (sau folosind emulatorul din Tinkercad)

void setup()
{
  Serial.begin(9600);
  Serial.println("astept comenzi");
}
 
void loop()
{
  if (Serial.available()){
    char a = Serial.read();
    char buf[20];
    sprintf(buf, "%s: %c", "primit caracter", a);
    Serial.println(buf);
  }
}

Task 1 (3p)

Folosind interfața serială și biblioteca Arduino, trimiteți următoarele comenzi dintr-un terminal serial:

• “on” - aprinde un led
• “off” - stinge un led
• “blink” – blink un led la interval de 200 ms
• “get” - afișează prin interfața serială starea unui buton apăsat

Fiecare comandă va fi urmată de caracterul de control: “\n” (newline). Configurați terminalul serial să trimită (doar) acest caracter după fiecare mesaj. Implementați un program în Arduino care să recunoască aceste comenzi și să realizeze acțiunile corespunzătoare pentru fiecare dintre ele. Folosiți pin-ul 13 (PB5) pentru LED și pin-ul 2 (PD2) pentru buton.

• Comanda blink va porni funcția blink (blink led “la infinit”)
• Comenzile on/off vor opri funcția blink.

long ts = 0; // global variable is your friend
void loop() {
 // my other code here
 if ((millis() - ts) >= 100) {
    ts = millis();
    // my non-blocking timed loop here
 }
 // my other code here
}

Task 2 (3p)

Rulați exemplul pentru USART pe bază de registre. Pentru configurările serialei, urmăriți fisierul usart.c din schelet.

Schelet

Configurați USART0 cu următorii parametri: baud rate 19200, 8 biți de date, 1 bit de stop, fara paritate. Transmiteți către PC câte un mesaj pentru fiecare eveniment de apăsare/lăsare a unui buton (ex: se apasă PD2, se transmite “PD2 apăsat”, se lasă PD2, se transmite “PD2 lăsat”, câte o singură dată pe apăsare).

Task 3 (4p)

Colaborați cu colegii de lângă voi pentru a conecta două plăci Arduino între ele și trimiteți mesaje, dinspre primul Arduino către al doilea, și invers.

• Mesajele trimise de primul Arduino vor fi afisate în terminalul Serial conectat la cel de-al doilea Arduino, și invers.
• Aprindeți led-ul (PB5) pentru 500 ms atunci când este recepționat un mesaj. Pentru a nu bloca programul (și implicit recepționarea mesajelor), nu folosiți funcția delay.
• Atenție la realizarea conexiunilor (RX1 la TX2, TX1 la RX2, și GND1 la GND2)

Bonus (2p) Realizați implementarea Task 1 pe bază de registre.

• Datasheet Atmega 328p
• Arduino UNO pinout
• 
• Responsabil: Alexandru Predescu