Archivi tag: arduino

Errori comuni nell’uso di Arduino – confondere uguaglianza con assegnamento

Durante le attività di formazione e la correzione dei compiti dei miei studenti sull’uso di Arduino ho l’abitudine di documentare gli errori per poi segnalarli all’interno delle mie dispense. Poiché sto sistemando il percorso che svolgo nelle classi 3’ Automazioni presso l’ITIS G.B. Pininfarina di Moncalieri (To) incomincio a pubblicare su questo sito le brevi note collezionate nel mio Evernote, faranno parte di una lezione più ampia, ma ho necessità che vengano usate subito dai ragazzi. Quindi nei prossimi giorni ritroverete su questo sito piccole “pillole” che costituiranno qualcosa di più esteso a scuola e durante i corsi per gli adulti.

Errore: confondere uguaglianza con assegnamento

E’ probabilmente uno degli errori più frequenti, confondere in C l’operatore di assegnamento = con quello di uguaglianza ==

Con le impostazioni di default dell’IDE Arduino, nella sezione Compiler warning, l’errore non verrà rilevato:

quindi nell’utilizzo di una istruzione if :

If (pippo = pluto)

In questo caso accadrà che il compilatore assegnerà il valore di pluto a pippo , inoltre bisogna ricordare che in C il valore 0 viene utilizzato per indicare uno stato logico FALSO e qualsiasi altro numero viene utilizzato per identificare un valore VERO, pertanto se il valore di pippo è diverso da 0 (perché pluto diverso da 0), la condizione dell’if sarà sempre vera, quindi le istruzioni all’interno dell’if saranno sempre eseguite.

Provate ad eseguire lo sketch che segue, dovreste notare, che pur avendo usato l’operatore di assegnamento, la stringa: Stampo questo messaggio perché l’if è sempre vero viene stampata sulla Serial Monitor:

int pippo;
int pluto = 1;


void setup() {
  Serial.begin(9600);
}

void loop() {
  if (pippo = pluto) {
    Serial.println("Stampo questo messaggio perché l'if è sempre vero");
  }
}

Allo stesso modo se provate ad eseguire lo sketch che segue, l’istruzione contenuta nell’if non verrà mai eseguita, mentre l’istruzione fuori dall’if sarà sempre eseguita:

int pippo;
int pluto = 0;


void setup() {
  Serial.begin(9600);
}

void loop() {
  if (pippo = pluto) {
    Serial.println("Stampo questo messaggio perché l'if è sempre vero");
  }
  Serial.println("Non eseguo le istruzioni dell'if perchè la condizione è sempre falsa");
}

Per avere una segnalazione da parte del compilatore, sempre dalle impostazioni, nella sezione Compiler warning, selezionate “All”:

Compilando nuovamente uno degli sketch proposti sopra potrete visualizzare il warning, ma ricordate che il programma verrà comunque eseguito:

Buona sperimentazione 🙂

Esperienza di laboratorio: verifica della tabella di verità del Flip Flop SR (Set-Reset) con integrato 7402 ed Arduino

2 Repliche

Il più semplice circuito digitale di memoria è il flip-flop Set-Reset. Esso è costituito da due ingressi identificati con il nome Set e Reset ed una uscita indicata con .
Accade spesso che i flip flop sono dotati, anche dell’uscita .

In un dispositivo di memoria l’uscita dipende:

dalla particolare combinazione che assumono le variabili di ingresso
dallo stato precedente assunto dall’uscita Q.

Lo stato precedente dell’uscita lo indichiamo con .

Flip-flop SR con porte NOR

Il simbolo logico, la tabella della verità e la soluzione circuitale a porte logiche NOR di un flip-flop S-R sono indicate nell’immagine che segue:

Combinazioni

Combinazione SR=00

Combinazione di riposo in quanto l’uscita conserva lo stato precedente (Q=Qo).

Combinazione SR=01

Posto R=1, l’uscita Q si porta a 0 indipendentemente dallo stato precedente.

Combinazione SR=10

Posto S=1, l’uscita Q si porta a 1 indipendentemente dallo stato precedente.

Combinazione SR=11

Questa combinazione è da evitare in quanto dal punto di vista logico risulta incongruente, non ha alcun senso comandare il flip-flop per memorizzare lo 0 (R=1) oppure l’1 (S=1).

Modalità di memorizzazione di 1 bit

Per memorizzare 1:

Passo 1: impostare S=1 e R=0.
Passo 2: impostare lo stato di riposo: S=0 e R=0.

l’uscita conserva lo stato precedente: Q=Qo=1

Per memorizzare 0:

Passo 1: S=0 e R=1.
Passo 2: impostare lo stato di riposo: S=0 e R=0.

l’uscita conserva lo stato precedente: Q=Qo=0

Ripasso sul funzionamento della porta 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 corrisponde al collegamento di una OR seguita da una porta NOT.

si legge A NOR 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 della variabile di uscita Y che soddisfa la definizione della porta logica NOR.

Verifica funzionamento come Flip-Flop S-R

Passo 1

Impostare S=0 e R=1.

L’uscita Q=0, infatti l’uscita Q della porta 2 va a 0 perché l’ingresso R=1.

Su tutti e due gli ingressi della porta 1 abbiamo 0 per cui la sua uscita va ad 1.
Dovreste aver notato che le due uscite sono complementari tra loro.

Passo 2

Impostare la combinazione di riposo: R=0 e S=0.

L’uscita Q nella fase precedente era stata portata a 0 (Qo=0), l’uscita della porta 1 resta ad 1 come conseguenza l’uscita della porta 2 rimane a 0 (Q=0).

Passo 3

Impostare S=1 e R=0.

L’uscita della porta 1 va a 0 come conseguenza, poiché R=0, l’uscita della porta 2 commuta ad 1: Q=1.

Passo 4

Impostare la combinazione di riposo: R=0 e S=0.

L’uscita Q nella fase precedente era stata portata a 1 (Qo=1), l’uscita della porta 1 resta a 0 come conseguenza l’uscita della porta 2 rimane a 1 (Q=1).

Passo 5

Impostare S=1 e R=1 (combinazione proibita)

Le uscite di entrambe le porte NOR commuteranno a 0.
In questo caso, le due uscite non saranno più complementari tra loro.
Inoltre se impostate contemporaneamente R=0 e S=0 entrambe le uscite si porteranno ad 1 e poi a 0 e così via.

Accadrà inoltre che per i diversi tempi di ritardo di propagazione del segnale elettrico in ciascuna porta, uno delle due porte NOR propagherà l’1 in uscita prima dell’altra porta.

Diventa aleatorio il valore dell’uscita Q che, pertanto, potrà trovarsi a 0 oppure a 1. Anche per questo motivo è da evitare la combinazione della tabella della verità: S=1 e R=1.

Fase 1: Verifica tabella di verità del Flip-Flop SR con integrato 7402

Realizzare il circuito e verificare la tabella di verità del Flip-Flop SR.

Lista componenti:

IC 7402 (Quad 2 Input NOR)
N. 2 R: 10 KOhm
N. 2 R: 180 Ohm
N. 1 LED Rosso
N. 1 LED Verde
N 2. Switch

Schema elettrico

Schema di montaggio

Pinout 7402

Fase 2: Realizzare un simulatore di Flip-Flop SR con Arduino

Dato lo sketch Arduino che segue, non commentato, comprenderne il funzionamento, commentare ogni parte e derivare il circuito elettronico di montaggio.

Fasi operative:

realizzare lo schema di montaggio in Fritzing;
realizzazione pratica del circuito;
verifica del funzionamento del circuito;
segnalare eventuali correzioni/miglioramenti da effettuare allo sketch.

int pinQ = 10;
int pinQneg = 9;
int pinSet = 8;
int pinReset = 7;

int pinLedSet = 5;
int pinLedReset = 4;

int statoOutNorReset = 0;
int statoOutNorSet = 0;

int statoOutNorResetSuc = 0;
int statoOutNorSetSuc = 0;

boolean statoQ = 0;
boolean statoQneg = 0;
  
void setup()
{
  pinMode(pinSet, INPUT);
  pinMode(pinReset, INPUT);

  pinMode(pinQ, OUTPUT);
  pinMode(pinQneg, OUTPUT);

  pinMode(pinLedSet, OUTPUT);
  pinMode(pinLedReset, OUTPUT);
}

void loop()
{
  boolean statoSet = digitalRead(pinSet);
  boolean statoReset = digitalRead(pinReset);

  if (statoSet == 1) {
    digitalWrite(pinLedSet, HIGH);
  } else {
    digitalWrite(pinLedSet, LOW);
  }

  if (statoReset == 1) {
    digitalWrite(pinLedReset, HIGH);
  } else {
    digitalWrite(pinLedReset, LOW);
  }

  statoOutNorSet = statoQneg;
  statoOutNorReset = statoQ;
  
  statoOutNorResetSuc = !(statoReset || statoOutNorSet);
  statoOutNorSetSuc = !(statoSet || statoOutNorReset);
  
  digitalWrite(pinQ, statoOutNorReset);
  digitalWrite(pinQneg, statoOutNorSet);

  statoQneg = statoOutNorSetSuc;
  statoQ = statoOutNorResetSuc;
}

