Flashcard per lo studio – utilizzare Anki

Visto che siamo in vacanza riprendo i miei appunti sull’organizzazione dello studio, iniziata con le schede Quick Reference, tutto con l’idea di realizzare in un futuro un manuale con esempi da fornire agli studenti. Ho ripreso lo studio delle lingue e quindi ho pensato di realizzare qualcosa in merito all’uso delle flashcard strumento che ritengo utile.

Parto da una domanda che mi è stata fatta da uno studente di seconda superiore poco prima delle vacanze natalizie:

“Prof, ma lei come studiava quando aveva la nostra età?”

È una domanda che torna spesso, e ogni volta mi ricorda una cosa importante: molti studenti immaginano che esista un “metodo segreto”, una tecnica risolutiva che rende lo studio facile e veloce. La mia risposta, invece, è sempre piuttosto disarmante: non studiavo in modo così diverso da voi. Riassunti, schemi, appunti ordinati… e soprattutto flashcard.

Le flashcard, però, non erano una soluzione “magica”. Erano uno strumento semplice, che funzionava solo a una condizione: usarle con costanza, a piccole dosi, nel tempo. Ho sempre pensato che nello studio valga una regola che sembra banale ma è decisiva: meglio poco, ma ripetuto nel tempo. È questo che trasforma un ripasso occasionale in un apprendimento stabile. E naturalmente, con gli anni, ognuno costruisce il proprio equilibrio: c’è chi rende più efficaci gli schemi, chi preferisce i riassunti, chi trova nelle flashcard la leva migliore per fissare concetti, definizioni, formule o passaggi procedurali.

Oggi, quando mi capita di usare le flashcard per imparare (ad esempio per le lingue o per memorizzare lessico tecnico), mi affido spesso ad Anki. Non perché sia “l’ennesima app per fare flashcard”, ma perché introduce un’idea molto concreta: invece di ripassare tutto allo stesso modo e negli stessi momenti, ti aiuta a ripassare solo ciò che serve, quando serve. Ti porta a fare una cosa che tende a essere faticosa ma estremamente efficace: provare a ricordare attivamente prima di guardare la risposta. E quel tentativo di richiamo, ripetuto con regolarità, è spesso la differenza tra “l’ho letto” e “lo so”.

Per gli studenti questo significa ridurre l’effetto delle maratone dell’ultimo minuto e costruire memoria a lungo termine con un metodo più sostenibile. Per i docenti significa avere uno strumento che rende più gestibile il ripasso distribuito e la personalizzazione, senza limitarsi al classico “ripasso pre-verifica”.
C’è poi un aspetto che, a scuola, conta più di quanto sembri: Anki è un progetto libero e open source (in particolare nella versione desktop), sostenuto da una comunità ampia e da un ecosistema di estensioni. In pratica, non sei legato a una piattaforma chiusa: puoi costruire nel tempo un archivio di materiali che resta tuo, riutilizzabile e migliorabile anno dopo anno.

Nei paragrafi che seguono vediamo cosa rende Anki diverso da altri strumenti di studio, quali vantaggi offre in modo concreto e come iniziare con un tutorial essenziale e due esempi pratici, subito adattabili alle vostre discipline.

Gli appunti che seguono sono una sintesi del manuale che trovate sul sito di riferimento e che ho riformulato e sintetizzato, troverete poi alcuni esempi di flashcard sull’uso di Arduino.

Anki nello studio

C’è un momento che studenti e docenti conoscono bene: hai studiato “davvero”, magari anche con impegno costante, eppure dopo pochi giorni ti accorgi che alcuni passaggi si sono sfilacciati. Non è (solo) una questione di volontà, è più spesso una questione di come ripassi e quando lo fai.

Anki è un programma di flashcard “intelligenti” che pianifica per voi il ripasso: vi mostra una domanda, vi chiede di rispondere, poi usa il vostro feedback per decidere quando rivedrete quella stessa informazione. In altre parole: voi pensate ai contenuti, Anki si occupa del calendario del ripasso.

Anki nasce esattamente per rispondere a questo problema quotidiano: non vi chiede di studiare di più, vi aiuta a sprecare meno. Invece di ripassare tutto allo stesso modo e nello stesso momento, vi porta a rivedere ciò che state per dimenticare, quando serve davvero. La logica di fondo è quella di allenare il cervello con due leve molto concrete: richiamo attivo (provare a ricordare prima di controllare) e ripetizione distanziata (rivedere a intervalli crescenti).

