Archivi categoria: i miei allievi

Arduino – algebra booleana e funzioni logiche – dai componenti discreti, agli integrati, alla codifica in C

Nuovo Istituto, nuove avventure didattiche. Con le classi di questo nuovo anno scolastico più elettronica e più automazione. Tra gli argomenti che ho rivisto negli scorsi mesi in virtù delle attività che vorrò svolgere, molte sperimentazioni dedicata all’elettronica digitale e all’algebra di Boole, ho riformulato le esercitazioni con componenti discreti che utilizzano i classici integrati TTL 74XX: 7404, 7432, 7408, 7402, 7400, 7486, 74266 corrispondenti alle porte logiche: NOT, OR, AND, NOR, NAND, XOR, XNOR a queste attività aggiungerò, in una fase successiva, la realizzazione delle porte logiche con Arduino, quindi progettazione di semplici shield per la dimostrazione delle tabelle di verità degli operatori logici fondamentali e derivati.

Per rendere più interessante il laboratorio di elettronica, oltre che usare la breadboard, realizzare pcb e saldare, cercherò se il tempo lo permetterà, di far realizzare la scheda Arduino prima su breadboard e poi realizzare una nostra personalissima scheda Arduino con protezioni specifiche sulle uscite digitali ed altro… sogni nel cassetto… vedremo, un passettino alla volta.

Questo articolo è da intendersi come esercitazione e di supporto alla parte teorica ed è dedicata agli studenti delle classi 3′ e 4′ automazione, per lo svolgimento si richiede che gli allievi abbiano seguito un corso base su Arduino. Di seguito senza dilungarmi riprendo alcuni concetti di base che hanno solo l’obiettivo di comprendere meglio la parte sviluppata su Arduino, al fondo due circuiti e due sketch di esempio che potrete migliorare ed espandere.

Avviso per gli studenti

Quest’anno faremo automazione, non solo con PLC ma anche con microcontrollori (Arduino), quindi incominciare a strutturare in C le funzioni logiche sarà essenziale per iniziare a costruire i mattoncini di base dell’automazione, vedremo come costruire altre funzioni nel corso dell’anno.

Premessa (per ripassare velocemente)

I circuiti digitali sono presenti in moltissimi strumenti che utilizzimo ogni giorno, i più noti sono i computer costituiti principalmente da circuiti digitali che, come già sapete, elaborano segnali logici 0 e 1.

Qualsiasi calcolo all’interno di un computer utilizza l’aritmetica binaria e l’adozione di questa aritmetica è stata fatta perché i bit sono rappresentabili in modo semplice tramite dispositivi elettronici in cui è possibile distinguere i 2 stati del potenziale elettrico: high e low a cui si associano i numeri 1 e 0.

Partendo da questi presupposti è possibile costruire un sistema di calcolo che impiega i soli due simboli 0 e 1 che viene chiamato sistema logico binario.

Fu George Boole (1815-1864) che per primo costruì un modello matematico fondato su una logica di tipo binario, tale modello prende il nome di: algebra di Boole.

Come diffusamente esposto durante le lezioni di teoria, l’algebra booleana utilizza equazioni ed espressioni, ma segue le leggi della logica e non quelle dell’aritmetica, per cui le operazioni seguono regole differenti dall’algebra convenzionale.

Le porte logiche realizzano le operazioni logiche dell’algebra binaria.

Porte logiche fondamentali

Somma logica OR

L’operazione può essere effettuata su due o più variabili di ingresso. La somma logica OR assumerà il valore 1 se almeno una delle variabili di ingresso è al valore 1.

Se chiamiamo con A e B le variabili di ingresso e con Y la variabile di uscita, la somma logica assumerà lo stato logico 1 se almeno una delle due variabili assume lo stato logico 1.

si legge A OR B

Nella figura che segue è mostrata la tabella della verità con le quattro possibili combinazioni delle variabili di ingresso A e B è il simbolo logico corrispondente. Nella colonna Y sono indicati i valori dalla variabile di uscita Y che soddisfa la definizione della porta logica OR.

Prodotto logico AND

L’operazione può essere effettuata su due o più variabili di ingresso. Il prodotto logico AND assumerà il valore 1 se tutte le variabili di ingresso assumeranno il valore 1.

Se chiamiamo con A e B le variabili di ingresso e con Y la variabile di uscita, il prodotto logico assumerà lo stato logico 1 solo se tutte le variabili di ingresso sono allo stato 1.

si legge A AND B

Negazione NOT

L’operazione può essere effettuata su una sola variabile di ingresso. Se chiamiamo con A la variabile di ingresso e con Y la variabile di uscita, la negazione farà assumere all’uscita il valore opposto a quello applicato all’ingresso.

si legge A NEGATO oppure A COMPLEMENTATO oppure NOT A

Nella figura che segue è mostrata la tabella della verità con le due possibili combinazioni
di A ed il simbolo logico corrispondente. Nella colonna Y è indicato il valore della variabile di uscita Y che soddisfa la definizione della porta logica NOT.

Porte logiche derivate

Sono le porte logiche ottenute partendo da una o più porte logiche fondamentali però poiché sono estremamente importanti per l’elettronica sono rappresentate con un simbolo unico.

Somma logica negata NOR

L’operazione può essere effettuata su due o più variabili di ingresso. Se chiamiamo con A e B le variabili di ingresso e con Y la variabile di uscita, la somma logica negata assumerà lo stato logico 1 solo se tutte le variabili di ingresso sono allo stato 1, in tutti gli altri casi l’uscita assumerà il valore 1.

La somma logica negata corrrisponde al collegamento di una OR seguita da una porta NOT.

si legge A NOR B

Prodotto logico negato NAND

L’operazione può essere effettuata su due o più variabili di ingresso. Il prodotto logico negato NAND assumerà il valore 1 se tutte le variabili di ingresso assumeranno il valore 0, in tutti gli altri casi l’uscita assumerà il valore 1.

Il prodotto logico negato corrrisponde al collegamento di una AND seguita da una porta NOT.

si legge A NAND B

OR esclusivo – XOR

L’operazione può essere effettuata su due o più variabili di ingresso. l’OR esclusivo assumerà il valore 1 e solo se vi è almeno un ingresso che differisce dagli altri, mentre varrà 0 se tutti gli ingressi assumono lo stesso valore.

Nel caso di due variabili di ingresso A e B, l’OR esclusivo assumerà il valore 1 se gli ingressi assumeranno valori diversi e varrà 0 se gli ingressi assumono lo stesso valore.

si legge A OR ESCLUSIVO B oppure A DIVERSO B

Nella seguente figura si mostra la tabella della verità con le quattro possibili combinazioni tra A e B ed il simbolo logico relativo ad una porta XOR. Nella colonna Y si sono posti i valori assunti dall’uscita Y che soddisfa la definizione della porta XOR.

L’OR ESCLUSIVO può essere espresso anche dalla seguente formula:

formula da ricordare quando dovrete implementare il codice C per Arduino che realizza questa funzione.

NOR esclusivo XNOR

L’operazione può essere effettuata su due o più variabili di ingresso. Il NOR esclusivo assumerà il valore 1 se e solo se tutti gli ingressi hanno il medesimo valore logico, è equivalente alla negazione della porta XOR.

Nel caso di due variabili di ingresso A e B, l’XNOR assumerà il valore 1 se gli ingressi assumeranno valori uguali e varrà 0 se gli ingressi assumono valore diverso.

e si legge A NOR ESCLUSIVO B oppure A COINCIDENTE CON B.

Nella seguente figura si mostra la tabella della verità con le quattro possibili combinazioni tra A e B ed il simbolo logico relativo ad una porta XNOR. Nella colonna Y si sono posti i valori assunti dall’uscita Y che soddisfa la definizione della porta XNOR.

Il NOR ESCLUSIVO può essere espresso anche dalla seguente formula:

formula da ricordare quando dovrete implementare il codice C per Arduino che realizza questa funzione.

Porte logiche con Arduino

Partiamo ora con la realizzazione delle porte logiche descritte sompra utilizzando Arduino.

In un precedente post ho descritto quali sono gli operatori logici disponibili all’interno di Arduino

Se gli ingressi A e B li indichiamo con le varibili:

pinInA
pinInB

e l’uscita Y la indichiamo con

pinOutY

usando la notazione in C che ritrovate nel link indicato sopra si otterrà:

Y = A || B

AND

Y = A && B

NOT

Y = !A

NOR

Y = !(A || B)

NAND

Y = !(A && B)

XOR

Y = A ⊕ B = (A && !B) || (!A && B)

XNOR

Y = !(A ⊕ B) = !((A && !B) || (!A && B))

Premesso ciò la scrittura dello sketch è estremamente semplice.

Realizziamo i due ingressi A e B mediante due pulsanti connessi rispettivamente ai pin 8 e 7, mentre l’uscita sarà connessa al pin 9.

/* Michele Maffucci
   08.09.18

   Versione 1 - sostituzione del codice per verificare
   la tabella di verità degli operatori logici
*/

int pinOutY = 9;
int pinInA = 8;
int pinInB = 7;

