Proiecte cu blocuri: 111 · Arduino · ESP32 · Pico
Programare cu blocuri pentru proiecte Arduino, ESP32 și Pico
Urmărește blocuri colorate în loc să citești codul linie cu linie. Proiecte BlueGrays cu versiune pe blocuri: 111; fiecare bloc corespunde unei linii din codul real care rulează pe placă.
Ce este programarea cu blocuri?
Programarea cu blocuri înseamnă că alcătuiești un program din blocuri asemănătoare unor piese de puzzle, în loc să-l scrii. „Setează pinul ca ieșire”, „aprinde LED-ul” și „așteaptă 1 secundă” sunt fiecare câte un bloc, iar prin suprapunerea lor se construiește programul. Fără puncte și virgulă, paranteze sau greșeli de scriere, așa că te poți concentra pe logică.
BlueGrays folosește propriul set de blocuri, iar blocurile vorbesc limba ta: dacă aplicația este în engleză, blocurile spun „repeat forever” și „write HIGH to pin”. În proiectele Arduino și ESP32 blocurile corespund codului C++; în proiectele Raspberry Pi Pico corespund codului MicroPython.
Scopul nu este să rămâi mereu la blocuri, ci să înțelegi codul. Pune blocurile unui proiect lângă codul lui și vezi ce face fiecare linie. După câteva proiecte începi să citești codul și fără blocuri.
Cum funcționează programarea cu blocuri în BlueGrays
În aplicație, blocurile se află în secțiunea de cod a fiecărui proiect cu blocuri. Patru pași:
- 01
Alege un proiect cu blocuri
Proiectele cu insigna de blocuri vin cu o versiune cu blocuri. Poți filtra lista ca să afișezi doar proiectele cu blocuri.
- 02
Activează „Arată ca blocuri”
Un comutator din secțiunea de cod transformă codul în blocuri. Atinge imaginea ca s-o deschizi pe tot ecranul și mărește-o.
- 03
Înțelege blocurile
Fila „Înțelege blocurile” te conduce prin program pas cu pas, arătând la fiecare pas doar blocurile respective și ce fac ele.
- 04
Treci la codul real
Dezactivează comutatorul și același program apare ca cod. Copiază-l în Arduino IDE (sau în Thonny pentru Pico) și încarcă-l pe placă.
Un singur program: blocuri și cod
În stânga, blocurile proiectului. În dreapta, codul care rulează pe placă. Fiecare bloc are o linie de cod corespunzătoare.
Blocuri

Cod
1// ─────────────────────────────────────────
2// BlueGrays · bluegrays.com
3// LED Blink
4// ─────────────────────────────────────────
5// Blinks a single LED on and off every 100 ms. Shows the basic use of the
6// digitalWrite and delay functions.
7//
8// Pins:
9// D9 -> LED (with a 220 ohm resistor)
10
11void setup() {
12 pinMode(9,OUTPUT); // LED pin as output
13}
14
15void loop() {
16 digitalWrite(9,HIGH); // Turn the LED on
17 delay(100); // Wait 100 ms (1000 ms = 1 s)
18 digitalWrite(9,LOW); // Turn the LED off
19 delay(100);
20}
21Proiecte cu blocuri
Toate proiectele cu versiune cu blocuri, pe platforme. Proiectele gratuite sunt primele: 31 dintre ele sunt complet gratuite, cu tot cu blocuri și cod.
Proiecte ArduinoProiecte cu blocuri: 74

LED intermitent
Primul salut din lumea electronicii: aprinzi și stingi un singur LED. Arduino-ul aprinde și stinge LED-ul la intervale foarte scurte, astfel încât lumina clipește rapid.

Două LED-uri care clipesc alternativ
Două LED-uri clipesc rapid, pe rând: când unul se aprinde, celălalt se stinge, de parcă și-ar pasa o minge. Arduino-ul ține fiecare LED aprins o cincime de secundă, apoi trece la celălalt.

Semafor
O copie în miniatură a semaforului pe care îl vezi zilnic pe stradă. LED-ul roșu stă aprins două secunde, cel galben se aprinde pentru scurt timp, iar cel verde stă aprins două secunde.

Girofar de poliție cu LED-uri
Ca luminile unei mașini de poliție: LED-ul roșu clipește rapid de trei ori, apoi cel albastru clipește de trei ori, iar secvența se repetă fără pauză.

Lumini secvențiale cu LED-uri
Lumini care se aprind una după alta, de parcă ar alerga. Arduino-ul aprinde pe rând șase LED-uri: fiecare luminează pentru o clipă, apoi se stinge.

Efect Knight Rider cu LED-uri
Efectul cunoscut sub numele Knight Rider: un punct luminos se deplasează de la un capăt la celălalt al unui șir de șase LED-uri, apoi revine.

Lumini secvențiale cu LED-uri și viteză reglabilă
Șase LED-uri se aprind unul după altul, iar lumina pare să alerge de la un capăt la celălalt.

Efect Knight Rider cu LED-uri și viteză reglabilă
O lumină aleargă de la un capăt la celălalt al unui șir de șase LED-uri, apoi se întoarce.
Proiecte Arduino: toate proiectele cu blocuri
- AR-9Aprinderea unui LED cât timp apeși butonulGratuit
- AR-10Aprinderea și stingerea unui LED cu un butonGratuit
- AR-11Măsurarea intensității luminii cu un LDRGratuit
- AR-12Lampă de veghe cu LDRGratuit
- AR-13Utilizarea unui buzzerGratuit
- AR-14Reglarea frecvenței unui buzzerGratuit
- AR-27Măsurarea distanței cu HC-SR04 (Serial Monitor)Gratuit
- AR-37Citirea unui contact reedGratuit
- AR-45Configurarea modulului de ceas RTC DS1302Gratuit
- AR-55Temperatură și umiditate cu DHT11Gratuit
- AR-61Utilizarea unei tastaturi matriceale 3x4Gratuit
- AR-16Citirea codurilor unei telecomenzi IR
- AR-17Aprinderea și stingerea LED-urilor cu receptor IR și telecomandă
- AR-19Aprinderea unui bec de 230 V cât timp ții apăsat butonul
- AR-20Aprinderea și stingerea unui bec de 230 V cu un buton
- AR-21Aprinderea unui bec de 230 V cu telecomanda
- AR-22Sistem de avertizare cu laser
- AR-23Sistem de securitate cu laser
- AR-24Detector de mișcare cu senzor
- AR-25Sonerie și lumină cu senzor de mișcare
- AR-26Pian simplu cu buzzer și butoane
- AR-28Senzor de parcare cu HC-SR04
- AR-29Afișarea unui mesaj pe un ecran LCD 2x16
- AR-30Text animat care ricoșează pe LCD
- AR-31Măsurarea distanței cu afișare pe LCD
- AR-32Utilizarea unui ecran LCD prin I2C
- AR-33Proiect de măsurare a înălțimii
- AR-34Controlul unui LED de pe telefon prin Bluetooth
- AR-35Utilizarea unui servomotor
- AR-36Controlul unui servomotor cu un potențiometru
- AR-38Senzor pentru ușă cu contact reed
- AR-39Utilizarea unui LED RGB
- AR-40Tranziții line între culori cu un LED RGB
- AR-42Afișarea numerelor 0-99 pe un afișaj cu 7 segmente
- AR-43Contor cu afișaj cu 7 segmente și butoane
- AR-44Măsurarea temperaturii cu NTC și afișaj LCD 2x16
- AR-46Ceas RTC DS1302 cu afișaj LCD
- AR-47Afișarea 0-9.999 pe un afișaj cu 7 segmente și 4 cifre
- AR-48Ceas digital cu afișaj cu 7 segmente și 4 cifre
- AR-49Animație de bombă cu afișaj cu 7 segmente și 4 cifre
- AR-50Utilizarea unui senzor de flacără
- AR-51Utilizarea unui senzor de gaz
- AR-52Alarmă cu senzori de flacără și de gaz
- AR-53Citirea identificatorului RFID
- AR-54Autentificare prin RFID
- AR-56Voltmetru digital cu afișaj LCD
- AR-58Comunicare bidirecțională între 2 plăci Arduino
- AR-59Controlul LED-urilor cu un joystick
- AR-60Controlul servomotoarelor cu un joystick
- AR-62Controlul LED-urilor cu o tastatură matriceală 3x4
- AR-63Utilizarea unei tastaturi matriceale 4x4
- AR-64Încuietoare cu cod, tastatură matriceală 4x4 și LCD
- AR-67Utilizarea unui motor pas cu pas
- AR-68Servomotor de 360 de grade dintr-un motor pas cu pas
- AR-69Utilizarea unei benzi LED WS2812B
- AR-70Girofar de poliție cu WS2812B
- AR-71Lumină în mișcare cu WS2812B
- AR-72Lumină în mișcare cu WS2812B (efect de umplere)
- AR-73Efect Knight Rider cu WS2812B
- AR-74Efect Knight Rider cu WS2812B (3 LED-uri)
- AR-75WS2812B, animația 1
- AR-77Detectarea reflexiei (proximității) cu TCRT5000
- AR-78Detectarea suprafețelor albe și negre cu TCRT5000
- AR-82Iluminat inteligent pentru scări și coridoare
- AR-83Stație inteligentă de irigare
- AR-95Test de reacție cu Arduino și semnal sonor: măsoară-ți reflexele în milisecunde (LCD + buzzer + 3 LED-uri)
Proiecte ESP32Proiecte cu blocuri: 23

LED intermitent cu ESP32
Învață să folosești o ieșire GPIO pe ESP32. Aprinzi și stingi un LED de la un pin digital pentru a obține un efect intermitent. Este versiunea pentru ESP32 a proiectului clasic de pe Arduino UNO: comenzile de bază din mediul Arduino sunt aceleași, dar dispunerea pinilor și nivelurile GPIO de 3,3 V ale plăcii ESP32 diferă de cele ale plăcii Arduino UNO.

Controlul unui LED cu buton pe ESP32 (la apăsare)
LED-ul rămâne aprins cât timp ții apăsat butonul și se stinge când îl eliberezi. Înveți să folosești un pin de intrare digitală și rezistorul pull-up intern al plăcii ESP32. Modul INPUT_PULLUP elimină nevoia unui rezistor extern pentru buton.

Controlul unui LED cu buton pe ESP32 (comutare)
La fiecare apăsare a butonului, LED-ul își schimbă starea: dacă este aprins, se stinge, iar dacă este stins, se aprinde. Este un exemplu clasic de comutare. Prin filtrarea oscilațiilor contactelor (debounce), obții o singură schimbare la fiecare apăsare.

LED-ul integrat al plăcii ESP32: aprindere intermitentă
Fă LED-ul albastru integrat al plăcii ESP32 DevKit V1 să clipească. Nu ai nevoie de componente externe! Este primul proiect de încercat când îți cumperi o placă ESP32. LED-ul integrat este conectat la GPIO 2.

Semafor cu ESP32
Simulează un semafor cu 3 LED-uri: roșu, galben și verde. Duratele sunt apropiate de cele din trafic: roșu lung, galben scurt, verde lung. Un exemplu clasic de control secvențial al pinilor GPIO.

Efect Knight Rider cu LED-uri și ESP32
6 LED-uri se aprind pe rând de la stânga la dreapta, apoi de la dreapta la stânga, în stil Knight Rider. Un exemplu simplu de folosire a buclelor for și a tablourilor, prin care înveți logica schimbării direcției.

Variația lină a luminozității unui LED cu PWM pe ESP32
Modifică lin luminozitatea LED-ului de la 0 la maxim și înapoi la 0. Controlezi PWM cu analogWrite(), ca pe Arduino; aceeași sintaxă funcționează fără probleme cu ESP32 Arduino Core 3.0+. Sunt suficiente definirea pinului, pinMode și analogWrite.

Controlul unui LED RGB cu ESP32
Obții nenumărate culori cu un singur LED RGB în loc de 3 LED-uri separate. Ca pe Arduino, reglezi valorile R/G/B cu analogWrite() pentru a crea o tranziție prin culorile curcubeului. Descoperi în practică amestecul culorilor, de exemplu roșu + verde = galben.
Proiecte ESP32: toate proiectele cu blocuri
- ES-11Citirea intensității luminii cu ESP32 și un modul LDRGratuit
- ES-14Măsurarea ultrasonică a distanței cu ESP32 și HC-SR04Gratuit
- ES-15Temperatură și umiditate cu ESP32 și DHT22 (cu afișaj LCD)Gratuit
- ES-20Alarmă de gaz și fum cu ESP32 și MQ-2Gratuit
- ES-21Cititor de carduri RFID RC522 cu ESP32 (cu LCD)Gratuit
- ES-7Efect de girofar de poliție cu ESP32
- ES-10Lampă de veghe cu ESP32 și LDR
- ES-12Redarea unei melodii cu ESP32 și un buzzer
- ES-13Reglarea luminozității unui LED cu ESP32 și un potențiometru (analogic → PWM)
- ES-16Servomotor cu ESP32 (control prin potențiometru)
- ES-17Afișaj LCD I2C cu ESP32 (16x2)
- ES-18Ceas digital cu ESP32 și DS1307 RTC (I2C + LCD)
- ES-19Iluminat automat cu ESP32 și senzor de mișcare PIR
- ES-23Afișaj TM1637 cu 4 cifre și 7 segmente cu ESP32
- ES-24Controlul unei benzi WS2812B NeoPixel cu ESP32
Proiecte Raspberry Pi PicoProiecte cu blocuri: 10

Clipirea LED-ului integrat pe Raspberry Pi Pico (Pico și Pico W)
Primul proiect din seria Raspberry Pi Pico! Faci să clipească LED-ul verde integrat pentru a verifica funcționarea plăcii, experimentul clasic de început, de tip „Hello World”. Nu ai nevoie de componente externe, doar de Pico și un cablu USB. Codul este scris în MicroPython, limbaj susținut oficial de Raspberry Pi Foundation.

Controlul unui LED extern cu Raspberry Pi Pico (breadboard)
Următorul pas după LED-ul integrat pe Pico: conectează un LED extern pe breadboard și controlează-l prin pinul GP14. Înveți să folosești un pin GPIO ca ieșire, să identifici polaritatea LED-ului (terminal lung = anod/+, terminal scurt = catod/–) și de ce este obligatoriu un rezistor de limitare a curentului (220Ω). Fără rezistor, prin LED trece prea mult curent și acesta se poate arde.

Clipirea alternativă a două LED-uri cu Raspberry Pi Pico
Următorul pas după un singur LED pe Pico: animația clasică în care două LED-uri clipesc pe rând. Un LED se stinge când celălalt se aprinde, un exemplu simplu de control al mai multor pini GPIO. Două LED-uri de culori diferite (roșu pe GP14, verde pe GP13) își inversează stările la fiecare 500 ms. Cu metoda Pin.toggle() din MicroPython, codul rămâne scurt și ușor de citit.

Semafor cu Raspberry Pi Pico (3 LED-uri în secvență)
Recreează un semafor cu LED-uri roșu, galben și verde, în primul proiect Pico cu 3 LED-uri! Verdele indică „treci” timp de 4 secunde, galbenul „pregătește-te” timp de 1,5 secunde, roșul „oprește” timp de 3 secunde, iar roșul și galbenul împreună „pornire” timp de 1 secundă, după secvența europeană. Înveți să definești funcții (def all_off()), să folosești logica unei mașini de stări și să sincronizezi mai mulți pini GPIO.

Girofar de poliție cu Raspberry Pi Pico (roșu + albastru)
Simulează cât mai simplu girofarul unei mașini de poliție cu Raspberry Pi Pico! LED-urile roșu și albastru se aprind alternativ: când roșul este aprins, albastrul este stins, iar la fiecare 0,3 secunde își schimbă starea, la nesfârșit. Codul execută direct cei doi pași într-o singură buclă while True, iar viteza se reglează prin constanta WAIT_MS.

Girofar cu Raspberry Pi Pico: serii de 3 clipiri (2 LED-uri)
O variantă ritmică a girofarului de poliție, cu serii de 3 clipiri! Circuitul rămâne același (GP11 roșu + GP12 albastru), dar secvența diferă: LED-ul roșu clipește rapid de 3 ori, apoi cel albastru de 3 ori, la nesfârșit. Acest ritm de serii alternate este caracteristic girofarurilor de poliție. Înveți să definești funcția cu parametri def burst(led, count, duration_ms), să creezi ritmuri și să obții efecte vizuale diferite prin cod, pe același circuit.

Aprindere și stingere LED din buton cu Raspberry Pi Pico
Buton și LED, la nivelul următor! Apeși și eliberezi: LED-ul se aprinde. Repeți: se stinge. Nu trebuie să ții butonul apăsat. Circuitul rămâne același (LED pe GP14, buton pe GP2), dar codul diferă. Înveți detectarea frontului descendent (trecerea 1→0), memorarea stării anterioare și filtrarea oscilațiilor mecanice ale contactelor (debounce). Metoda led.toggle() din MicroPython schimbă starea într-o singură linie.

Raspberry Pi Pico: variația luminozității unui LED prin PWM (efect de respirație)
LED-ul nu mai doar clipește, ci respiră! Cu PWM (modulație în lățimea impulsurilor) pe Raspberry Pi Pico, luminozitatea LED-ului crește lent, apoi scade lent, creând un efect calm de „respirație”, ca indicatorul unui laptop în repaus. Înveți să folosești clasa machine.PWM, valoarea luminozității pe 16 biți, între 0–65535, cu duty_u16(), și frecvența PWM.
Proiecte Raspberry Pi Pico: toate proiectele cu blocuri
Pentru cine este?
Copii și părinți
Programarea pentru copii se fixează mult mai bine când se termină cu un LED care se aprinde pe birou. Blocurile fac programul ușor de citit, iar circuitul îl construiți împreună.
Profesori și cluburi
La o oră de robotică sau STEM poți explica un proiect mai întâi cu blocuri, apoi poți trece la codul lui. Fiecare proiect are lista de piese și schema electrică gata pregătite.
Începători
Programarea cu blocuri pentru Arduino este cea mai rapidă cale de a înțelege logica în primele proiecte. Începe cu blocuri și treci la cod când te simți pregătit.
Întrebări frecvente
Ce este programarea bazată pe blocuri?
Este un mod de programare în care comenzile apar ca blocuri care se îmbină ca piesele de puzzle, în loc de text scris. Fiindcă nu poți face greșeli de scriere, începătorii și copiii înțeleg mai ușor logica unui program.
Câte proiecte BlueGrays vin cu blocuri?
Acum 111: Arduino 76, ESP32 25 și Raspberry Pi Pico 10. Lista crește pe măsură ce sunt convertite mai multe proiecte.
Este programarea cu blocuri gratuită?
Aplicația este gratuită. Blocurile și codul a 31 proiecte cu blocuri sunt deschise tuturor. La celelalte proiecte, blocurile se deblochează cu Premium, la fel ca și codul.
Pot încărca blocurile direct pe placă?
Nu. Blocurile fac programul mai ușor de citit și de înțeles; pe placă ajunge întotdeauna codul real al proiectului. Îl copiezi în Arduino IDE, sau în Thonny pentru Pico, și îl încarci.
Pot construi propriile programe cu blocurile?
Încă nu. Pregătim noi blocurile pentru fiecare proiect și le potrivim unu la unu cu codul, așa că blocurile pe care le vezi reprezintă întotdeauna un program testat, care funcționează.
Prin ce diferă de Scratch sau mBlock?
În Scratch și mBlock tragi blocuri pe computer ca să-ți scrii propriul program. În BlueGrays fiecare proiect cu blocuri vine cu schemă electrică, listă de piese și codul real, iar blocurile sunt o versiune ușor de citit a acelui cod. Cele două se completează.
Este potrivit pentru copii? De la ce vârstă pot începe?
Copiii de circa 9 sau 10 ani, care citesc fluent, pot începe împreună cu un adult. Primele proiecte nu necesită lipire: se construiesc pe breadboard cu LED-uri, butoane și un buzzer.
În ce limbi sunt blocurile?
Engleză, turcă, germană, spaniolă, franceză și italiană. Blocurile apar în limba în care folosești aplicația.