Perché Anki è interessante rispetto ad altri applicativi

  1. Trasforma lo studio passivo in apprendimento che resta
    Rileggere, sottolineare, “ripassare scorrendo” sono abitudini comprensibili: danno l’idea di essere produttivi. Ma spesso si basano sul riconoscimento, non sul recupero. Quando invece vi trovate davanti a una domanda e dovete rispondere senza aiuti, state facendo ciò che il manuale chiama test di richiamo attivo: è faticoso, sì, ma è proprio quella fatica “buona” che rende la memoria più stabile.
  2. Ripassate meno, ma meglio (ripetizione distanziata)
    Il cervello tende a scartare in fretta ciò che non viene usato. Ecco perché il ripasso “a ondate” (tutto la sera prima) funziona male sul lungo periodo. Anki applica invece la ripetizione distanziata: ciò che ricordate bene torna dopo più tempo; ciò che vi è difficile ricompare prima. Il risultato pratico è semplice: non ripassate “a caso”, ma in modo mirato, con intervalli che crescono mentre la memoria si consolida.
  3. È personalizzabile: funziona per materie diverse e livelli diversi
    Anki non è “solo per le lingue” o “solo per medicina”. Se una cosa si può chiedere in forma di domanda (e verificare con una risposta), allora si può allenare con Anki: definizioni, formule, passaggi di procedure, date, classificazioni, concetti chiave e potete farlo anche con materiali ricchi: immagini, audio, video, notazione scientifica (LaTeX/Math).
  4. Open source e free: vantaggi concreti
    Qui Anki ha un valore particolare, soprattutto a scuola:

    • Desktop open source: il codice di Anki è pubblicato con licenza GNU AGPL v3 o successiva (con alcune parti sotto licenze differenti, come indicato nel repository). Questo significa continuità, verificabilità e un progetto che non dipende da una “scatola chiusa”.
    • Ecosistema di add-on: Anki si estende con componenti aggiuntivi, spesso nati da bisogni reali di docenti e studenti (lingue, layout, gestione, workflow).
    • Controllo e portabilità dei materiali: puoi esportare e trasferire mazzi “impacchettati” con contenuti e media, utile per backup e condivisione ragionata.
    • Multi-piattaforma e sync: esiste un servizio di sincronizzazione gratuito (AnkiWeb) per tenere allineati i contenuti tra dispositivi.
    • Android open source: AnkiDroid è su GitHub e dichiara licenze libere (GPL-3.0, con componenti specifiche sotto altre licenze).

Nota utile per evitare equivoci: su iOS l’app ufficiale AnkiMobile è a pagamento; la pagina App Store spiega che le vendite finanziano lo sviluppo.

  1. Un “sistema” più che un’app
    Molti strumenti per flashcard si fermano al “fronte/retro”. Anki, invece, è un piccolo sistema di studio: statistiche, ricerca, tag, opzioni di pianificazione, modelli delle carte, sincronizzazione, backup. Per chi vuole ottimizzare ulteriormente, oggi esiste anche un pianificatore alternativo (FSRS) integrato nelle opzioni.

Mini-tutorial usare Anki

Continua a leggere

Sensori e attuatori lontani da Arduino: guida pratica al cablaggio corretto

Metto in evidenza la mia risposta ad una domanda di un utente in riferimento ai problemi causati dalla lunghezza delle linee che collegano Arduino ai dispositivi elettronici.

Marco sei gentilissimo, grazie 🙂
Immagino che tu ti stia riferendo ai collegamenti diretti dei tuoi dispositivi elettronici ad Arduino, è un problema tipico che mi trovo spesso ad affrontare, inoltre l’attività di automazione del controllo di un plastico di trenini è qualcosa che spesso viene svolto a scuola.

Di seguito ti faccio una lista di problemi e soluzioni in riferimento alle problematiche di collegamento, sono molto sintetiche perché sono tratte dalle slide per i miei studenti, quindi sono quasi un copia ed incolla dalle slide sono strutturate a lista puntata con sintesi di spiegazione spero sia sufficiente per risolvere il tuo problema.

Spero di non spaventare con la risposta, in realtà mentre scrivo è diventata una guida sulle possibili cause del problema che stai riscontrando, credo che tu possa risolvere seguendo i 3 passi che trovi alla fine di questa risposta, (al fondo dove scrivo: “ATTENZIONE giusto per non spaventare“), credo che risolverai al PASSO 1.

Allora come dici: perché “allungando i fili di 2 metri il giochino non funziona più?”

Le cause possono essere:

1. Caduta di tensione sui cavi (power)
A 2 m il cavo introduce resistenza: se il dispositivo assorbe corrente (anche solo un relè, un servo o una striscia LED), la tensione arriva più bassa al carico.
Sul banco hai 5V applicati al dispositivo, sul plastico può diventare “4.4–4.7 V” e alcuni moduli iniziano a fare cose strane (reset, letture errate, relè che non agganciano, servo che impazziscono).

Sintomi tipici: Arduino che si resetta quando scatta un relè/servo, sensori instabili, moduli che “a volte sì a volte no”.

2. Disturbi elettromagnetici e ritorni di massa (ground)
Nel plastico ci sono spesso motori, bobine, elettromagneti, alimentatori switching: generano disturbi. Con cavi lunghi aumenta l’area del “loop” e quindi la sensibilità ai disturbi.
In più, se la massa (GND) non è distribuita bene, il riferimento logico “0 V” non è più uguale dappertutto: per Arduino un “HIGH” può non essere più così HIGH 🙂

Sintomi tipici: ingressi digitali che cambiano da soli, finecorsa che “rimbalzano” anche senza toccarli, comunicazioni che falliscono.

Precisazione: quando dico area di “loop” intendo l’area racchiusa dal percorso andata + ritorno della corrente

  • andata: dal pin Arduino (o dall’alimentazione) verso il componente tramite il filo del segnale o del +V
  • ritorno: dal componente che torna a GND (massa) e rientra verso Arduino/alimentatore

Questi due fili (andata e ritorno) formano, di fatto, una spira. Più i due conduttori sono lontani tra loro, più la spira ha area grande.

Una spira con area grande:

  • capta disturbi (si comporta come un’antenna “ricevente”)
  • irradia disturbi (si comporta anche come un’antenna “trasmittente”), soprattutto se nel loop scorrono correnti impulsive (relè, motori, servo)

Ti faccio un esempio pratico che riguarda il tuo progetto:

  • caso “peggiore”: cavo del segnale che va da solo lungo il plastico, e il ritorno GND passa da un’altra parte (magari su una barra massa distante). Loop grande > più problemi.
  • caso “migliore”: segnale e GND viaggiano vicini (idealmente intrecciati). Loop piccolo > molto più robusto.

Come risolvere in questo caso

Per ogni collegamento “lungo”:

  • porta SEMPRE insieme segnale + GND (o +V + GND) nello stesso cavo
  • meglio ancora: usa doppino intrecciato (twisted pair): riduce l’area del loop e quindi la sensibilità ai disturbi

3. Linee di segnale troppo “deboli” (capacità + riflessioni)

Un cavo lungo aggiunge capacità e a volte riflessioni/ringing (fronti ripidi su linee non terminate).
Se stai usando bus come I²C o SPI, 2 metri sono spesso già fuori specifica senza accorgimenti.

Sintomi tipici: sensori I²C che non vengono più visti, display che si bloccano, letture non valide, bus che va in errore.

Vediamo ora come risolvere

Continua a leggere

Buone feste a tutti

Un grazie sincero agli studenti e ai colleghi per la collaborazione, il confronto continuo e per le idee condivise che, passo dopo passo, trasformano le attività in qualcosa di concreto e significativo.

Grazie a tutte le persone che con affetto e costanza seguono il mio sito, ogni visita, commento, messaggio e condivisione è un segnale importante che dà senso al lavoro di documentazione e di divulgazione.

Vi auguro feste serene, un po’ di tempo per ricaricarvi e un nuovo anno ricco di entusiasmo, progetti e piccole grandi scoperte.

Buone feste

STEAM BOX Stargate

Mi è stato chiesto negli scorsi giorni se le STEAM BOX sono oggetti sperimentati con le mie classi, certamente sì non tutte quelle che propongo ma le ho utilizzate durante i corsi di formazione per docenti e con gli studenti, ma non solo per le mie classi, colleghi della secondaria di primo grado, prendendo spunto dai miei suggerimenti ne hanno realizzato altre molto interessanti.

Per un futuro progetto che coinvolgerà le classi prime del mio istituto ne sto realizzando altre che mostro in anteprima nel corso STEAM BOX.

La scorsa settimana ho avuto occasione di rivedere, credo per la quinta volta, STARGATE, film di fantascienza del 1994 e dal film ne ho tratto un semplice gioco didattico che coinvolge diverse discipline del biennio dell’ITIS, di seguito condivido la trama della storia e dettagli fotografici del gioco. Per chi è iscritto al corso condividerò procedura di costruzione, file grafici, template per la creazione di attività simili e molto altro.

La storia introduttiva

Dovete riuscire ad attivare il portale! Potrebbe aprire un varco e riportarvi sulla Terra… o almeno lontano da questo pianeta. Ma il sistema è danneggiato: gli Anelli di Attivazione sono stati rimossi e chiusi in cinque contenitori di sicurezza, ognuno protetto da un codice a 4 cifre.
Sul pannello del manufatto si vedono anche 10 punti di connessione numerati. Dagli antichi schemi che siete riusciti a ricostruire emerge che il portale non è automatico: va ricablato manualmente. Solo collegando con precisione i 5 cavi di energia alle coppie di punti corrette e riposizionando i cinque anelli l’intero circuito si chiuderà. In quel momento, una luce si accenderà attraversando gli anelli e segnando l’attivazione del Gate.

Ora tocca a voi:

  • 5 squadre,
  • 5 anelli da recuperare,
  • 5 codici da decifrare,
  • 5 connessioni da completare.

Avete 60 minuti per risolvere i quesiti, aprire i contenitori, collegare i cavi e tentare l’attivazione del portale. Se ci riuscirete, forse rivedrete la Terra. Se fallirete, resterete bloccati su questo pianeta alieno…

Buon Making a tutti 🙂

Dirimere i conflitti con il pensiero computazionale – educazione civica – sketch Arduino – lezione 03

Ora traduciamo lo pseudocodice in uno sketch Arduino. Usiamo input da Serial Monitor per simulare le scelte e il LED integrato (e un buzzer opzionale) per avere feedback fisico. L’obiettivo non è “automatizzare i conflitti”, ma allenare il pensiero procedurale e la gestione consapevole dei passi. Si faccia riferimento alla lezione precedente (seguire il link) in cui è stato mostrato il diagramma di flusso nella modalità Mermaid e classica.

Nella dimostrazione viene usato un Arduino UNO R4 WiFi.

Di seguito una possibile soluzione, il funzionamento lo trovate nei commenti.

/* Prof. Maffucci Michele
  data: 18.11.25
  Risoluzione di un conflitto
  Input da Serial Monitor

  - LED integrato (pin 13) usato come feedback visivo
  - Buzzer opzionale su pin 5 (beep brevi)
  Istruzioni:
  1) Aprire la Serial Monitor (115200 baud).
  2) Rispondere alle domande con i tasti indicati (y/n, a/f) o premi invio quando richiesto.
*/

const int pinLed = LED_BUILTIN;  // pin 13
const int pinBuzzer = 5;         // pin a cui è connesso il Buzzer
int numeroBeep = 0;

bool chiaveMsg = 0;  // per controllo stampa msg

// emissione della nota
void beep(int durataMs) {
  tone(pinBuzzer, 880);  // nota La4
  delay(durataMs);
  noTone(pinBuzzer);
}

// sequenza di beep ripetuta all'avvio del programma
void sequenzaAvvio() {
  for (int i = 0; i < 10; i++) {
    beep(100);
    delay(100);
  }
}

// Attende che ci sia almeno un carattere sulla seriale e lo legge (minuscolo)
char leggiChar() {
  while (!Serial.available()) {
    // lampeggio lento del LED per indicare "in attesa"
    digitalWrite(pinLed, HIGH);
    delay(200);
    digitalWrite(pinLed, LOW);
    delay(200);
  }

  // Legge un solo byte dalla seriale e lo mette in c (di tipo char).
  // Questo è il primo carattere che l’utente ha inviato.
  char c = Serial.read();

  // Svuota il buffer rimanente leggendo tutto quello che è ancora arrivato
  // (ad esempio il \n dell’invio, o più caratteri se l’utente ha incollato del testo).
  while (Serial.available())
    Serial.read();
  if (c >= 'A' && c <= 'Z')  // Conversione in minuscolo se il carattere è una lettera maiuscola.
    c = c - 'A' + 'a';
  return c;
}

// -- Utility: attende qualsiasi tasto (usata come "invio per continuare")
// “un puntatore a char costante”, cioè una stringa in stile C non modificabile
// (tipicamente una stringa letterale come "Ciao").

void attendiConferma() {
  const char* messaggio = "Premi invio per continuare";
  Serial.println(messaggio);
  while (!Serial.available()) {
    digitalWrite(pinLed, HIGH);
    delay(150);
    digitalWrite(pinLed, LOW);
    delay(150);
  }
  // svuota
  while (Serial.available())
    Serial.read();
  beep(100);
}

// -- Utility: domanda sì/no
bool domandaSiNo(const char* domanda) {
  Serial.println(domanda);
  Serial.println("Digita 'y' per SI, 'n' per NO");

  //ripetiamo finché l’utente non inserisce una risposta valida.
  // Il ciclo si interrompe con un return (es. quando l’utente digita ‘y’ o ‘n’).
  for (;;) {
    char c = leggiChar();
    if (c == 'y') {
      Serial.println("Hai risposto: SI");
      beep(100);
      return true;
    }
    if (c == 'n') {
      Serial.println("Hai risposto: NO");
      beep(100);
      return false;
    }
    Serial.println("Risposta non valida. Usa 'y' o 'n'.");
  }
}

// Pausa "simulata breve" al posto di 2 minuti reali
void pausaBreve(const char* motivo, int secondi = 5) {
  Serial.print("Pausa: ");
  Serial.print(motivo);
  Serial.print(" (");
  Serial.print(secondi);
  Serial.println("s)");
  for (int i = 0; i < secondi; i++) {
    digitalWrite(pinLed, HIGH);
    delay(300);
    digitalWrite(pinLed, LOW);
    delay(700);
    Serial.print(".");
  }
  Serial.println();
  beep(100);
}

void setup() {
  pinMode(pinLed, OUTPUT);
  Serial.begin(115200);
  delay(1000);
  Serial.println("=== Risoluzione Conflitto - VERSIONE BASE ===");
  Serial.println("Benvenuto! Segui le istruzioni sul Serial Monitor.");
  pinMode(pinBuzzer, OUTPUT);
  sequenzaAvvio();
}

void loop() {
  // 1) Sicurezza del confronto
  bool sicuro = false;
  do {
    sicuro = domandaSiNo("E' sicuro parlare adesso?");
    if (!sicuro) {
      Serial.println("OK, facciamo un time-out breve al posto di 2 minuti.");
      pausaBreve("time-out", 5);
    }
  } while (!sicuro);

  // 2) Definizione del problema
  Serial.println("Definisci il problema in UNA frase (in classe va bene scriverla su carta).");
  attendiConferma();

  // 3) Turni + Parafrasi
  bool parafrasiOk = false;
  do {
    Serial.println("Turno A (60s simulati).");
    attendiConferma();
    Serial.println("Turno B (60s simulati).");
    attendiConferma();
    parafrasiOk = domandaSiNo("Parafrasi reciproca corretta?");
  } while (!parafrasiOk);

  // 4) Opzioni di soluzione (almeno 2)
  int numeroOpzioni = 0;
  Serial.println("Genera almeno 2 opzioni di soluzione.");
  for (;;) {
    Serial.println("a = aggiungi opzione, f = fine (consentita solo se >= 2 opzioni)");
    char c = leggiChar();
    if (c == 'a') {
      numeroOpzioni++;
      Serial.print("Opzione aggiunta. Totale: ");
      Serial.println(numeroOpzioni);
      beep(100);
    } else if (c == 'f') {
      if (numeroOpzioni >= 2) {
        Serial.println("OK, passiamo alla decisione.");
        beep(100);
        break;
      } else {
        Serial.println("Servono almeno 2 opzioni prima di terminare.");
      }
    } else {
      Serial.println("Scelta non valida. Usa 'a' o 'f'.");
    }
  }

  // 5) Decisione finale
  bool accordo = domandaSiNo("C'e' accordo su una opzione?");
  if (accordo) {
    Serial.println("Piano d'azione: definire chi/fa/cosa/entro quando (scrivere su carta).");
    Serial.println("Promemoria: verifica dopo 24 ore.");
    Serial.println("FINE. Riavvio tra 5 secondi...");
    pausaBreve("chiusura", 5);
  } else {
    Serial.println("Coinvolgi un mediatore o rinvia il confronto.");
    Serial.println("Ritorno al controllo 'E' sicuro parlare?'.");
    pausaBreve("ritorno", 3);
  }
}