void setup()
{
  pinMode(pinOutY, OUTPUT);
  pinMode(pinInA, INPUT);
  pinMode(pinInB, INPUT);
}
void loop()
{
  boolean statoInA = digitalRead(pinInA);
  boolean statoInB = digitalRead(pinInB);
  boolean statoOut;

  // --- sostituire l'operatore logico indicata nel commento in fondo ---

  // funzione logica OR
  statoOut = statoInA || statoInB;
  digitalWrite(pinOutY, statoOut);
}

/*
Sostituisci all'interno del loop nella posizione indicata

  // operatore logico OR
  statoOut = statoInA || statoInB;

  // operatore logico AND
  statoOut = statoInA && statoInB;

  // operatore logico NOT
  statoOut = !statoInA;

  // operatore logico NOR
  statoOut = !(statoInA || statoInB);

  // operatore logico NAND
  statoOut = !(statoInA && statoInB);

  // operatore logico XOR
  statoOut = (statoInA && !statoInB) || (!statoInA && statoInB);

  // operatore logico XNOR
  statoOut = !((statoInA && !statoInB) || (!statoInA && statoInB));
*/

Vediamo ora come realizzare uno sketch che permette dalla Serial Monitor di selezionare mediante menù il tipo di porta logica che si intende simulare; quando la selezione viene effettuata da menù la pressione dei pulsanti deve realizzare la tabella di verità della funzione logica selezionata.

Un pulsante aggiuntivo, che chiameremo: “AVVIA MENU'” verrà utilizzato per riavviare il menù di scelta.

Le azioni quindi saranno:

primo avvio – selezione funzione (da 1 a 7) inserendo da tastiera il numero sulla Serial Monitor
verifica della tabella di verità premendo i pulsanti A e B controllando che il LED, che identifica la Y, sarà acceso per un livello logico 1 e sarà spento per un livello logico 0
Cambio funzione logica:
1. premere il pulsante: “AVVIA MENU'”
2. seleziono la funzione logica da verificare e ripetere nuovamente dal passo 1

/* Michele Maffucci
   08.09.18

   Versione 2 - scelta dell'operatore logico da menù stampato sulla Serial Monitor.

 All'avvio compare un menù di selezione dell'operatore logico
  1: OR
  2: AND
  3: NOT
  4: NOR
  5: NAND
  6: XOR
  7: XNOR

  Scrivere sulla Serial Monitor il numero corrispondente e con
  i pulsanti A e B verificare la tabella di verità

  La selezione di un altro operatore avviene premendo il pulsante: AVVIA MENU
  che mostrerà nuovamente sulla Serial Monitor il menù di selezione operatore
*/

int pinOutY = 9;
int pinInA = 8;
int pinInB = 7;

int pinChiave = 10;

boolean statoInA;
boolean statoInB;
boolean statoOut;

// array da utilizzare come chiave di stampa
// per le tabelle di verità delle singole funzioni logiche

int chiavi[] = {1, 1, 1, 1, 1, 1, 1};

void setup()
{
  Serial.begin(9600);
  pinMode(pinOutY, OUTPUT);
  pinMode(pinInA, INPUT);
  pinMode(pinInB, INPUT);

  pinMode(pinInB, INPUT);

  // funzione per la stampa sulla Serial Monitor
  // del menù di scelta dell'operatore logico
  stampaMenu();
}

void stampaMenu() {
  Serial.println("---- Seleziona l'operatore logico ----");
  Serial.println("1: OR");
  Serial.println("2: AND");
  Serial.println("3: NOT");
  Serial.println("4: NOR");
  Serial.println("5: NAND");
  Serial.println("6: XOR");
  Serial.println("7: XNOR");
  Serial.println("--------------------------------------");
  Serial.println("");
  Serial.println("");
}

// La funzione di stampa tabella di verità pone a 0 il valore della
// chiave, chiavi[n] = 0, dove n identifica la tabella di verità
// e il valore associato, 1 o 0, indica il fatto di poterla stampare oppure no.
// chiavi[n] = 0 permette di non stampare ciclicamente una stessa tabella
// di verità all'interno dei singoli cicli while presenti nel loop in cui avviene
// il controllo di quale selezione è stata fatta.

void stampaOr() {
  Serial.println("Hai selezionato l'operatore OR");
  Serial.println("La tabella di verità è:");
  Serial.println(" A  |  B  |  Y  ");
  Serial.println("----|-----|-----");
  Serial.println(" 0  |  0  |  0  ");
  Serial.println(" 0  |  1  |  1  ");
  Serial.println(" 1  |  0  |  1  ");
  Serial.println(" 1  |  1  |  1  ");
  Serial.println("");
  Serial.println("----------------------------------------------------------------");
  Serial.println("Per selezionare un altro operatore premi il pulsante AVVIA MENU'");
  Serial.println("----------------------------------------------------------------");
  Serial.println("");

  mettiUnoChiavi();
  chiavi[0] = 0;
}

