Impara a programmare — da zero

Non hai mai scritto una riga di codice? Perfetto. In questa pagina farai lampeggiare una luce vera e suonare un motivetto a un buzzer vero, scrivendo solo poche righe semplici — niente cavi, niente configurazione, niente da installare. Se sai scrivere una lista della spesa, sai fare anche questo.

Cos'è un programma?

Un programma è semplicemente una lista di istruzioni che una macchina esegue, una alla volta, dall'alto verso il basso — come una ricetta, o i passi di una danza. La macchina è veloce e molto ubbidiente: fa esattamente ciò che hai scritto, nell'ordine in cui l'hai scritto. Niente di più, niente di meno.

Quindi "programmare" vuol dire soprattutto spezzare ciò che immagini in passi piccoli e chiari. "Accendi la luce rossa. Aspetta un secondo. Spegnila." Questo è già un programma.

Il BASIC, e il nostro Chip BASIC

Il BASIC è un linguaggio di programmazione inventato nel 1964 per insegnare ai principianti assoluti — il nome significa letteralmente "Beginner's All-purpose Symbolic Instruction Code", cioè codice di istruzioni simboliche per principianti. Si legge quasi come l'inglese di tutti i giorni, ed è proprio per questo che lo usiamo qui.

La nostra versione si chiama Chip BASIC, ed è due cose in una che usi insieme nello stesso programma: il cuore BASIC di sempre — numeri di riga, GOTO, IF…THEN, LET, variabili e conti, le stesse idee del BASIC dal 1964 — più i nostri comandi che parlano alla scheda: LED, WAIT, SOUND, PLAY, BUTTON e le MISSION intere.

10 LET a = 0
20 LED green, on
30 WAIT 1s
40 LED green, off
50 a = a + 1
60 IF a < 3 THEN GOTO 20
70 MISSION "ALLARME"

Un solo programma, i due strati insieme: il BASIC classico (LET, conti, IF…THEN, GOTO) gestisce il ciclo, e i nostri comandi (LED, WAIT, MISSION) fanno agire la scheda. Non c'è una modalità da cambiare — li mescoli e basta, sulla riga che vuoi.

La regola d'oro del Chip BASIC: ogni riga inizia con un numero (10, 20, 30…). Quei numeri stabiliscono l<em>ordine</em> di esecuzione e danno a ogni riga un nome a cui saltare. Conta di dieci in dieci, non 1-2-3, così potrai <em>infilare nuove righe in mezzo</em> più tardi — una riga tra la <code>10</code> e la <code>20</code> diventa <code>15</code>.

Come funziona Text to Chip

Tu scrivi BASIC. Il browser lo traduce in una lista di istruzioni minuscole e semplici (la chiamiamo bytecode). Un piccolo "lettore" esegue poi quelle istruzioni — o nel Simulatore sullo schermo, o su un chip vero (un ESP32-S3) collegato via USB.

La parte intelligente: è lo stesso programma tradotto in entrambi i posti. Ciò che vedi lampeggiare nel simulatore è ciò che lampeggia sulla scheda vera. Così puoi costruire e provare tutto senza hardware, e poi far girare la stessa identica cosa su un chip vero.

Il tuo primo programma

Facciamo lampeggiare la luce rossa. Apri l'IDE, assicurati che sia selezionato il Simulatore e scrivi queste cinque righe nell'editor:

10 LED red, on
20 WAIT 1s
30 LED red, off
40 WAIT 1s
50 GOTO 10

Ora premi ▶ run (in alto a sinistra). La luce rossa si accende per un secondo, si spegne per un secondo, si riaccende… all'infinito. Hai appena scritto un programma! Premi ■ stop per fermarlo.

Ecco cosa dice ogni riga:

• 10 LED red, on — accendi la luce rossa.
• 20 WAIT 1s — aspetta 1 secondo (la luce resta accesa durante l'attesa).
• 30 LED red, off — spegni la luce rossa.
• 40 WAIT 1s — aspetta un altro secondo (ora resta spenta).
• 50 GOTO 10 — torna alla riga 10 e rifai tutto. È questo che la fa lampeggiare all'infinito.

Come scorrono le righe

Il lettore parte dal numero di riga più piccolo e procede verso il basso: 10, poi 20, poi 30… Se arriva alla fine senza altro da fare, si ferma.

GOTO cambia questo percorso: salta alla riga che indichi. GOTO 10 rimanda il lettore alla riga 10, creando un ciclo — un pezzo che si ripete. I cicli sono ciò che fa continuare il semaforo e lampeggiare la luce.

La cassetta degli attrezzi — ogni istruzione

Queste sono tutte le "parole" che il Chip BASIC capisce e trasforma in azione reale — quelle del BASIC classico e i nostri comandi della scheda, fianco a fianco. Ogni scheda mostra la forma dell'istruzione, cosa fa e un piccolo esempio. Non devi impararle a memoria — torna a sbirciare qui ogni volta che ti serve.

10 LED green, on

20 WAIT 2s

50 GOTO 10

90 END

10 REM blink the light

10 LED red, on : WAIT 1s

30 IF a > 5 THEN LED red, on

30 IF BUTTON("A") THEN SOUND "coin"

10 LET a = 0

20 a = a + 1

40 SOUND "coin"

50 PLAY "c5 e5 g5 c6"

10 GOSUB 100

10 MISSION "SEMAFORO" WITH green=4s

10 MOVE 160 160

20 SERVO 90

10 IF VOICE()="go" THEN MOVE 160 160

10 IF SEE()="person" THEN SOUND "coin"

10 IF SENSOR("radar") < 20 THEN MISSION "ALLARME"

Missioni già pronte

Una missione è un comportamento completo che qualcuno ha già costruito per te. Invece di scrivere riga per riga tutta la danza del semaforo, la richiami in una riga:

10 MISSION "SEMAFORO" WITH green=4s yellow=1s red=4s beep=slow
20 GOTO 10

La parte WITH la regola: quanto dura il verde, la velocità del beep, e così via. Ogni missione consente certe impostazioni entro limiti sicuri (un semaforo non ti lascia spegnere il rosso — sarebbe pericoloso). Quelle disponibili sono nella Libreria nella barra laterale: SEMAFORO, PIANOLA (tastiera), METRONOMO (battito) e ALLARME.

Il modo più facile per cambiare le impostazioni di una missione: clicca la riga MISSION nell'editor — si apre un piccolo modulo con tutte le opzioni, pronto da regolare.

Il catalogo delle missioni

Ecco tutte le missioni che puoi eseguire nel simulatore oggi, per tier. Aprine una dalla Libreria (la griglia nella barra laterale) — oppure scrivi la sua riga, ad es. MISSION "RADAR". Ognuna si regola con WITH, come il semaforo qui sopra.

È parametrizzabile. Aggiungi una clausola WITH per regolare i tempi, il bip e il pulsante:

MISSION "SEMAFORO" WITH green=6s yellow=1s red=4s beep=off|slow|fast button=on|off minGreen=2s

Intervalli: green 2–15s, yellow 0.5–3s, red 2–15s, minGreen 2–10s. beep è off, slow o fast; button è on o off. Le durate accettano decimali o millisecondi (0.5s, 1500ms). Imposta solo i parametri che ti interessano, ad es. MISSION "SEMAFORO" WITH green=4s beep=fast.

Il pulsante pedonale

Con button=on, premere il pulsante è una richiesta di attraversamento: il LED verde lampeggia subito per confermarla, poi la luce passa al rosso appena il verde è durato almeno minGreen (così una pressione non ferma il traffico all'istante). Nel simulatore clicca il pulsante a schermo; sull'hardware collegalo a GPIO 6 (attivo-basso, a GND).

Vincoli di sicurezza fissi

Alcune cose non si possono cambiare — sono vincoli di sicurezza: le luci seguono sempre il ciclo verde → giallo → rosso, una luce alla volta, il bip per i pedoni suona solo sul rosso e una pressione del pulsante non può mai ridurre il verde sotto minGreen.

Fatti aiutare dall'assistente (il tasto @)

Bloccato, o di fretta? In fondo all'editor c'è una casella @ descrivi una modifica. Scrivi cosa vuoi con parole tue — "fai lampeggiare la luce più in fretta" oppure "suona un motivetto allegro quando premo il pulsante" — e l'assistente scrive o modifica il BASIC per te.

Risponde sempre con vere righe di BASIC, direttamente nell'editor — così puoi leggerle, eseguirle e impararci sopra. L'assistente è un insegnante che mostra il suo lavoro, non una scatola nera.

Esecuzione automatica

Nella barra in alto c'è un interruttore Auto-run, attivo per impostazione predefinita. Quando il programma cambia e compila senza errori, viene caricato ed eseguito automaticamente sul backend attivo — così vedi il risultato dal vivo senza dover cliccare tu Carica ed esegui.

Qualche programma completo

Incolla uno qualsiasi di questi nell'editor e premi run. Poi cambia un numero e guarda cosa succede — il gioco è tutto qui.

Un semaforo

10 LED red, on
20 WAIT 5s
30 LED red, off
40 LED yellow, on
50 WAIT 1s
60 LED yellow, off
70 LED green, on
80 WAIT 5s
90 LED green, off
100 GOTO 10

Rosso per 5 secondi, giallo per 1, verde per 5, poi GOTO 10 ricomincia il ciclo. Prova a cambiare i tempi di attesa.

Premi il pulsante → suono della monetina

10 IF BUTTON("A") THEN SOUND "coin"
20 GOTO 10

La riga 10 controlla il pulsante in continuazione (la riga 20 torna subito indietro a controllarlo). Tieni premuto il pulsante A nel simulatore e sentirai il motivo della monetina.

Suona una piccola melodia

10 PLAY "c5 e5 g5 c6"
20 END

Quattro note che salgono, poi finisce. Cambia le note — prova "c5 d5 e5 f5 g5" — ed esegui di nuovo.

Andare oltre

Questi mattoncini sembrano pochi, ma combinandoli ottieni qualsiasi cosa — un pugno di comandi più un po' di logica: un vero programma è tutto qui. Ecco gli schemi che ti portano da "far lampeggiare una luce" a qualcosa che ragiona.

Ripetere un numero esatto di volte

10 LET a = 0
20 LED red, on
30 WAIT 0.3s
40 LED red, off
50 WAIT 0.3s
60 a = a + 1
70 IF a < 5 THEN GOTO 20
80 SOUND "tada"
90 END

Una variabile è una scatolina che ricorda un numero. Qui a conta i lampeggi: la riga 60 ne aggiunge uno a ogni giro, e la riga 70 continua a tornare indietro finché a arriva a 5 — poi una fanfara. Cambia il 5 per ripetere quante volte vuoi.

Riusa un blocco — GOSUB e RETURN

10 GOSUB 100
20 WAIT 1s
30 GOSUB 100
40 END
100 SOUND "coin"
110 LED green, on
120 WAIT 0.5s
130 LED green, off
140 RETURN

Scrivi un blocco una volta e usalo ovunque. GOSUB 100 salta alla riga 100; RETURN riporta il controllo subito dopo la chiamata. Le righe 100–140 sono un blocco "beep + lampeggio" che il programma principale esegue due volte. I programmi grandi si costruiscono da piccoli blocchi riutilizzabili esattamente così.

Ricordare uno stato

10 LET a = 0
20 IF a = 0 THEN LED red, on
30 IF a = 1 THEN LED green, on
40 WAIT 0.5s
50 LED red, off
60 LED green, off
70 a = 1 - a
80 GOTO 20

Una variabile può contenere a che punto sei, non solo un conteggio. Qui a è di chi è il turno — rosso (0) o verde (1) — e a = 1 - a lo ribalta tra 0 e 1 a ogni giro, così le luci si alternano. Quella piccola memoria è ciò che fa decidere al programma nel tempo.

Conti e condizioni combinate

10 LET a = 10
20 LET b = 3
30 IF a > 5 AND b < 5 THEN SOUND "coin"
40 LET a = a - b
50 IF a = 7 THEN LED green, on
60 END

Puoi fare i conti ovunque vada un numero, e unire i test con AND. La riga 30 scatta solo se entrambe le condizioni sono vere; la riga 40 aggiorna a con una sottrazione. Con + - * /, > < =, AND e ABS() esprimi regole vere.

Un robot è una sequenza di missioni

10 MISSION "SEMAFORO" WITH green=2s yellow=1s red=2s
20 MISSION "METRONOMO" WITH beat=0.4s bar=4
30 GOTO 10

L'idea più grande: un intero progetto è solo missioni in fila, guidate dal BASIC che hai imparato. Ogni riga qui è un comportamento completo; GOTO 10 fa ripartire lo spettacolo. Cambia le missioni, aggiungi un IF per scegliere tra loro, conta i giri con una variabile — e stai programmando un robot.

Dove gira il tuo programma

Il flusso di lavoro (uguale per ogni backend)

1. Scrivi @ seguito dalla tua richiesta su una riga dell'editor (l'AI scrive il BASIC), oppure scegli un programma pronto dalla Libreria nella barra laterale. Il programma è BASIC numerato che modifichi direttamente.
2. Scegli dove eseguirlo con l'interruttore Simulatore / Scheda reale.
3. Compila — la console mostra il risultato (numero di istruzioni ed eventuali avvisi).
4. Carica ed esegui — invia il programma e avvia la VM (con Auto-run attivo avviene a ogni modifica).
5. Stop la ferma; scrivi un comando OVERRIDE: su una riga (es. OVERRIDE: STOP o OVERRIDE: SET 4 0) e premi Invio per iniettare una singola istruzione in tempo reale, senza ricaricare.

Falla funzionare da sola (Salva su scheda)

Su una scheda reale, premi Salva su scheda per memorizzare il programma nella flash della scheda ed eseguirlo a ogni avvio. Ora puoi staccare il PC: alimenta la scheda da un qualsiasi caricatore USB o da una batteria e funziona da sola — premi RST per riavviarla. Il programma resta finché non ne salvi un altro o premi Autorun off. È tutto qui il senso: costruisci il comportamento nel browser, poi il chip continua a farlo senza alcun computer collegato.

1 · Simulatore (nessun hardware)

1. Apri https://textochip.com in un browser qualsiasi.
2. Lascia l'interruttore su Simulatore (si connette automaticamente).
3. Clicca Carica ed esegui. I LED a schermo, l'indicatore del buzzer e il pulsante riproducono esattamente ciò che farebbe una scheda reale.
4. Per i programmi che leggono il pulsante, clicca il pulsante a schermo per pilotare il pin di ingresso.

Il simulatore è una VM in TypeScript con lo stesso set di istruzioni e modello a tick del firmware, così un programma che funziona qui si comporta in modo identico sulla scheda.

2 · ESP32-S3 (consigliata, verificata)

Scheda di riferimento: Freenove ESP32-S3-WROOM (USB-C, due porte USB). Flashi il firmware generico Zephyr della VM una volta; dopodiché carichi il bytecode dall'IDE tutte le volte che vuoi — nessun re-flash per cambiare programma.

Ottieni il firmware

La scheda esegue un piccolo firmware generico per la VM costruito con Zephyr. Vive nel suo repo aperto, textochip-runtime; lo compili e lo flashi una volta da lì, poi carichi i programmi dal browser. I passaggi completi, copia-e-incolla, sono nel README di quel repo.

Cosa ti serve

• Scheda ESP32-S3 + cavo USB-C (la Freenove espone due porte USB — si usano entrambe)
• Breadboard, 3 LED (rosso/giallo/verde) + resistori da ~220–330 Ω
• Un buzzer piezo passivo e un pulsante (opzionali)
• La toolchain Zephyr: un workspace west + la Zephyr SDK (vedi la guida Getting Started di Zephyr)

Cablaggio

Questi pin provengono dal profilo della scheda (lib/boardProfile.ts); il compilatore li integra nel bytecode. GPIO 1/2/4/5/6 sono I/O digitali sicuri sull'ESP32-S3.

Compila e flasha il firmware (una volta sola)

1. Prepara la toolchain Zephyr — un workspace west e la Zephyr SDK (la guida Getting Started di Zephyr). I sorgenti del firmware sono nel repo dedicato textochip-runtime (clonalo).
2. Dal clone di textochip-runtime, compila per l'ESP32-S3:

   west build -b esp32s3_devkitc/esp32s3/procpu zephyr

   Esegui west packages pip --install una volta così esptool ≥ 5.0.2 è nel PATH al momento del flash.
3. Collega la porta “USB UART” della scheda (il chip CH343) e flasha con west flash — su questa porta l'auto-reset di esptool in modalità download funziona.
4. Se un flash non riesce ad auto-resettare (ad es. il firmware è già in esecuzione): tieni premuto BOOT, premi RST, rilascia BOOT, poi di nuovo west flash.
5. Due porte, due compiti: flashi dalla porta “USB UART”, ma connetti l'IDE dalla porta “USB OTG” (USB nativo) — non scambiarle.

Connetti ed esegui dall'IDE

1. Apri https://textochip.com in Chrome/Edge/Brave.
2. Sposta l'interruttore su Scheda reale.
3. Clicca Connetti scheda e scegli la porta “USB OTG” (USB nativo) della scheda — appare come CDC_ACM_serial_backend. (Non la porta “USB UART” da cui hai flashato.)
4. Clicca Carica ed esegui. Usa Stop e Override durante l'esecuzione.

3 · Altre schede (Zephyr)

Poiché il firmware è Zephyr, la stessa identica VM, ISA e mission girano su qualsiasi scheda supportata da Zephyr — cambia solo un piccolo file HAL. Il compilatore nel browser, il protocollo seriale e i tuoi programmi .bas restano identici, quindi l'intero flusso dell'IDE è invariato da scheda a scheda.

Cosa cambia per ogni scheda

Solo due cose: i numeri delle GPIO in lib/boardProfile.ts (il compilatore li integra nel bytecode) e una implementazione della HAL — circa 9 funzioni che mappano pin/PWM/clock su quel chip. Poi compili per il target con west build -b <board> zephyr.

Nordic nRF54L (in arrivo)

Il prossimo target è il nRF54LM20 DK. Lo compili con l<b>nRF Connect SDK</b> (lo Zephyr di Nordic): <code>west build -b nrf54lm20dk/nrf54lm20a/cpuapp zephyr</code>, poi <code>west flash</code>. Stesso flusso dellIDE via Web Serial; OVERRIDE via BLE e mission edge-AI sull'NPU Axon verranno dopo.

Il linguaggio, in breve

Un primo programma — un semaforo in loop (Progetto 01):

10 LED red, on
20 WAIT 5s
30 LED red, off
40 LED yellow, on
50 WAIT 1s
60 LED yellow, off
70 LED green, on
80 WAIT 5s
90 LED green, off
100 GOTO 10

Il sottoinsieme eseguibile compila in bytecode: LED, WAIT, GOTO, GOSUB/RETURN, IF … THEN, LET, aritmetica e confronti (inclusi >= <= <>), SOUND/PLAY (bip e melodie), BUTTON("A"), i comandi robot + edge-AI MOVE, SERVO, VOICE(), SEE() (oggetti e colori come "yellow") con SEEX() (dove si trova nell'inquadratura, 0-100) e SEESIZE() (quanto sembra grande, 0-100: piu grande vuol dire piu vicino), DISTANCE() (centimetri) e SENSOR()/AREAD(), e i blocchi MISSION (es. un attraversamento pedonale completo). Le istruzioni che richiedono hardware che questa scheda non ha (GPS, uno schermo…) compilano comunque — generano un no-op e un avviso in console invece di fallire.

Consigli ed errori comuni

• Ogni riga ha bisogno di un numero. Una riga senza (solo LED red, on) non viene eseguita — scrivi 10 LED red, on.
• Conta di dieci in dieci (10, 20, 30) così potrai infilare una nuova riga in mezzo più tardi.
• I tempi vogliono un'unità: WAIT 2s (secondi) o WAIT 500ms (millisecondi). Un WAIT 2 da solo significa 2 millisecondi — quasi niente!
• Un ciclo GOTO non si ferma da solo. Di solito è quello che vuoi (una luce che lampeggia) — premi il pulsante ■ stop per fermarlo.
• La console ti parla. Se qualcosa non va, la console sotto l'editor mostra un avviso giallo o un errore rosso con il numero di riga. Leggilo — sta cercando di aiutarti.
• I piccoli passi vincono. Esegui spesso. Cambia una cosa, esegui, guarda. Impari molto di più da dieci piccoli esperimenti che da una grande supposizione.

Risoluzione dei problemi

• Nessun pulsante “Connetti scheda” / non fa nulla: non sei su un browser desktop Chromium, oppure non sei su HTTPS. Usa Chrome/Edge/Brave su https://textochip.com.
• “no PONG” alla connessione: probabilmente hai aperto la porta “USB UART” (che resetta il chip). Scegli invece la porta “USB OTG” (CDC_ACM_serial_backend); se non funziona ancora, premi RST, attendi ~3 s, riconnetti.
• Porta mancante su Linux: aggiungiti al gruppo dialout (sudo usermod -a -G dialout $USER) ed esci/rientra.
• Non si accende nulla: controlla la polarità dei LED e che i pin cablati corrispondano al profilo della scheda.