Introducere - limbajul C, mediul Arduino și primul program

1Obiectivele lucrării

• Instalarea mediului Arduino IDE și configurarea plăcii și a portului de încărcare
• Înțelegerea structurii setup() / loop() și a motivului pentru care există
• Identificarea funcțiilor fiecărui pin al plăcii Arduino Uno
• Alegerea tipurilor de date potrivite pentru un sistem cu 2 KB de RAM
• Comanda unui pin de ieșire și verificarea funcționării prin LED

2Materiale necesare

• 1 Placă Arduino Uno (ATmega328P)
• 1 Cablu USB tip B
• 1 Breadboard
• 1 LED de 5 mm
• 1 Rezistor 220 Ω
• 2 Fire jumper

3Arhitectura plăcii

Placa Arduino Uno este construită în jurul microcontrolerului ATmega328P, un procesor pe 8 biți cu arhitectură Harvard modificată. Resursele lui sunt modeste - și tocmai de aceea fiecare decizie de programare contează.

4Explorator de pini

Apăsați pe orice pin pentru a vedea ce funcții are. Observați că mulți pini au funcții multiple - de exemplu D13 este simultan ceasul SPI și LED-ul de pe placă, iar D0 și D1 sunt ocupate de comunicația serială.

5Structura programului

Un program obișnuit pornește, își face treaba și se termină. Un program pentru microcontroler nu se termină niciodată: cât timp placa este alimentată, procesorul trebuie să execute ceva. Mediul Arduino impune de aceea două funcții:

/* Cele doua functii pe care le scrieti dumneavoastra in schita: */
void setup() { /* codul VOSTRU de initializare */ }
void loop()  { /* codul VOSTRU, repetat la nesfarsit */ }

/* ...iar mediul Arduino adauga singur, in spate, exact atat: */
int main(void)
{
    init();          // configureaza timerele si ADC-ul, apelata automat

    setup();         // o singura data, la pornire

    for (;;) {       // bucla infinita
        loop();      // la nesfarsit
    }
    return 0;        // nu se ajunge niciodata aici
}

6Simulator de execuție

Urmăriți pas cu pas ordinea reală a execuției: setup() rulează o singură dată, apoi loop() se reia la infinit. Observați valoarea contorului static, care demonstrează că funcția chiar este apelată repetat.

7Tipuri de date pe AVR

Calificatori importanți

8Schema de montaj

9Cod sursă

Programul minimal - Blink

const uint8_t LED_PIN = 8;    // const + uint8_t: nu ocupa RAM inutil

void setup() {
  pinMode(LED_PIN, OUTPUT);   // pinul devine iesire
}

void loop() {
  digitalWrite(LED_PIN, HIGH);  // aprinde
  delay(500);                   // asteapta 500 ms
  digitalWrite(LED_PIN, LOW);   // stinge
  delay(500);
}

Aceeași funcționalitate, la nivel de registru

Funcțiile pinMode() și digitalWrite() există doar în mediul Arduino. Aceleași operații scrise direct pe regiștri funcționează pe orice compilator AVR și se execută de aproximativ 50 de ori mai rapid:

void setup() {
  DDRB |= (1 << PB0);           // pinul 8 devine iesire  (echiv. pinMode(8, OUTPUT))
}

void loop() {
  PORTB |=  (1 << PB0);         // pinul 8 pe HIGH        (echiv. digitalWrite(8, HIGH))
  delay(500);
  PORTB &= ~(1 << PB0);         // pinul 8 pe LOW         (echiv. digitalWrite(8, LOW))
  delay(500);
}

Depanare fără ecran: LED-ul ca instrument

Microcontrolerul nu are ecran. Până la lucrarea a șasea, când veți învăța comunicația serială și veți putea trimite text către calculator, singurul instrument de depanare pe care îl aveți este chiar LED-ul: îl folosiți ca să arătați că programul a ajuns într-un anumit punct sau ca să „afișați” un număr mic, prin clipiri numărate.

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  static uint8_t contor = 0;    // static: isi pastreaza valoarea intre apeluri
  contor++;

  // "afisam" contorul: cate o clipire pentru fiecare unitate
  for (uint8_t i = 0; i < contor; i++) {
    digitalWrite(13, HIGH);
    delay(150);
    digitalWrite(13, LOW);
    delay(250);
  }

  delay(1500);                  // pauza lunga = s-a terminat "afisarea"
  if (contor >= 5) contor = 0;  // luam de la capat
}

Verificarea memoriei disponibile

Dimensiunile tipurilor le găsiți în tabelul de la capitolul 7. Cât RAM a mai rămas liber se poate afla însă doar în timpul execuției, cu funcția de mai jos. Neavând încă monitorul serial, programul nu tipărește valoarea, ci o semnalizează: dacă memoria liberă scade sub un prag, LED-ul rămâne aprins continuu.

// Returneaza numarul de octeti liberi intre heap si stiva
int memorieLibera() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  if (memorieLibera() < 256) {
    digitalWrite(13, HIGH);       // alarma: memorie aproape epuizata
  } else {
    digitalWrite(13, LOW);
  }
  delay(500);
}

10Montaj interactiv

Montajele de mai jos rulează codul chiar în pagină, pe un ATmega328P simulat. Nu este o animație: PORTB chiar comandă pinul, LED-ul se aprinde pentru că bitul 5 a devenit 1, iar ceasul de 16 MHz curge la fel ca pe placa reală. Apăsați Pornește, apoi schimbați codul și porniți din nou.

void setup() {
  pinMode(13, OUTPUT);      // pinul 13 devine iesire
}

void loop() {
  digitalWrite(13, HIGH);   // aprinde
  delay(500);               // asteapta 500 ms
  digitalWrite(13, LOW);    // stinge
  delay(500);
}

/* Punct = 200 ms aprins, linie = 600 ms aprins.
   Intre semnale: 200 ms pauza. Intre litere: 600 ms pauza. */

void punct() {
  digitalWrite(13, HIGH);
  delay(200);
  digitalWrite(13, LOW);
  delay(200);
}

void linie() {
  /* Completati: la fel ca punct(), dar aprins 600 ms */
}

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  punct(); punct(); punct();     // S
  delay(400);
  /* Completati: trei linii pentru O, apoi trei puncte pentru S,
     apoi o pauza lunga de 2000 ms inainte de a relua. */
}

11Sarcini de lucru

• Instalați Arduino IDE, selectați placa Arduino Uno și portul serial corect.
• Încărcați programul Blink și verificați funcționarea LED-ului de pe placă (D13).
• Montați un LED extern cu rezistor de 220 Ω pe pinul D8 și modificați programul.
• Calculați curentul prin LED și verificați că se încadrează sub 20 mA.
• Modificați intervalele astfel încât LED-ul să fie aprins 100 ms și stins 900 ms.
• Rulați programul de verificare a dimensiunilor și notați valorile pentru int și long.
• Verificați experimental capcana int t = 1000 * 60; și corectați-o cu sufixul L.
• Afișați memoria RAM liberă și observați cum scade după declararea unui tablou de 200 de int.

12Aplicație de aprofundare

13Întrebări de verificare

14Resurse

• Îndrumarul acestei lucrări (PDF)
• Îndrumarul complet de laborator
• Pagina cursului - toate materialele