Show page

Differences

This shows you the differences between two versions of the page.

--- info2:laboratoare:02 [2020/03/03 13:25]
liviu.moraru
+++ info2:laboratoare:02 [2021/03/09 14:55] (current)
alexandru.vochescu [Exerciții]
@@ Line 1: / Line 1: @@
-===== Laboratorul 02 - Operații GPIO =====
+===== Laboratorul 02 - Introducere în Python =====
 ===== Scop =====
-  * familiarizarea cu operațiile legate de pinii arduino
   * familiarizarea cu conceptele de bază din programare
+  * interacțiunea cu placa de dezvoltare folosind Python
 ===== Cuvinte cheie =====
-  * pinMode, digitalWrite, HIGH, LOW, LED
   * for, if, while, vector
+  * basic, music
+  * show_string, show_number, show_leds, clear_screen, pause
+  * play_tone, start_melody
 ===== Concepte de programare =====
 ==== Variabile ====
-Variabilele sunt moduri în care referențiem valori de anumite tipuri.
+Variabilele sunt moduri în care referențiem valori de anumite tipuri. Spre deosebire de limbaje de programare precum C sau C++, în python tipurile de date sunt identificate în momentul inițializării.
-<code c variabile.c>
-#include <stdio.h>
-int main(void)
+Câteva exemple de tipuri din python sunt:
-{
+<code python variabile.py>
-      int variabila_numar = 10;
+x = 2                                                           #int    - număr întreg
-      char variabila_caracter = 'c';
+x = 2.7                                                         #float  - număr cu zecimale
-      float variabila_numar_zecimale = 10.25;
+x = "c"                                                         #char   - caracter ASCII
-      return 0;
+x = True                                                        #bool   - valoare logică: True/False
-}
 </code>
+Odată ce a fost asignat un tip de date, putem reasigna alt tip printr-o nouă inițializare (ca mai sus), însă anumite tipuri de date nu pot fi combinate, de exemplu: să adunăm un număr întreg la un șir de caractere.
 ==== Șiruri / Vectori ====
 Șirurile/Vectorii sunt variabile mai inteligente de o anumită dimensiune ce pot stoca un șir de valori de fiecare tip de mai sus. Exemplu:
-<code c variabile.c>
+<code python variabile.py>
+x = "Hello Python!!!"                                           #string - șir de caractere, declarat direct folosind ""
+x = ['h', 'e', 'l', 'l', 'o']                                   #string - declarat ca vector de caractere ASCII
+x = [2, 3.2, 21, 12]                                            #array  - vector de numere
+</code>
-#include <stdio.h>
+Un lucru atipic la Python față de multe limbaje de programare clasice, este faptul că acesta ne permite să avem valori din tipuri diferite de date în cadrul aceluiași vector (numere întregi, șiruri de caractere și valori logice).
-int main(void)
-{
-      int sir[6];
-      int sir2[] = { 1,2,3,4,5,6};
-      char sir3[] = {'a', 'b', 'c', 'd'};
-      char sir[6] = "salut";
-      return 0;
-}
-</code>
 ==== If - Else ====
-Propoziția if este o propoziție condițională folosită pentru a executa instrucțiuni în funcție de anumite condiție construcția if-else se traduce prin "dacă - altfel":
+Propoziția if este o propoziție condițională folosită pentru a executa instrucțiuni în funcție de anumite condiții. Construcția if-else se traduce prin "dacă - altfel":
-<code c if_else.c>
+<code python if_else.py>
+a = 10
+if a == 10:                         # Dacă a este egal cu 10
+   a = a / 2                        # Fă operații dacă a este 10
+else:                               # Altfel
+   a = a * 2                        # Fă operații când a este diferit de 10
+</code>
-#include <stdio.h>
+<note important>Blocul de cod care trebuie executat este identificat prin numărul de aliniate, deci aveți mare atenție la indentarea codului!</note>
-int main(void)
-{
-      int a = 10;
-      if (a == 10) { //dacă a este egal cu 10
-          // Fă operații când a este 10
-      } else { // Altfel
-          // Fă operații când a este diferit de 10
-      }
-      return 0;
-}
-</code>
 ==== For ====
 Structura for este o structură repetitivă în funcție de o condiție. Mod de utilizare:
-<code c for.c>
+<code python for.py>
+fruits = ["măr", "cireșe", "pară", "banană"]
-#include <stdio.h>
-int main(void)
+# for element în vector_de_elemente:
-{
+for f in fruits:
-      //for(inițializare, condiție, operație) {}
+  print(x)
-      int i;
-      for (i = 0; i <= 10; i++) {
-          printf("%d ", i); // Afișează i;
-      }
-      return 0;
-      // Codul de mai sus va afișa: 0 1 2 3 4 5 6 7 8 9 10
+# Codul de mai sus va afișa: măr cireșe pară banană
-}
+# Alternative mai apropiate de C:
+# for element în range(valoare maximă care nu va fi atinsă):
+for x in range(6):
+  print(x)
+# Codul de mai sus va afișa: 0 1 2 3 4 5
+# for element în range(valoare inițială, valoare maximă care nu va fi atinsă, valoare de increment)
+# Ultima valoare poate lipsi din construcție, fiind implicită valoarea de 1
+for x in range(2, 10, 2):
+  print(x)
+# Codul de mai sus va afișa: 2 4 6 8
 </code>
 ==== Parcurgerea unui șir ====
 Accesarea unei anumite valori dintr-un vector se face prin index-ul(poziția) valorii din vector.
-<code c vector.c>
+<code python vector.py>
+v = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+sum = 0
-#include <stdio.h>
+print(v[3])                    # afișează valoarea de pe poziția 4: 4 (indexarea se face începând de la 0)
-int main(void)
+for i in range(len(v)):
-{
+  sum = sum + v[i]
-      int i;
-      int vector[] = {1,2,3,4,5,6,7,8,9};
+print(sum)                     # afișează 55
-      int sum = 0;
+# O altă alternativă de calcul al sumei ar fi fost:
-      printf("%d\n", vector[2]); // Afișează 3
+for element in v:
+  sum = sum + element
-      for (i = 0; i < 9; i++) { // Pozițiile în vector încep de la 0!!
-          sum = sum + vector[i]; // Suma tuturor elementelor din vector
-      }
-      return 0;
-}
 </code>
-==== Funcții ====
+===== Interacțiunea cu simulatorul în Python =====
-Funcţiile împart taskuri complexe în bucăţi mici mai uşor de înţeles şi de programat. Acestea pot fi refolosite cu alte ocazii, în loc să fie rescrise de la zero. De asemenea, funcţiile sunt utile pentru a ascunde detalii de funcţionare ale anumitor părţi ale programului, ajutând la modul de lucru al acestuia. Utilizând funcţii, care reprezintă unitatea fundamentală de execuţie a programelor C, se obţine o divizare logică a programelor mari şi complexe.
-<code c vector.c>
-#include <stdio.h>
+Pentru a putea interacționa cu simulatorul, fiecare din funcțiile expuse în Python de către placă trebuie prefixate cu "basic" (care este obiectul în care se află funcțiile respective).
-void afiseaza(int number) {
+Un exemplu de astfel de funcție este scrierea unui șir de caractere pe ecran:
-    printf("%d\n", number);
+<code python>
-}
+basic.show_string('Hello!')
+</code>
-int main(void)
+==== Interacțiunea cu led-urile de pe placă ====
-{
-    int x = 10;
+Funcțiile principale pe care le avem la dispoziție sunt:
+  * Afișarea unui șir de caractere pe ecran:
-    afiseaza(10); // Va afisa valoarea 10
+<code python>
+basic.show_string('Hello!')
-    return 0;
+</code>
-}
+  * Afișarea unui număr pe ecranul de led-uri:
+<code python>
+basic.show_number(0)
+</code>
+  * Afișarea unei imagini din led-uri:
+<code python>
+basic.show_leds("""
+    . # . # .
+    # # # # #
+    # # # # #
+    . # # # .
+    . . # . .
+    """)
+# Se va afișa o inimă din Led-uri
+# # - semnifică led aprins
+# . - semnifică led stins
 </code>
-===== Operații pini arduino =====
-Pentru a folosi pinii unui arduino trebuie să setăm modul în care dorim să îi folosim (INPUT/OUTPUT). Exemplu:
+  * Stingerea tuturor led-urilor de pe placă:
-<code arduino.c>
+<code python>
-void setup() {
+basic.clear_screen()
-    pinMode(PINUL_MEU, INPUT);
+</code>
-    pinMode(PINUL_MEU2, OUTPUT);
+  * Întârzierea execuției programului cu un anumit număr de milisecunde:
-}
+<code python>
-void loop() {
+basic.pause(1000)
-}
 </code>
-Dacă am setat un pin pe modul OUTPUT, acum putem elibera voltaj pe acest pin folosind digitalWrite. Exemplu:
+==== Sunete folosind Python ====
+Funcții pentru redarea sunetelor folosind simulatorul de Microbit:
+  * Redarea unei singure note folosind obiectul "Note":
+<code python>
+freq = Note.D
+music.play_tone(Note.C, 1000)
+</code>
-<code arduino.c>
+  * Redarea unei melodii o singură dată:
-void setup() {
+<code python>
-    pinMode(PINUL_MEU, INPUT);
+melody = music.built_in_melody(Melodies.ENTERTAINER)      # Vom folosi o melodie predefinită
-    pinMode(PINUL_MEU2, OUTPUT);
+music.start_melody(melody, MelodyOptions.ONCE)            # Redă o singură dată melodia
-}
+</code>
-void loop() {
-    digitalWrite(PINUL_MEU, HIGH); //Pe acest pin avem acum 5v
-    delay(3000); // Așteaptă 3 secunde
-    digitalWrite(PINUL_MEU, LOW); //Acum avem 0v pe acest pin
-}
+  * Redarea unui sample până când se termină acel sample:
+<code python>
+soundExpression.giggle.play_until_done()
 </code>
+Funcționalitățile explicate mai sus, dar și altele pot fi găsite în [[https://makecode.microbit.org/reference|documentație]].
 ===== Exerciții =====
-Toate exercițiile vor fi realizate pe [[https://www.tinkercad.com/| Tinkercad]]
+  - Generați o secvență de imagini care să apară pe ecran la un anumit interval de timp.
-  - Folosind un **VOLTMETRU** masurați voltajul de pe pinul GPIO 3. Setați pinul pe LOW/HIGH și observați cum se modifică valorile.
+  - Generați o secvență folosind ecranul din LED-uri. Veți genera mai întâi o imagine, iar după 2 secunde de întârziere, vă veți scrie prenumele (de preferat prescurtat) sau o poreclă. În final după încă o întârziere de 200 de milisecunde, veți aprinde toate led-urile de pe plăcuță (simularea umplerii ecranului).
-  - Folosind un **ARDUINO**, un **LED** și o **REZISTENȚĂ de 220 ohmi**, aprindeti LED-ul **(NU folositi pinii GPIO)**, apoi masurați curentul și voltajul circuitului.
+  - Afișați pe ecranul format din led-uri numerele de la 1 la 10.
-  - Folosind un **ARDUINO**, un **LED** și o **REZISTENȚĂ de 220 ohmi**, faceți un LED să clipească (rezolvați exercițiul în 2 modalități).
+  - Afișați pe ecran numerele pare de la 1 la 20.
-  - Folosind un **ARDUINO**, **LED-uri** și **REZISTENȚE de 220 ohmi**, simulați un semafor de mașini și un semafor de pietoni care să fie sincronizate. Semafoarele vor fi implementate folosind led-uri și parcurgerea acestora trebuie făcută cu **șiruri/vectori** (rezolvați exercițiul în 2 modalități).
+  - Parcurgeți numerele de la 1 la 30: dacă numărul este divizibil cu 5, afișați o inimă, dacă numărul este divizibil cu 3 (dar nu și cu 5), afișați o față zâmbitoare, iar în orice alt caz afișați o față tristă.
-  - Conectați la un **ARDUINO**, un **7 SEGMENT DISPLAY** și folosind funcții ajutătoare, afișați fiecare număr (0-9) pe display. Rezolați în 2 modalitați: folosind un **7 SEGMENT DISPLAY** cu **anod comun**, respectiv cu **catod comun**.
+  - Generați un vector de 20 de elemente aleatoare între 0 și 100. Apoi parcurgeți vectorul generat și calculați numărul de elemente care sunt divizibile cu 10 și numărul de elemente divizibile cu 9. Dacă numărul de elemente divizibile cu 10 este mai mare, afișați o față zâmbitoare pe ecran. În caz contrar, afișați o față tristă. **Hint**: pentru generarea de elemente aleatoare, uitați-vă în secțiunea Math, la funcția //randint//.
-  - Folosind montajul anterior implementați un numarator ce afiseaza cifrele de la 0 la 9.
+  - Modificați proiectul anterior pentru a găsi numărul prim cel mai mare din vector și se va afișa pe ecran. Dacă nu există niciun număr prim în vector, se va genera o secvență în care toate led-urile se aprind de 3 ori cu o întârziere de 500 ms între ele.
-{{:info2:laboratoare:arduino-7-segment-display.png?200|100}}
+  - Modificați proiectul anterior astfel încât în caz de succes se va cânta melodia "Entertainer", iar dacă numărul nu este găsit se va reda melodia "Funeral". Se va folosi funcția //music.built_in_melody//.
+  - Căutați pe google notele pentru melodia "Twinkle Twinkle little star" și creați un vector cu notele respective. Apoi folosiți funcția //play_tone// pentru a reda melodia.
+  - Adaptați proiectul anterior pentru a genera câte o imagine diferită pentru fiecare notă care este redată.
+  - Creați un proiect nou în care veți reda aceeași melodie, folosind funcția //music.play_melody// (mai multe detalii în platformă, în meniul de //music//, primul bloc). Încercați să adaptați codul pentru a genera imagini în mod similar exercițiului anterior.
+  - Implementați redarea primelor note din melodia preferată. Modificați diverse variabile precum tempo-ul și volumul.
+  - Redați un sample precum cel din laborator și afișați o față zâmbitoare.

Laboratoare

Laboratories

Lab 02 - GPIO operations

Resources

info2/laboratoare/02.1583234729.txt.gz · Last modified: 2020/03/03 13:25 by liviu.moraru

Show page Old revisions

Media Manager Back to top