void stampaAnd() {
  Serial.println("Hai selezionato l'operatore AND");
  Serial.println("La tabella di verità è:");
  Serial.println(" A  |  B  |  Y  ");
  Serial.println("----|-----|-----");
  Serial.println(" 0  |  0  |  0  ");
  Serial.println(" 0  |  1  |  0  ");
  Serial.println(" 1  |  0  |  0  ");
  Serial.println(" 1  |  1  |  1  ");
  Serial.println("");
  Serial.println("----------------------------------------------------------------");
  Serial.println("Per selezionare un altro operatore premi il pulsante AVVIA MENU'");
  Serial.println("----------------------------------------------------------------");
  Serial.println("");

  mettiUnoChiavi();
  chiavi[1] = 0;
}

void stampaNot() {
  Serial.println("Hai selezionato l'operatore NOT");
  Serial.println("La tabella di verità è:");
  Serial.println(" A  |  Y  ");
  Serial.println("----|-----");
  Serial.println(" 0  |  1  ");
  Serial.println(" 1  |  0  ");
  Serial.println("");
  Serial.println("----------------------------------------------------------------");
  Serial.println("Per selezionare un altro operatore premi il pulsante AVVIA MENU'");
  Serial.println("----------------------------------------------------------------");
  Serial.println("");

  mettiUnoChiavi();
  chiavi[2] = 0;
}

void stampaNor() {
  Serial.println("Hai selezionato l'operatore NOR");
  Serial.println("La tabella di verità è:");
  Serial.println(" A  |  B  |  Y  ");
  Serial.println("----|-----|-----");
  Serial.println(" 0  |  0  |  1  ");
  Serial.println(" 0  |  1  |  0  ");
  Serial.println(" 1  |  0  |  0  ");
  Serial.println(" 1  |  1  |  0  ");
  Serial.println("");
  Serial.println("----------------------------------------------------------------");
  Serial.println("Per selezionare un altro operatore premi il pulsante AVVIA MENU'");
  Serial.println("----------------------------------------------------------------");
  Serial.println("");

  mettiUnoChiavi();
  chiavi[3] = 0;
}

void stampaNand() {
  Serial.println("Hai selezionato l'operatore NAND");
  Serial.println("La tabella di verità è:");
  Serial.println(" A  |  B  |  Y  ");
  Serial.println("----|-----|-----");
  Serial.println(" 0  |  0  |  1  ");
  Serial.println(" 0  |  1  |  1  ");
  Serial.println(" 1  |  0  |  1  ");
  Serial.println(" 1  |  1  |  0  ");
  Serial.println("");
  Serial.println("----------------------------------------------------------------");
  Serial.println("Per selezionare un altro operatore premi il pulsante AVVIA MENU'");
  Serial.println("----------------------------------------------------------------");
  Serial.println("");

  mettiUnoChiavi();
  chiavi[4] = 0;
}

void stampaXor() {
  Serial.println("Hai selezionato l'operatore XOR");
  Serial.println("La tabella di verità è:");
  Serial.println(" A  |  B  |  Y  ");
  Serial.println("----|-----|-----");
  Serial.println(" 0  |  0  |  0  ");
  Serial.println(" 0  |  1  |  1  ");
  Serial.println(" 1  |  0  |  1  ");
  Serial.println(" 1  |  1  |  0  ");
  Serial.println("");
  Serial.println("----------------------------------------------------------------");
  Serial.println("Per selezionare un altro operatore premi il pulsante AVVIA MENU'");
  Serial.println("----------------------------------------------------------------");
  Serial.println("");

  mettiUnoChiavi();
  chiavi[5] = 0;
}

void stampaXnor() {
  Serial.println("Hai selezionato l'operatore XNOR");
  Serial.println("La tabella di verità è:");
  Serial.println(" A  |  B  |  Y  ");
  Serial.println("----|-----|-----");
  Serial.println(" 0  |  0  |  1  ");
  Serial.println(" 0  |  1  |  0  ");
  Serial.println(" 1  |  0  |  0  ");
  Serial.println(" 1  |  1  |  1  ");
  Serial.println("");
  Serial.println("----------------------------------------------------------------");
  Serial.println("Per selezionare un altro operatore premi il pulsante AVVIA MENU'");
  Serial.println("----------------------------------------------------------------");
  Serial.println("");

  mettiUnoChiavi();
  chiavi[6] = 0;
}

void mettiUnoChiavi() {
  for (int indice = 0; indice < 7; indice++) {
    chiavi[indice] = 1;
  }
}

void loop()
{

  if (Serial.available())
  {
    byte selezione = Serial.read();

    while (selezione == '1')
    {
      if (chiavi[0] == 1)
      {
        stampaOr();
      }

      statoInA = digitalRead(pinInA);
      statoInB = digitalRead(pinInB);

      // funzione logica OR
      statoOut = statoInA || statoInB;
      digitalWrite(pinOutY, statoOut);

      if (digitalRead(pinChiave) == HIGH) {
        mettiUnoChiavi();
        stampaMenu();
        break;
      }
    }

    while (selezione == '2')
    {
      if (chiavi[1] == 1) {
        stampaAnd();
      }
      statoInA = digitalRead(pinInA);
      statoInB = digitalRead(pinInB);

      // funzione logica AND
      statoOut = statoInA && statoInB;
      digitalWrite(pinOutY, statoOut);
      //selezione = Serial.read();

      if (digitalRead(pinChiave) == HIGH) {
        mettiUnoChiavi();
        stampaMenu();
        break;
      }
    }

    while (selezione == '3')
    {
      if (chiavi[2] == 1) {
        stampaNot();
      }

      statoInA = digitalRead(pinInA);
      statoInB = digitalRead(pinInB);

      // funzione logica NOT
      statoOut = !statoInA;
      digitalWrite(pinOutY, statoOut);

      if (digitalRead(pinChiave) == HIGH) {
        mettiUnoChiavi();
        stampaMenu();
        break;
      }
    }

    while (selezione == '4')
    {
      if (chiavi[3] == 1) {
        stampaNor();
      }

      statoInA = digitalRead(pinInA);
      statoInB = digitalRead(pinInB);

      //funzione logica NOR
      statoOut = !(statoInA || statoInB);
      digitalWrite(pinOutY, statoOut);

      if (digitalRead(pinChiave) == HIGH) {
        mettiUnoChiavi();
        stampaMenu();
        break;
      }
    }

    while (selezione == '5')
    {
      if (chiavi[4] == 1) {
        stampaNand();
      }

      statoInA = digitalRead(pinInA);
      statoInB = digitalRead(pinInB);

      //funzione logica NAND
      statoOut = !(statoInA && statoInB);
      digitalWrite(pinOutY, statoOut);

      if (digitalRead(pinChiave) == HIGH) {
        mettiUnoChiavi();
        stampaMenu();
        break;
      }
    }

    while (selezione == '6')
    {
      if (chiavi[5] == 1) {
        stampaXor();
      }

      statoInA = digitalRead(pinInA);
      statoInB = digitalRead(pinInB);

      // funzione logica XOR

      statoOut = (statoInA && !statoInB) || (!statoInA && statoInB);
      digitalWrite(pinOutY, statoOut);

      if (digitalRead(pinChiave) == HIGH) {
        mettiUnoChiavi();
        stampaMenu();
        break;
      }
    }

    while (selezione == '7') {
      if (chiavi[6] == 1) {
        stampaXnor();
      }

      statoInA = digitalRead(pinInA);
      statoInB = digitalRead(pinInB);

      // funzione logica XNOR
      statoOut = !((statoInA && !statoInB) || (!statoInA && statoInB));
      digitalWrite(pinOutY, statoOut);

      if (digitalRead(pinChiave) == HIGH) {
        mettiUnoChiavi();
        stampaMenu();
        break;
      }
    }
  }
}

Propongo come esercizio cinque varianti all’esempio precedente:

Gli ingressi selezionati con pulsanti devono essere visualizzati con LED (1 acceso, 0 spento), create inoltre una libreria dedicata per l’implementazione delle funzioni logiche (inserite il codice in un file .h). Per sapere come creare una libreria seguire il link, al fondo del tutorial troverete la spiegazione.
La selezione della funzione logica non avviene più tramite la serial monitor, ma attraverso 7 pulsanti di selezione funzione, la cui selezione deve essere visualizzata con un LED (Acceso = selezionato; Spento= non selezionato). Deve essere presente un pulsante che effettua il reset dell’operazione (non deve essere il reset della scheda Arduino).
Realizzare le stesse funzionalità del punto 2 ma in questo caso non si devono utilizzare LED ma un display 16×2 del tipo Hitachi HD44780, se desiderate potete utilizzare un’interfaccia I2C HD44780 per utilizzare meno pin.
Aggiungere il codice per effettuare il debounce (anti-rimbalzo) sui pulsanti.
Per gli studenti di 4′ superiore realizzare un debounce usando l’elettronica a componenti discreti.

Per chi volesse esplorare nuove frontiere:

Realizzate tutto ciò che è stato esposto prima mediante BBC micro:bit e programmate tutto in microPython.
Realizzate tutto ciò che è stato esposto prima mediante Raspberry Pi e programmate tutto in Python.

Buon Coding (e studio) a tutti 🙂

Cosa sono le awesome list?

2 Repliche

Ad ogni inizio d’anno scolastico propongo ai nuovi allievi che incontro una serie di attività e strumenti che dal mio punto di vista servono per creare un atteggiamento positivo e rilassato nei confronti dello studio e delle sperimentazioni in laboratorio. Ogni anno esordisco con una serie di starter kit per lo studente:

setting dei luoghi di studio, (alcune indicazioni su come gestire gli oggetti del proprio studio)
tecniche di studio
tecniche di gestione del tempo lavoro
sistemi di gestione dei progetti
tecniche di documentazione
ricerca dell’informazione
realizzazione di un propria Personal Learning Network

e proprio su quest’ultimo punto, ripreso dai corsi che svolgo per gli insegnanti, mi focalizzo. Ritengo essenziale saper selezionare e far diventare un’attività periodica la ricerca e l’utilizzo di fonti attendibili ed autorevoli on-line da utilizzare per ampliare le proprie competenze.

Quando parlo di Personal Learning Network intendo banalmente (cito le mie slide):

la rete di relazioni online che fa uso di tutti gli strumenti web come: blogs, wiki, twitter, facebook, … per creare connessioni con altre persone al fine di estendere le nostre conoscenze, imparando insieme ad altri, come parte di una comunità globale.

Ciò permetterà di ottimizzare tempi e sforzi nell’utilizzo di particolari tecnologie.

Ovviamente un grande sforzo da parte del docente deve essere fatto per insegnare a saper discriminare le fonti, è un’azione da costruire “un passettino alla volta” e ritengo che ciò possa innescare il volano che mi piace chiamare: “cerco-studio-mi-diverto-condivido”

Ma da dove cominciare?

Io ho costruito negli anni la mia procedura e le mie collezioni che rinnovo settimanalmente, ma per studenti “grintosi” che hanno voglia di costruire e calarsi subito nella pratica della materia, è essenziale collezionare i “punti di osservazione web” (consiglierò anche un buon sistema per collezionare le fonti, sarà motivo di un’altra lezione) tra questi segnalo ai miei studenti le awesome list su GitHub, “liste fantastiche” su ogni argomento dal fantasy, alla musica, al gaming, ma anche all’elettronica, automazione, programmazione, all’uso di Arduino o di Raspberry Pi e mille altre cose, tutto realizzato dalla comunità di GitHub.
(Per saperne di più su GitHub seguire il link: Documentare la didattica con la sintassi Markdown su GitHub)

Questo il repository principale delle “awesome list“.

Molte liste sono aggiornate periodicamente altre un po’ meno, ma prendendosi un po’ di minuti al giorno potrete scoprire tantissimo.

Come promesso oggi nella mia 4B Automazione (ma lo sarà anche per tutte le altre classi) le collezioni da cui partire, molte altre risorse (riviste, siti internet, ecc…) le segnalerò durante l’anno scolastico, di seguito alcune collezioni interessanti:

Compito: segnalatemi o realizzate una lista più interessante di quelle indicate sopra, (è possibile segnalare argomenti di altre discipline tecniche).

Buona esplorazione 🙂

gamer:bit – un controller per BBC micro:bit

Lascia una risposta

gamer:bit è un pratico shield per micro:bit che dispone di 6 pulsanti ed un connettore breakout che permette di realizzare un pratico controller per pilotare dispositivi remoti, come ad esempio robot o realizzare giochi.

Edge Connector

Il gamer:bit si connette al micro:bit mediante un connettore edge disposto sul centro della scheda, il micro:bit va connesso con i LED verso l’alto.

Pulsanti di direzione

Il gamer:bit è stato progettato pensando ad un controller di gioco classico, quindi ritroverete sulla sinistra la classica configurazione “D Pad” e i pin che ciascun pulsante controlla sono etichettati sulla scheda.

su => P0
sinistra => P1
giù => P8
destra => P2

Pulsanti azione

Sono collocati sulla destra ed in questo breve tutorial li chiameremo X e Y. Non hanno un uso specifico e possono essere utilizzati all’interno dei vostri programmi.

Sono collegati ai seguenti pin:

X (funzione sinistra) => P12
Y (funzione destra) => P16

Connettori Poke-Home

Sul retro del gamer:bit noterete una serie di connettori in plastica chiamati Poke-Home, ognuno corrisponde ai pulsanti presenti sulla scheda e sul micro:bit. Tutti i connettori Poke-Home sono etichettati per avere la corrispondenza con i pulsanti sul gamer:bit e micro:bit. Questi connettori vi permetteranno di estendere le funzionalità dei vostri progetti aggiungendo ulteriori dispositivi elettronici. Ogni punto di connessione Poke-Home è dotato di due connettori dove collegare il pulsante al componente esterno.

Installare il gamer:bit Package per il JavaScript Blocks Editor Continua a leggere→

RobotArm:bit, storia di un piccolo progetto

Lascia una risposta

Qualche settimana fa…

Mannaggia fare questo mestiere è complicato, la giornata sarà ancora lunga, terminerà solo questa sera dopo la riunione con le famiglie…
ora mi prendo 10 minuti di pausa, è intervallo, mi chiudo in laboratorio di sistemi elettronici alla ricerca di un momento yogico, ma il frastuono degli allievi che chiacchierano a gran voce in corridoio non mi permette la “ricarica” completa.
Con la matita pasticcio su un foglio di carta millimetrata, ad un certo punto un frastuono mi fa sobbalzare dalla sedia, è la porta del laboratorio aperta malamente da un allievo che mi dice:

Allievo: “Vabbè Prof. poteva dircelo!”

Io: “Marco! La parola magicaaaa?”

Allievo: “Buooongioorno Proooof”

Io: “Marco il Prof. è un po’ scombussolato, tenta di far la dieta è in carenza di zuccheri ha dormito poco…. eeee sta cercando unaaa soluzione!”

Allievo: “Cosa Prof???
Aaaa ok ho capito!
Sta scarabocchiando sui nostri disegni, ci vuole fregare!
Si sta inventando una di quelle robe elettroniche per farci venire voglia di studiare…
vabbè vabbè Prof.! Volevo solo sapere perché non porta anche noi di seconda alla mostra Lego, porta tutti gli altri e a noi non ha detto nulla!
Vogliamo usare anche noi i robottini!”

Io: “Marco! Porta pazienza ma anche il tuo Prof. dimentica!”

Allievo: “Ok ok ok ho capito l’età si fa sentire!”

Io: “Marco tu sai che gestisco il registro elettronico, vuoi mica che tutti i tuoi voti diventino bit disordinati persi nel Matrix?”

Allievo: “Magari Prof.! Scomparirebbero i 4 di mate!”

…volevo dirle… allora… noi veniamo con lei,
siamo in quattro,
e se vuole diamo anche una mano a fare orientamento scolastico,
insomma lei ci porta alla mostra e noi la ripaghiamo facendo orientamento”

Io: ”Marco ma questa cosa si chiama estorsione! 🙂
ok ok dai vi porto”

E’ sera…
torni a casa correggi i disegni e ritrovi lo scarabocchio,
ma a cosa stavo pensando?

Pensavo agli “oggetti faro”.
Te le devi inventar tutte per far studiare gli allievi.

Cos’é “l’oggetto faro”?

Il progetto che vi condivido è quello di un piccolo e semplice braccio robot, che sarà inserito all’interno di un percorso più ampio di Coding in cui si utilizza sia di BBC micro:bit che di Arduino, l’attività sarà svolta tra qualche mese.

Durante i corsi mi capita che studenti appassionati chiedano di realizzare progetti che pregiudicano competenze ancora non acquisite ed il rischio è che lo studio inizia con gran voglia di fare e subito dopo sopraggiunge affanno perché non si riesce a gestire la complessità degli argomenti trattati.

Ecco che il metodo degli “oggetti faro” può venirci in aiuto.
Ma di cosa si tratta?

E’ una strategia che probabilmente con altri nomi già viene attuata da altri colleghi, a me piace chiamarla in questo modo e in sostanza mi permette, costruendo “oggetti faro” di far percepire allo studente la direzione in cui si sta andando e durante l’attività di formazione mi permette di mantenere vivo l’interesse anche se la complessità aumenta nel tempo.

“Professore voglio progettare un braccio robot che possa sollevare almeno 1 kg e che abbia 6 gradi di libertà, ma non voglio copiarlo on-line, ma voglio progettarlo io, ho visto che sta usando micro:bit, ritiene che debba usare questa scheda oppure e meglio usare Arduino? Mi spiega come fare?
A Prof. non so molto di meccanica e di elettronica se compro tutto e porto a scuola mi spiega?”

Se la richiesta viene da un allievo di prima superiore, l’attività può diventare un po’ complessa da gestire 🙂

Tornando agli “oggetti faro”, RobotArm:bit è uno di questi.
Arriverà un momento in cui l’allievo mi chiederà di non giocare più con la matrice di LED del micro:bit, ma vorrà incominciare a movimentare oggetti e dopo aver spiegato come gestire ad esempio un servo con micro:bit gli si spiega come usarne due insieme, poi come usarne tre e poi come pilotare i tre servo a distanza con un altro micro:bit e poiché bisogna dare delle risposte all’allievo citato prima, si aggiunge l’esercitazione con “l’oggetto faro” realizzato in modo molto elementare ed espandibile…

A questo punto si attua una strategia project learning breve che ha come punto di partenza “l’oggetto faro” RobotArm:bit per esempio. Cosa può succedere?

Nella mente del ragazzo nascono nuove idee:

“Prof. disegno una versione più grande e la stampiamo a scuola, quali software devo imparare ad usare? Lo faccio io da solo a casa!”

Quindi nuovi breanch si aprono e gli studenti portano ad esplorare in autonomia nuovi argomenti, tutto questo mi permette di insegnare ad esplorare, è una semplice strategia che serve per far nascere passioni.

Però bisogna proseguire con il corso.
Nuovi contenuti nuove sperimentazioni per giungere “all’oggetto faro” successivo, ad esempio un WalkerBot:bit e così di seguito.

Insomma un percorso intervallato da milestones (punti di riferimento) costituiti da “oggetti faro” su cui attuo del project learning da cui cerco di far nascere branch creativi gestiti in modo indipendente da parte dello studente.

Come realizzare RobotArm:bit?

Se avete necessità di realizzare RobotArm:bit vi rimando su Thingiverse dove potrete prelevare i sorgenti grafici per la stampa 3D, di seguito invece una sequenza fotografica che mostra i passi di costruzione, alla fine di questo post trovate video e link al programma di test realizzato con il JavaScript Blocks editor, è molto semplice e mi permette di selezionare tre movimenti.

Le leve collegate ai servo devono essere incollate alle parti stampate in 3D, ovviamente se desiderate potete utilizzare delle viti.

4 oggetti

Inserimento del primo servo

Incollare le leve con i giunti da collegare all’albero di ciascun servomotore

Fissare i servomotori con le viti in dotazione

Unire ogni parte

Per la stampa si poteva fare di meglio… ma vabbè lascio a voi i miglioramenti.

Se avete bisogno del codice per realizzare i medesimi movimenti del video seguite il link.

STM 32 Nucleo – Supporto Arduino Core

Lascia una risposta

E’ da tempo che mi ero ripromesso di utilizzare le schede STM32 Nucleo, desideravo svilupparne alcuni moduli didattici, ma la mia attenzione era rivolta verso altre tecnologie, fortunatamente l’incontro dell’amico Giuseppe Treccarichi e la chiacchierata con gli ingegneri di ST (molto gentili e disponibili) durante la recente MakerFaire di Roma mi hanno convinto che spiegare anche l’uso di STM 32 Nucleo può essere un valore aggiunto per i miei allievi, pertanto mi sto dedicando da qualche giorno alla realizzazione di lezioni sull’uso di queste schede.

La linea ST32 Nucleo è ormai sul mercato da lungo tempo, venne presentata nel 2014, però recentemente ST ha reso disponibile l’Arduino Core ST32 che permette la programmazione di diverse schede ST32 Nucleo mediante l’IDE di Arduino, inoltre il processore a 32 bit, le velocità elevate (nella versione da me posseduta un Cortex-M4 a 85 MHz), il basso costo (circa 10 Euro) la rendono una piattaforma estremamente interessante per i miei studenti.
Le varie schede disponibili, di cui trovate una grafica nell’immagine che segue, supportano comunicazioni di tipo: SPI, I2C, USB-OTG, CAN, UART.

Come si evince dall’immagine possiamo distinguere 3 serie:

Serie L: Ultra low power a 32 pin
Serie F fino a F3: Mainstream da 32 a 64 pin
Serie F4 fino a F7: High performance con processore che va dagli 85 Mhz ai 216 Mhz da 64 a 144 pin

ST mette a disposizione diverse shield con molte funzionalità: controllo motori, WiFi, Bluetooth LE, RFID, GPS, sensori di prossimità e molto altro. Di seguito link alla pagina di riferimento delle ST Exspansion Board Continua a leggere→

Porte logiche fondamentali

Somma logica OR

Prodotto logico AND

Negazione NOT

Porte logiche derivate

Somma logica negata NOR

Prodotto logico negato NAND

OR esclusivo – XOR

Porte logiche con Arduino

Related posts:

Related posts:

Related posts:

Related posts:

Related posts: