Archivi tag: automazione

EduRobot – ASL (Alternanza Scuola Lavoro) – Manuale di costruzione – 2/3

In questo seconda parte del manuale di costruzione di EduRobot – ASL vedremo come effettuare tutti i collegamenti elettrici tra motori, Arduino, L298N e proporrò alcuni esercizi.

Durante questa fase non collegate la batteria di alimentazione alla scheda, accertatevi che tutti i collegamenti siano corretti e prima di procedere con i test di funzionamento chiedete un controllo al docente presente in aula oppure contattatemi.

L298N Dual H-Bridge Motor Controller

Per poter pilotare i motori in corrente continua di EduRobot è necessario utilizzare un driver motori costituito da due ponti H, se sei uno dei miei studenti di 3′ che sta svolgendo questa esercitazione per l’Alternanza Scuola Lavoro, ti ricordo che questo argomento di elettronica sarà affrontato al 4′ anno, ma se vuoi avere dettagli sul controllo dei motori in CC puoi consultare la mia dispensa: Alfabeto di Arduino – Lezione 6 alla pagina n. 39 dove spiego come usare un driver L293D e fornisco alcuni sketch di esempio, il funzionamento è molto simile al driver L298N.

Inoltre ti ricordo che per comprendere esattamente il controllo della velocità e della direzione dei motori è essenziale leggere la dispensa: Alfabeto di Arduino – Lezione 2 alla pagina 85 in cui parlo di Modulazione di larghezza di impulso (PWM). Per i miei allievi di 3′ affronterò questo argomento nelle prossime lezioni di Laboratorio di Sistemi.

Per lo svolgimento di questa esercitazione sarà sufficiente seguire gli esempi è fornirò, in maniera molto più semplice la modalità per controllare velocità e direzione di EduRobot.

Ponte H

Per controllare la direzione di rotazione del motore abbiamo bisogno di invertire la direzione del flusso di corrente attraverso il motore, il metodo più comune per fare questa operazione è quella che fa uso di un ponte H.
Un ponte H è costituito da quattro elementi di commutazione che possono essere dei transistor o dei mosfet, per semplicità, poiché hai incominciato elettronica quest’anno, non conosci ancora questi componenti elettronici, per ora assumi la loro funzione a degli interruttori che possiamo comandare attraverso Arduino, nei prossimi mesi ti spiegherò come funzionano.
Al centro del ponte H è collocato il motore elettrico e come puoi vedere dall’immagine, attivando contemporaneamente due interruttori alla volta è possibile modificare la direzione della corrente modificando in questo modo modifichiamo anche la direzione di rotazione del motore.
Nella scheda che ti ho consegnato sono presenti due ponti H uno per ogni motore, inoltre con questa scheda possiamo anche controllare la velocità di rotazione dei motori.

Per ora tutto ciò può essere sufficiente per svolgere l’esercitazione.

L298N Dual H-Bridge Motor Controller è presente in commercio in forme diverse ma con stesse funzionalità, ha una dimensione estremamente contenuta:

L298N Dual H-Bridge Motor Controller

All’interno della scheda sono presenti due ponti H in grado di controllare velocità e senso di rotazione di due motori in CC (quelli gialli che trovate nel kit allegato, a lezioni vi spiegheremo il funzionamento teorico) oppure controllare un motore passo-passo (come quelli presenti nella stampante 3D che vi ho mostrato a scuola). La scheda può essere usata per motori con tensione di alimentazione dai 5 ai 35V e corrente massima di lavoro di 2A.

Ogni ponte H può essere abilitato o disabilitato attraverso i pin enable, quelli che sulla scheda sono indicati con ENA e ENB. Abilitare o meno il ponte H è come dire: “comando o non comando il motore”, per fare un’analogia possiamo considerarlo ENA e ENB all’aceleratore dei motori A e B, vedremo che se viene inviato su di essi un valore MAGGIORE DI 0, permettiamo la rotazione del motore (premiamo l’acceleratore), se invece viene inviato il VALORE 0 ad uno degli EN non permettiamo la rotazione del motore (non premiamo l’acceleratore).

Descrizione dei pin della scheda

Di seguito trovate i riferimenti per la scheda L298N tra numero del pin e la sua funzione:

  1. Motore 1 CC: [OUT1: +]. Motore passo-passo: A+
  2. Motore 1 CC: [OUT2: -]. Motore passo-passo: A-
  3. Jumper da rimuovere se la tensione di alimentazione dei motori risulta superiore ai 12V.
  4. Alimentazione del/dei motori. Il pin accetta una tensione massima di 35V CC. Se la tensione di funzionamento dei motori è superiore ai 12V è necessario rimuovere il ponticello 3
  5. GND – il ground
  6. Uscita a 5 V tensione stabilizzata che può essere usata per alimentare direttamente Arduino
  7. ENA – permette l’abilitazione o la disabilitazione del motore A in CC (Corrente Continua), quello connesso ai pin nominati OUT1 e OUT2. Se si vuole comandare un motore in CC togliere il ponticello o posizionarlo come indicato nell’immagine che segue. Nel caso si voglia pilotare un motore passo passo non rimuovere il ponticello. Il pin ENA dovrà essere connesso ad un pin Arduino di tipo PWM per il controllo della velocità di un motore in CC.
  8. IN1 – per il controllo della direzione di rotazione
  9. IN2 – per il controllo della direzione di rotazione
  10. IN3 – per il controllo della direzione di rotazione
  11. IN4 – per il controllo della direzione di rotazione
  12. ENB – permette l’abilitazione o la disabilitazione del motore A in CC (Corrente Continua), quello connesso ai pin nominati OUT3 e OUT4. Se si vuole comandare un motore in CC togliere il ponticello o posizionarlo come indicato nell’immagine che segue. Nel caso si voglia pilotare un motore passo passo non rimuovere il ponticello. Il pin ENA dovrà essere connesso ad un pin Arduino di tipo PWM per il controllo della velocità di un motore in CC.
  13. Motore 2 CC: [OUT3: +]. Motore passo-passo: B+
  14. Motore 2 CC: [OUT4: +]. Motore passo-passo: B-
Jumper ENA e ENB in modalità motore passo-passo
Jumper ENA e ENB in modalità motore motore in CC

Circuito n. 1 – schema di collegamento

Il collegamento dei motori di EduRobot avranno polarità invertita (ricordate che il motore di sinistra per andara avanti deve girare in senso antiorario e il motore di destra in senso orario), così come indicato nell’immagine che segue, se invertite la polarità la rotazione sarà opposta.

Seguire le indicazioni di collegamento per effettuare i primi test di funzionamento.

I collegamenti tra scheda L298N e Arduino devono essere quelli riportati nello schema e dettagliati nell’immagine che segue. I pin ENA e ENB dovranno essere collegati ai pin 10 e 9 di Arduino che sono pin di tipo PWM con essi controlleremo l’attivazione dei motori e la loro velocità. I pin Arduino di tipo PWM sono quelli indicati dal segno “~“.

Dettaglio collegamento tra L298N ed Arduino UNO

Fate attenzione al collegamento che segue: Pin +12V della Scheda motori con VIN scheda Arduino, ciò consentirà di alimentare direttamente tutta l’elettronica mediante la tensione applicata al Jack di alimentazione di Arduino.

Dettaglio collegamento alimentazione L298N a scheda Arduino UNO (GND – VIN)

L’alimentazione dei motori, della scheda motori e della scheda Arduino UNO avviene collegando una batteria da 9V al Jack di alimentazione di Arduino.

Modalità di alimentazione circuiti

Programmi di test 1

Specifiche: si realizzi la sequenza che ripete ciclicamente la rotazione avanti e indietro delle due ruote del robot:

  • Il motore Sx ruota in senso antiorario (in avanti) per 500 millisecondi (o,5 secondi).
  • Il motore Sx si ferma per 500 millisecondi.
  • Il motore Sx ruota in senso orario (indietro) per 500 millisecondi
  • Il motore Sx si ferma per 500 millisecondi
  • Il motore Dx ruota in senso antiorario (in avanti) per 500 millisecondi (o,5 secondi).
  • Il motore Dx si ferma per 500 millisecondi.
  • Il motore Dx ruota in senso orario (indietro) per 500 millisecondi
  • Il motore Dx si ferma per 500 millisecondi

Quando effettuate l’upload del programma sulla scheda Arduino scollegate la batteria di alimentazione di EduRobot.

Per collegare il cavo USB alla scheda Arduino potrebbe essere necessario togliere la ruota SX.

Per il test del programma posizionate il robot in una modalità in cui le ruote non toccano la superficie di appoggio, per esempio come rappresentato in figura:

Ricordate che la polarità di collegamento dei motori alla scheda L298N è opposta, nel caso di discordanza di rotazione rispetto a quanto indicato nel programma provate ad invertire la modalità di collegamento dei motori sulla breadboard oppure variate il programma.

/*
  Prof. Maffucci Michele
  20.01.19
  
  EduRobot - Programma test n. 1

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

// Impostazione pin motori

// motore 1 (sx)

int direzione1_M1 = 2;
int direzione2_M1 = 3;
int velocita_M1 = 9; // pin di tipo PWM per controllare la velocità del motore

// motore 2 (dx)

int direzione1_M2 = 4;
int direzione2_M2 = 5;
int velocita_M2 = 10; // pin di tipo PWM per controllare la velocità del motore

int velocita = 200;         // velocità di rotazione dei motori. Valore compreso tra 0 e 255
int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int attesa = 3000; // tempo di attesa prima che parta la rotazione dei motori

void setup() {

  // modalità di utilizzo dei pin di controllo
  pinMode(direzione1_M1, OUTPUT);
  pinMode(direzione2_M1, OUTPUT);
  pinMode(velocita_M1, OUTPUT);
  pinMode(direzione1_M2, OUTPUT);
  pinMode(direzione2_M2, OUTPUT);
  pinMode(velocita_M2, OUTPUT);

  delay(attesa);
}

void loop() {

// --- Motore 1 ---

  // Motore 1 (Sx) avanti - senso antiorario

  analogWrite(velocita_M1, velocita); // Imposta la velocità del motore M1 a velocità = 200

  // per far girare il motore M1 (Sx) in senso antiorario
  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  delay(tempo_rotazione);

  // Motore 1 (Sx) fermo

  analogWrite(velocita_M1, 0); // Per fermare il motore impostare a 0 il secondo parametro

  // fermare il motore M1 (Sx)
  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, LOW);
  delay(tempo_rotazione);

  // Motore 1 (Sx) indietro - in senso orario

  analogWrite(velocita_M1, velocita); // Imposta la velocità del motore M1 a velocità = 200

  // per far girare il motore M1 (Sx) in senso orario
  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  delay(tempo_rotazione);

  // Motore 1 (Sx) fermo

  analogWrite(velocita_M1, 0); // Per fermare il motore impostare a 0 il secondo parametro

  // fermare il motore M1 (Sx)
  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, LOW);
  delay(tempo_rotazione);

// --- Motore 2 ---

  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M2, velocita); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M2 (Dx) in senso orario
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo_rotazione);

  // Motore 2 (Dx) fermo

  analogWrite(velocita_M2, 0); // Per fermare il motore impostare a 0 il secondo parametro

  // fermare il motore M2 (Dx)
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo_rotazione);

  // Motore 2 (Dx) indietro - senso antiorario

  analogWrite(velocita_M2, velocita); // Imposta la velocità del motore M2 a velocità = 200

  // per far girare il motore M2 (Dx) in senso antiorario
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo_rotazione);

  // Motore 2 (Dx) fermo

  analogWrite(velocita_M2, 0); // Per fermare il motore impostare a 0 il secondo parametro

  // fermare il motore M2 (Dx)
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo_rotazione);
}

Esercizio 1

Realizzare un programma che ciclicamente esegua la sequenza: avanzamento di EduRobot in avanti per 500 millisecondi, si ferma nella posizione per 500 millisecondi e successivamente torna indietro (in retromarcia) per 500 millisecondi e si ferma nella posizione per 500 millisecondi.

Esercizio 2

Realizzare un programma che faccia compiere ciclicamente a EduRobot il perimetro di un quadrato. Il tempo di percorrenza di ogni singolo lato deve essere di 500 millisecondi e la velocità di rotazione deve essere ridotta a 150 (variabile: velocita = 150).

Semplifichiamo la gestione dei motori

Per semplificare la gestione dei motori utilizziamo una specifica libreria sviluppata da yohendry e che dovrà essere prelevata dal seguente link: https://github.com/yohendry/arduino_L298N

Il file zip scaricato dovrà essere installato all’interno di Arduino (per i miei allievi questa operazione richiede le password di amministratore del computer, chiedere il supporto dell’Assistente di Laboratorio).

Per installare la libreria: Sketch > Include library > Add ZIP Library… e caricare il file ZIP precedentemente scaricato:

All’interno della libreria troverete una cartella con due esempi che potete utilizzare per comprendere il funzionamento della libreria:

Programma test n. 2

Specifiche: Utilizzando la libreria appena installata per realizzare un programma che ciclicamente esegua i seguenti passi:

  • avanti per 500 millisecondi
  • sosta di 500 millisecondi
  • indietro per 500 millisecondi
  • sosta di 500 millisecondi.
/*
  Prof. Maffucci Michele
  20.01.19

  EduRobot - Programma test n. 2
  Avanti e indietro

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

#include <L298N.h>

const int ENB = 10;
const int IN4 = 5;
const int IN3 = 4;
const int IN2 = 3;
const int IN1 = 2;
const int ENA = 9;


L298N driver(ENA, IN1, IN2, IN3, IN4, ENB);

int tempo_rotazione = 500;
int velocita = 200;

void setup() {
}

void loop()
{
  driver.forward(velocita, tempo_rotazione);  // avanti per per 500 millisecondi alla velocità 200
  driver.full_stop(tempo_rotazione);          // fermata di 500 millisecondi
  driver.backward(velocita, tempo_rotazione); // indietro per per 500 millisecondi alla velocità 200
  driver.full_stop(tempo_rotazione);          // fermata di 500 millisecondi
}

Programma test n. 3

Specifiche: Utilizzando la libreria appena installata per realizzare un programma che ciclicamente esegua i seguenti passi:

  • avanti per 500 millisecondi
  • sosta di 500 millisecondi
  • rotazione a destra per 500 millisecondi
  • sosta di 500 millisecondi
  • rotazione a sinistra per 500 millisecondi
  • sosta di 500 millisecondi
  • indietro per 500 millisecondi.

Impostare la velocità dei motori a 100.

/*
  Prof. Maffucci Michele
  20.01.19

  EduRobot - Programma test n. 3
  Movimento

  Collegamenti:

  L298N -->  Arduino

  ENB  -->  Pin 10
  IN4  -->  Pin 5
  IN3  -->  Pin 4
  IN2  -->  Pin 3
  IN1  -->  Pin 2
  ENA  -->  Pin 9
  +12V -->  Vin
  GND  -->  GND
*/

#include <L298N.h>

const int ENB = 10;
const int IN4 = 5;
const int IN3 = 4;
const int IN2 = 3;
const int IN1 = 2;
const int ENA = 9;


L298N driver(ENA, IN1, IN2, IN3, IN4, ENB);

int tempo_rotazione = 500;
int velocita = 100;
void setup() {
}

void loop()
{
  driver.forward(velocita, tempo_rotazione);    // avanti per per 500 millisecondi alla velocità 200
  driver.full_stop(tempo_rotazione);            // fermata di 500 millisecondi
  driver.turn_right(velocita, tempo_rotazione); // rotazione a destra per 500 millisecondi
  driver.full_stop(tempo_rotazione);            // fermata di 500 millisecondi
  driver.turn_left(velocita, tempo_rotazione); // rotazione a sinistra per 500 millisecondi
  driver.full_stop(tempo_rotazione);            // fermata di 500 millisecondi
  driver.backward(velocita, tempo_rotazione);   // indietro per per 500 millisecondi alla velocità 200
}

Esercizio 3

Dovreste aver notato che il robot accelerando in avanti si alza bruscamente (impenna) siete in grado di realizzare un programma che faccia accelerare gradualmente in avanti il robot?

Esercizio 4

Utilizzando la libreria appena installata realizzare un programma che faccia muovere EduRobot lungo il perimetro di un quadrato.

Buon lavoro.

EduRobot – ASL (Alternanza Scuola Lavoro) – Manuale di costruzione – 1/3

Al terzo anno, presso l’istituto dove attualmente lavoro, l’ITIS G.B. Pininfarina di Moncalieri (To), gli studenti svolgono un’attività di azienda simulata e per l’occasione, visto i tempi brevi di cui si dispone ho ripreso un progetto di qualche anno fa EduRobot (trovate i riferimenti seguendo il link), un kit robotico con struttura in legno a bassissimo costo che sviluppai come parte di un modulo di automazioni che svolsi in altra scuola.

L’idea è quella di simulare un’azienda che sviluppa e produce kit robotici per la didattica per l’insegnamento del Coding per gli studenti di scuola media. Gli studenti sulla base del kit che ho prodotto, dovranno costruirlo, programmarlo, pensare a soluzioni per migliorarlo sia dal punto di vista hardware che software, realizzare la manualistica e depliant pubblicitari in lingua inglese.

Questo manuale di lavoro vuole essere la guida per i miei allievi di 3A Automazione e 3B Automazione e per tutti coloro che intendono realizzare un robot.

La struttura è costituita da un supporto in legno su cui collocare tutta l’elettronica, la struttura potrete realizzarla di qualsiasi altro materiale o forma in quanto gli elementi di base sono realizzati in 3D e si adattano a qualsiasi supporto, per recuperare il materiale precedente acquistato riutilizzerò la base di EduRobot.

Per chi desidera stampare gli elementi seguite il link alla pagina di Thingiverse dove ho reso disponibile tutti i file, troverete gli elementi che si adattano ad EduRobot e gli elementi generici che potrete usare per qualsiasi robot.

Per i miei allievi: tutti gli elementi sono stati già stampati e la breadboard è già fissata su un supporto in legno.

Nei file stl che trovate su Thingiverse ho aggiunto un il file: Supporti-Motori-Universale.stl da sostituire a Supporti-Motori-EduRobot.stl nel caso in cui voi non basate la vostra costruzione su EduRobot.

Nel prossimo futuro sostituirò la batteria di alimentazione da 9V con una batteria LiPo.

Il manuale è strutturato in 3 parti

  1. Manuale di costruzione (questa pagina)
  2. Manuale collegamenti elettrici
  3. Manuale di programmazione

Per i miei studenti del Pininfarina

  • Tutta l’attività sarà valutata.
  • Sarà fornito un kit già montato che dovrà essere condiviso tra la 3A Automazione e 3B Automazione in modo che, nel caso di dubbi, possiate usarlo come riferimento.
  • Tutti gli elementi stampati in 3D dovranno essere fissati con delle viti metalliche. Ricordo a tutti di non forzare troppo il serraggio delle viti in quanto potreste rompere gli elementi stampati in 3D.
  • Tutti gli elementi consegnati sono di proprietà del sottoscritto e poiché userò questi elementi anche in altre classi vi chiedo la massima cura nella gestione dei materiali, nel caso di problemi non esitate a contattarmi.
  • Questa manualistica di assemblaggio sarà conservata nella sezione EduRobot di questo sito.
  • Attenzione alla gestione dei motori! I cavi di collegamento sono saldati ai due poli del motore, questi sono estremamente delicati, per evitare rotture ho utilizzato una fascetta di plastica che dovrebbe evitare il distacco.
  • Nella kit fornito aggiungerò un quantitativo di dadi e viti maggiore a quello realmente necessario, saranno tutti di misura M3.
  • Non sono richiesti attrezzi aggiuntivi, all’interno del kit avete ha disposizione anche un piccolo cacciavite a stella sufficiente per la costruzione del robot, se preferite potete utilizzare anche gli strumenti disponibili in laboratorio.
  • Nel caso di rotture di qualsiasi apparato comunicare tempestivamente al docente presente in aula e poi a me in modo da poter sostituire tempestivamente l’oggetto (ma spero ciò non accadrà 😉 ).
  • Al termine di ogni lezione riporre all’interno del contenitore fornito tutti i semilavorati.
  • Ogni scatola è numerata, su di essa è indicato il numero del gruppo e la classe.
  • In ogni scatola troverete un piccolo contenitore dove riporre le minuterie.
  • Ogni robot è numerato. Il numero del robot NON coincide con il numero della scatola.
  • Non sono richieste saldature.

Procedimento

Orientamento del robot

Nelle spiegazioni si farà riferimento all’orientamento specificato nelle immagini che seguono:

Passo 1

Per questa fase avrete bisogno di:

  • breadboard
  • alloggiamento batteria di scorta
  • due dadi M3
  • due viti M3 da 12 mm
  • giravite a stella

Fissare sulla basetta di compensato con due viti da 12 mm la breadboard (già fissata su basetta di legno) e l’alloggiamento per la batteria di riserva.

Passo 2

Per questa fase avrete bisogno di:

  • caster ball
  • due dadi M3
  • due viti M3 da 10 mm
  • giravite a stella

Fissare la caster ball facendo attenzione all’orientamento, l’elemento di rinforzo obliquo deve essere orientato come riportato in figura, i dadi M3 devono entrare nella sede della struttura della caster ball, serrare il tutto con viti da 10 mm.

Passo 3

Per questa fase avrete bisogno di:

  • elementi realizzati al passo precedente
  • due supporti motori
  • quattro dadi M3
  • quattro viti M3 da 12 mm
  • giravite a stella

Fissare i motori alla basetta di compensato mantenendo la testa delle viti verso il lato inferiore del robot così come indicato nell’immagine.

Passo 4

Per questa fase avrete bisogno di:

  • elementi realizzati al passo precedente
  • due motori
  • quattro dadi M3
  • quattro viti M3 da 25 mm
  • giravite a stella

Fissare i motori ai supporti usando due viti da 25 mm. L’orientamento dei motori deve essere con i punti di saldatura dei fili verso l’interno della struttura, così come indicato nell’immagine che segue. Far passare i cavi dei motori attraverso i fori quadrati.

Passo 5

Per questa fase avrete bisogno di:

  • scheda motori L298N
  • supporto scheda motori
  • 3 dadi M3
  • 3 viti M3 da 10 mm
  • giravite a stella

Avvitare la scheda motori L298N con 3 viti da 12 mm.

Verificate che i jumper siano disposti come rappresentati nell’immagine che segue:

Passo 6

Per questa fase avrete bisogno di:

  • elementi assemblati del passo precedente
  • scheda Arduino
  • supporto compensato
  • 4 dadi M3
  • 4 viti M3 da 35 mm
  • supporto scheda Arduino
  • giravite a stella

Sul lato superiore della basetta di compensato posizionare il supporto per la scheda Arduino ed inserire le 4 viti M3 da 35 mm e su di esso inserire la scheda L298N in modo da realizzare una struttura a sagwitch.

Passo 7

Per questa fase avrete bisogno di:

  • elementi assemblati del passo precedente
  • 2 dadi M3
  • 2 viti M3 da 10 mm
  • batteria da 9V
  • jack connessione batteria
  • giravite a stella

Avvitare con due viti da 10 mm l’alloggiamento per la batteria da 9V mantenendo i due svasi del supporto batteria verso il lato sinistro come indicato nell’immagine.

Passo 8

Per questa fase avrete bisogno di:

  • elementi assemblati del passo precedente
  • 2 ruote

Inserire le ruote. Fate attenzione! Non spingete con forza. Il profilo del foro e del mozzo sono costituiti da un mozzo smussato è l’inserimento può avvenire in un solo modo.

Passo 9

Per questa fase avrete bisogno di:

  • elementi assemblati del passo precedente
  • batteria 9V di riserva

Inserire la batteria aggiuntiva nella sede al di sotto del robot. Questa batteria servirà inoltre per appesantire il robot nella parte anteriore ed evitare che in accelerazione il robot si alzi anteriormente.

Buon lavoro 🙂

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

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

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

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à:

OR

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:

  1. primo avvio – selezione funzione (da 1 a 7) inserendo da tastiera il numero sulla Serial Monitor
  2. 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
  3. 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:

  1. 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.
  2. 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).
  3. 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.
  4. Aggiungere il codice per effettuare il debounce (anti-rimbalzo) sui pulsanti.
  5. 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 🙂

E’ nato rokers.io!

rokers
E’ trascorso ormai un anno da quanto insieme a Ludovico incominciammo a strutturare meglio i nostri robot didattici, (benedetto fu quel tendine che si ruppe 🙂 ) molti eventi, molti incontri con tantissime persone, scambio di competenze, creazioni robotiche e tanto “imparare insieme” e tutto ciò si concludeva quasi sempre con una cena.

Negli scorsi giorni ci siamo interrogati sul perché non dare corpo a questo nostro modo di agire dando una struttura più formale a questi momenti di “robotica e pizza“?

Perché non pensare ad una community di sviluppatori robotici?

In concomitanza con la prima Cloud Rokers Faire di Torino, siamo felici di annunciare il nuovo progetto rokers.io, voluto da Michele Maffucci, Ludovico Russo e Gabriele Ermacora, per supportare la nascita di una community Italiana di Sviluppatori Robotici.

Rokers è un progetto nuovo, e ancora non ha una vera e propria forma. Lo scopo principale, al momento, è creare una forte community di sviluppatori di robotica di servizio a Torino ed in Italia. E questo verrà fatto, in prima battuta, organizzando ritrovi periodici in cui si parlerà di Robotica nelle sue varie forme.

Vuoi far parte della community? Compila questo form, verrai informato delle iniziative che organizzeremo e potrai dare un tuo personalissimo contributo al progetto.

Ma cosa vuol dire rokers?

“RObot MaKERS”

Ma per chi è questa community?

La community è aperta a tutti coloro che amano per passione o per professione la robotica di servizio non è importante essere nerd del settore l’importante e voler condividere progetti, formare o essere formati in maniera gratuita e libera, in piena serenità, senza alcuna paura di non sapere ma con la sola voglia di imparare…e mangiare insieme… ecco in modo semplice tutto ciò lo vogliamo chiamare roker (senza la c mi raccomando 🙂 )

Se credi nell’Open Source, nell’Open Hardware e nella Open Culture, che tu sia studente, insegnante (di qualsiasi materia e di qualsiasi ordine), “scienziato pazzo” o qualsiasi altra cosa allora puoi far parte di roker.io

Il sito è nato ieri ed in costruzione, lo utilizzeremo per segnalare le attività che gli associati vorranno realizzare… l’iscrizione non costa nulla è sufficiente compilare il form per dire: “vogliamo essere dei robot maker” 🙂

Ricorda, se non sei di Torino non fa nulla l’idea è far nascere una community fatta di gruppi che promuovono la robotica di servizio e la robotica didattica presso la propria città, roker.io servirà per creare relazioni tra persone e annunciare iniziative e condividere esperienze.
Ci piace pensare a dei luoghi simili a degli hackerspace che si occupano di robotica.

Il desiderio è andare oltre le gare robotica o gli eventi espositivi, vogliamo pensare a una didattica diversa, ad una robotica che sia di ausilio alla disabilità e molto altro… come realizzare tutto ciò? Creando un network di persone competenti ognuna per il proprio settore… riusciremo? Non so dirvi! Ma provarci non costa nulla 🙂

WhatsApp Image 2017-05-08 at 07.49.12

 

Pilotaggio di un teleruttore di potenza mediante Arduino

Questa mattina sperimentazione per l’impostazione di una serie di esperienze di laboratorio per sistemi di controllo civili e industriali basati su Arduino. Il percorso didattico che ho progettato è volto alla realizzazione di una serie di casi studio/strategie volte all’insegnamento sia dell’informatica chedell’impiantistica. Nell’esempio realizzato questa mattina si è verificato l’assorbimento dei contatti del mini relè di pilotaggio.

Sono in fase di realizzazione shield di controllo con funzioni particolari e plance per esercitazioni civili e industriali su cui alloggiare l’elettronica di controllo.

Nelle prossime sperimentazione controllo e sequenze di sistemi trifase.

Il teleruttore di potenza usato, di cui potete vedere il funzionamento nei primi due filmati, è della serie Lovato tipo BF12 per carichi fino a 3HP in regime alternato trifase, corrente assorbita dalla bobina di comando del teleruttore 0,49 A in regime sinusoidale (impedenza Z=4,4+j47,79) Induttanza L della bobina 152mH. Circuito di comando 24 AC alimentazione Arduino 9V (nei due filmati prima con batteria da 9V e poi con alimentatore stabilizzato).

Analogo esperimento con teleruttore Audoli, caratteristiche visibili nella fotografia allegata.

Prossimamente pubblicherò gli schemi di collegamento.

Un grazie particolare va all’amico Orazio Romano. La sua esperienza decennale nel settore dell’impiantistica civile ed industriale è per me essenziale sia per imparare che per realizzare questo nuovo percorso didattico.

Arduino alimentato da batteria a 9V – teleruttore Lovato tipo BF12

Arduino alimentato da alimentatore esterno – teleruttore Lovato tipo BF12

Arduino alimentato da alimentatore esterno – teleruttore Audoli

La danza del teleruttore 🙂

controllo-teleruttore-con-arduino-01

controllo-teleruttore-con-arduino-02

controllo-teleruttore-con-arduino-03