Si ricorda è obbligatorio:

inserire un’intestazione come indicato nell’immagine che segue, in cui indicare:
- Cognome e Nome
- Classe
- Esercizio/Sommario funzionamento
tutto il codice deve essere commentato;
tutto il codice deve essere correttamente indentato;
ogni allievo dovrà utilizzare 1 singola scheda Arduino;
il codice dovrà essere consegnato al docente su Google Classroom secondo le indicazioni date a lezione.

Buon lavoro 🙂

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

Lascia una risposta

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

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 AND.

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

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

si legge A NOR 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 NOR.

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

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 NAND.

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 🙂

Nome in codice DotBot Bubble

Lascia una risposta

Obiettivo di quest’ultima versione: tondeggiante, veloce da costruire, trasportabile, economicamente accessibile per le scuole, multipiattaforma: #Arduino (UNO e Nano), #Raspberry Pi (3, 2, Zero), #microbit, #STM32F401 #Nucleo-64 e visto che lo avevo promesso ad una persona durante la scorsa Maker Faire di Roma anche #UDOO #NEO. Per ogni piattaforma ho disegnato un tutorial per realizzare un robot segui linea, evita ostacoli e altre tipologie di interazioni in cantiere. La struttura avrà, in una successiva versione, un involucro trasparente per proteggere i circuiti elettronici aggiungerò inoltre elementi che permetteranno personalizzazioni estetiche.
Sto ancora studiando l’alimentazione più efficace, ho sperimentato con Li-Po però per alleggerire la struttura sto pensato a delle batterie Li-Ion che sperimenterò nella prossima settimana, per la versione preliminare 6 batterie AA da 1,5 V.

I sorgenti grafici per la stampa 3D per realizzarlo?
Entro qualche settimana,

perché?

Sto verificando l’efficacia della struttura meccanica e del software e della didattica, nel corso che si svolge presso l’IIS Vallauri di Fossano: ITS “Tecnico Superiore per l’Automazione e l’Innovazione di Processi e Prodotti Meccanici” – ITS VI (2016-2018), 2^ annualità (studenti neodiplomati) per cui sto svolgendo il corso: Microcontrollori.

Inoltre sperimenterò l’utilizzo con un nutrito gruppo di insegnanti durante il laboratorio: “La robotica tra i banchi di scuola: da BBC micro:bit ad Arduino”, attività che si svolgerà in occasione dell’evento organizzato dall’USR Piemonte: “La scuola europea del domani: le nuove tecnologie e i nuovi spazi di apprendimento ” venerdì 18 maggio 2018 presso l’Aula Magna LC M. d’Azeglio – via Parini 8 – Torino.

Spero poter regalare questa nuova piattaforma robotica al più presto in modo che possa essere usata da chi vorrà dal prossimo anno scolastico in attività di #Coding e #robotica

Buon Coding a tutti 🙂

Un’anteprima di alcuni dettagli del kit

I miei corsi per La Tecnica della Scuola “Terza edizione di: Starter kit delle competenze digitali”

Lascia una risposta

Siamo giunti alla terza edizione del corso in webinar: Starter kit delle competenze digitali. Come nelle precedenti edizioni mostrerò la strategia che adotto per costruire “la cassetta degli attrezzi” delle tecnologie digitali e come costruire un percorso di apprendimento alle tecnologie didattiche rivolto agli insegnanti. Rispetto alle edizioni passate, viste le richieste che mi sono state fatte dai colleghi, aggiungerò anche indicazioni su risorse e moduli didattici in merito all’uso di particolari tecnologie che si riferiscono alla stampa 3D, al Coding con BBC micro:bit, Arduino, Raspberry Pi, Maker Makey inoltre incomincerò a dare suggerimenti su come costruire un percorso di Didattica della Robotica, percorso che poi sfocerà nei prossimi mesi in un corso specifico. Vista la grande quantità di argomenti che verranno trattati lascerò come sempre slide e documentazione di approfondimento.

Presentazione

“Come imparare ad imparare l’uso delle tecnologie didattiche?”
“Dove informarsi e dove trovo esempi sull’uso delle tecnologie sviluppati da altri insegnanti?”

Il corso introduttivo intende fornire gli strumenti necessari per imparare a strutturare un proprio percorso di apprendimento all’uso delle tecnologie didattiche con particolare attenzione ad una serie di applicativi web in cloud, gratuiti ed open source, utilizzabili per la progettazione didattica e per la gestione della classe, a supporto di una didattica blended ed inclusiva.
Verranno forniti gli strumenti di partenza per sfruttare le potenzialità delle tecnologie nei processi chiave: progettazione, trasversalità, collaborazione, condivisione, valutazione.
Durante l’attività formativa verranno esposte soluzioni hardware di bassissimo costo (Raspberry Pi, micro:bit, MakeyMakey, Arduino, ecc…) immediatamente spendibili in classe che ben si adattano allo sviluppo di attività di didattiche laboratoriali, in grado di fornire competenze trasversali basate su una metodologia “project based learning” per il raggiungimento di uno scopo o di un obiettivo specifico che ha molto a che fare con problemi di vita reale.

Saranno svolti 3 incontri di 2 ore ciascuno per un totale di 6 ore

Martedì 10 aprile 2018 – dalle ore 17.00 alle 19.00
Mercoledì 11 aprile 2018 – dalle ore 17.00 alle 19.00
Mercoledì 18 aprile 2018 – dalle ore 17.00 alle 19.00

Potrete rivedere la registrazione del webinar senza limiti di tempo, anche in caso di assenza.
Per accedere, ti basterà acquistare il corso on line attraverso il nostro STORE. Con le stesse credenziali potrai visionare tutti i materiali del corso sulla piattaforma formazione.tecnicadellascuola.it

FORMATORE: Michele Maffucci

DESTINATARI: Docenti e istituzioni scolastiche e formative di ogni ordine e grado

COSTO: 55 euro
LA CASA EDITRICE LA TECNICA DELLA SCUOLA E’ ENTE DI FORMAZIONE ACCREDITATO DAL MIUR
Puoi acquistare i corsi anche con la CARTA DOCENTE

PUNTI TEMATICI CHE SARANNO AFFRONTATI

Strumenti per sostenere l’autoaggiornamento
Le comunità di insegnati sul web. Gruppi di interesse, comunità di pratica
Software cloud per la didattica attiva
Strumenti per comunicare (blog, siti), creare e sostenere la comunità della propria scuola
Strumenti di social bookmarking
La ricerca in rete: dato un problema, risolverlo con l’aiuto della rete
La progettazione condivisa e collaborativa tra i docenti: il curriculum mapping
Strumenti per costruire pensiero computazionale
Progettazione di ambienti cloud per la gestione della classe e la realizzazione di attività collaborative

OBIETTIVI

Verranno forniti competenze digitali ad ampio spettro che permetteranno di:

Costruire un proprio “network di apprendimento sociale” (basato su sistemi di social network) per l’apprendimento delle tecnologie
Valutare quali tecnologie adottare per rendere efficace il proprio lavoro
Dove informarsi sull’uso delle tecnologie didattiche (strategie, tutorial e case history)
Risorse web per la formazione e il supporto all’uso delle tecnologie
Usare le tecnologie per organizzarsi
Documentare per ampliare il proprio “network di apprendimento sociale” al fine di costruire il “diario delle proprie esperienze didattiche”
Saper cercare sul web: “imparare ad imparare l’uso delle tecnologie”
Gestire sistemi di social networking (per apprendere, recuperare per l’inclusione)

MAPPATURA DELLE COMPETENZE

Competenze a supporto di ogni attività giornaliera del docente: contesti, uso di particolari software, organizzazione di una piattaforma di formazione in funzione delle esigenze della classe
Saper scegliere strumenti tecnologici (hardware e software) diversi in rapporto ai contesti classe
Saper scegliere gli strumenti da utilizzare per progettare Unità di Apprendimento trasversali e disciplinari

TITOLO RILASCIATO
La Casa Editrice La Tecnica della Scuola è ente di formazione accreditato dal Miur per la formazione del personale della scuola (prot. n. AOODGPER/6834/2012) ai sensi della direttiva ministeriale n. 90/2003 adeguato ai sensi della Direttiva n. 170/2016.
Ai fini del rilascio dell’attestato di partecipazione, il percorso di formazione si conclude con un test di verifica e un questionario di gradimento del corso di cui è richiesto il completamento.

Il corso è presente sulla piattaforma ministeriale Sofia (ID. 6045), sulla quale sarà possibile iscriversi dopo avere effettuato il pagamento.

Per poter acquistare il corso seguire il LINK

Condividi:

Articoli correlati:

Flip-flop SR con porte NOR

Combinazioni

Modalità di memorizzazione di 1 bit

Ripasso sul funzionamento della porta NOR

Verifica funzionamento come Flip-Flop S-R

Fase 1: Verifica tabella di verità del Flip-Flop SR con integrato 7402

Fase 2: Realizzare un simulatore di Flip-Flop SR con Arduino

Condividi:

Articoli correlati:

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

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: