Michele Maffucci

Google per la didattica – 6′ edizione

Pubblicato il Febbraio 13, 2019 da admin

Guida all’uso degli applicativi Google finalizzati
ad un uso didattico, dalla ricerca alla creazione di contenuti

Giunto alla 6′ edizione il corso avrà inizio oggi, saranno svolti 5 incontri di 2 ore ciascuno per un totale di 10 ore di formazione

Mercoledì 13 febbraio 2019 – dalle ore 17.00 alle 19.00
Giovedì 14 febbraio 2019 – dalle ore 17.00 alle 19.00
Mercoledì 20 febbraio 2019 – dalle ore 17.00 alle 19.00
Mercoledì 6 marzo 2019 – dalle ore 17.00 alle 19.00
Giovedì 7 marzo 2019 – dalle ore 17.00 alle 19.00

Come accade in ogni edizione, aggiungerò ulteriori proposte di esercizio e sperimentazioni da condurre in classe con gli studenti.

Per maggiori informazioni sui contenuti del corso e sulle modalità di iscrizione vi rimando al pagina dedicata sul sito di Tecnica della Scuola.

Articoli simili:

Pubblicato in corsi | Contrassegnato corso, google, google per la didattica, Tecnica della Scuola | Lascia un commento

Winter Camp 2019 – sviluppare competenze attraverso le nuove tecnologie

Pubblicato il Gennaio 26, 2019 da admin

Creatività, espressione e innovazione per il Primo Ciclo – sviluppare competenze attraverso le nuove tecnologie.

Sabato 23 e 24 febbraio prossimi parteciperò come relatore alla terza edizione degli INcontri digitali presso l’Istituto Comprensivo Statale di Vestone (Brescia), corso invernale di formazione per insegnanti.

Il laboratorio che condurrò ha come titolo: “Divertiamoci a progettare il nostro apprendimento con il Coding e la robotica” e sarà dedicato a docenti della primaria e secondaria di primo grado.

questo l’abstract:

Insegnare a progettare il proprio apprendimento attraverso il Creative Computing utilizzando BBC micro:bit una picola scheda elettronica appositamente progettata per svolgere attività di Coding con studenti della scuola primaria e secondaria di primo grado.

BBC micro:bit può essere programmato in diverse modalità, ma quella principale fa uso di un ambiente di sviluppo on-line che permette di operare con un linguaggio di programmazione grafico, costituito da blocchi funzionali che possono essere tra essi collegati.

Le caratteristiche tecniche di micro:bit consentono di realizzare attività con forte interattività con il mondo reale: robot, strumenti musicali, strumenti di misura, giochi interattivi e molto altro, attività che verranno sperimentate durante il workshop.

L’evento include altri interessangtissimi laboratori condotti dai colleghi:

Roberto Sconocchini – Laboriatorio: C’ERA UNA VOLTA… – Per scuola dell’infanzia e primaria
Luca Raina – LABORATORIO: GAMIFICATION – Per scuola primaria e secondaria di 1° grado

Per maggiori informazioni:

Pagina di presentazione evento: Winter Camp 2019
Per le iscrizioni: Iscrizione al Winter Camp 2019 “INcontri Digitali”

Locandina di presentazione:

Articoli simili:

Pubblicato in corsi, micro:bit, robotica | Contrassegnato brescia, coding, Creative Computing, docenti, formazione, incontri digitali, micro:bit, robotica, tecnologie, Vestone, Winter Camp 2019 | Lascia un commento

Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Pubblicato il Gennaio 25, 2019 da admin

Addendum al progetto EduRobot.

Una settimana è bastata per scatenare la fantasia di giovani studenti alle prese con EduRobot per l’attività di Alternanza Scuola Lavoro. Le relazioni di lavoro mettono in evidenza soluzioni alternative originali, la richiesta è di continuare ad aggiungere funzionalità ad EduRobot, vedremo nelle prossime settimane come proseguire con i lavori, ma sicuramente in questa prima fase mi posso ritenere soddisfatto! 😊

Tra le richieste che mi sono state fatte vi è quella di inserire un display per aggiungere interattività con il robot. Tra le possibilità ho suggerito l’utilizzo di un LCD 16×2 Hitachi HD44780 1602 quelli in dotazione con molti kit Arduino. Per rendere più agevole la gestione e i collegamenti, visto l’elevato numero di connessioni presenti su EduRobot, ho consigliato l’utilizzo di un modulo PCF8574T per il controllo in I2C, poiché gli studenti sono giovani ed ancora non hanno affrontato questo argomento, con questo post voglio dare un piccolo aiuto.

Disponiamo dei moduli della sunfounder su cui è già saldato il modulo i2C:

l’utilizzo è identico ai più comuni expander esterni come quelli indicati nell’immagine che segue:

Il display è costituito da 4 pin di connessione, due dedicati all’alimentazione e due alla comunicazione i2C.

Le connessioni tra LCD1602 i2C ed Arduino sono i seguenti:

LCD1602 —> Arduino
GND -> GND
Vcc -> 5V
SDA -> A4
SCL -> A5

Per poter utilizzare questo display è necessario installare la libreria LiquidCrystal_I2C dal seguente link: https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library

Prelevate il file .zip ed installate la libreria direttamente dall’IDE di Arduino:

in alternativa potete scompattare e copiare il tutto nella cartella libraries di Arduino.

Piccolo avvertimento, sicuramente nelle vostre sperimentazioni prenderete spunto da sketch che troverete on-line, alcune volte questi esempi sono datati e si riferiscono ad una versione dell’ide di qualche anno fa in cui si poteva inizializzare l’LCD nel setup con: lcd.init(), ciò non è più possibile sostituitela con la classe lcd.begin() così come indicato negli esempi che seguono.

Includo a questo post una serie di sketch tutti tratti dal reference di Arduino e riadattati per un uso con il modulo PCF8574T in modo da accelerare le attività di sperimentazione dei miei allievi.

Il funzionamento di ogni esempio è dettagliato con commenti all’interno degli sketch.

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 1: scrittura testo su due righe
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------
void setup()
{
  lcd.begin(),      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
}
//-----------------------------


void loop()
{
  lcd.setCursor(2,0);
  lcd.print("Ciao Ragazzi");
  lcd.setCursor(0,1);
  lcd.print("Io sono EduRobot");
}

/* Prof. Michele Maffucci

* Utilizzo di un display LCD 16×2 Hitachi HD44780 1602

* con modulo i2C PCF8574T

* Esempio 1: scrittura testo su due righe

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin

LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

//-----------------------------

void setup()

{

lcd.begin(), // inizializzazione dell'LCD

lcd.backlight(); // attivazione della retroilluminazione

}

//-----------------------------

void loop()

{

lcd.setCursor(2,0);

lcd.print("Ciao Ragazzi");

lcd.setCursor(0,1);

lcd.print("Io sono EduRobot");

}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 2: noBlink - Blink
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------
void setup()
{
  lcd.begin(),      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
}
//-----------------------------

void loop() {
  // Turn off the blinking cursor:
  lcd.noBlink();
  delay(3000);
  // Turn on the blinking cursor:
  lcd.blink();
  delay(3000);
}

/* Prof. Michele Maffucci

* Utilizzo di un display LCD 16×2 Hitachi HD44780 1602

* con modulo i2C PCF8574T

* Esempio 2: noBlink - Blink

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin

LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

//-----------------------------

void setup()

{

lcd.begin(), // inizializzazione dell'LCD

lcd.backlight(); // attivazione della retroilluminazione

}

//-----------------------------

void loop() {

// Turn off the blinking cursor:

lcd.noBlink();

delay(3000);

// Turn on the blinking cursor:

lcd.blink();

delay(3000);

}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 3: noDisplay - Display
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------
void setup()
{
  lcd.begin(),      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
  lcd.print("EduRobot");
}
//-----------------------------

void loop() {
  // disattiva il display
  lcd.noDisplay();
  delay(500);
  // attiva il display
  lcd.display();
  delay(500);
}

/* Prof. Michele Maffucci

* Utilizzo di un display LCD 16×2 Hitachi HD44780 1602

* con modulo i2C PCF8574T

* Esempio 3: noDisplay - Display

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin

LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

//-----------------------------

void setup()

{

lcd.begin(), // inizializzazione dell'LCD

lcd.backlight(); // attivazione della retroilluminazione

lcd.print("EduRobot");

}

//-----------------------------

void loop() {

// disattiva il display

lcd.noDisplay();

delay(500);

// attiva il display

lcd.display();

delay(500);

}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 4: scrollDisplayLeft() - scrollDisplayRight()
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------
void setup()
{
  lcd.begin(),      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
  lcd.print("EduRobot");
  delay(1000);
}
//-----------------------------

void loop() {
  // sposta di 8 posizioni (lunghezza della tringa: EduRobot) a sinistra
  for (int positionCounter = 0; positionCounter < 8; positionCounter++) {
    // per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante
    lcd.scrollDisplayLeft();
    // aspetta un momento:
    delay(150);
  }

  // sposta di 24 posizioni (lunghezza della tringa + lunghezza del siplay(n. colonne)) a destra
  for (int positionCounter = 0; positionCounter < 24; positionCounter++) {
    // sposta di una posizione a destra
    lcd.scrollDisplayRight();
    // per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante
    delay(150);
  }

  // sposta di 24 posizioni (lunghezza della tringa + lunghezza del siplay(n. colonne)) a sinistra
  // to move it back to center:
  for (int positionCounter = 0; positionCounter < 24; positionCounter++) {
    // sposta di una posizione a sinistra
    lcd.scrollDisplayLeft();
    // per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante
    delay(150);
  }

  // al termine di un ciclo di uno spostamento destra e sinistra
  // attesa di 1 secondo
  delay(1000);
}

/* Prof. Michele Maffucci

* Utilizzo di un display LCD 16×2 Hitachi HD44780 1602

* con modulo i2C PCF8574T

* Esempio 4: scrollDisplayLeft() - scrollDisplayRight()

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin

LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

//-----------------------------

void setup()

{

lcd.begin(), // inizializzazione dell'LCD

lcd.backlight(); // attivazione della retroilluminazione

lcd.print("EduRobot");

delay(1000);

}

//-----------------------------

void loop() {

// sposta di 8 posizioni (lunghezza della tringa: EduRobot) a sinistra

for (int positionCounter = 0; positionCounter < 8; positionCounter++) {

// per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante

lcd.scrollDisplayLeft();

// aspetta un momento:

delay(150);

}

// sposta di 24 posizioni (lunghezza della tringa + lunghezza del siplay(n. colonne)) a destra

for (int positionCounter = 0; positionCounter < 24; positionCounter++) {

// sposta di una posizione a destra

lcd.scrollDisplayRight();

// per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante

delay(150);

}

// sposta di 24 posizioni (lunghezza della tringa + lunghezza del siplay(n. colonne)) a sinistra

// to move it back to center:

for (int positionCounter = 0; positionCounter < 24; positionCounter++) {

// sposta di una posizione a sinistra

lcd.scrollDisplayLeft();

// per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante

delay(150);

}

// al termine di un ciclo di uno spostamento destra e sinistra

// attesa di 1 secondo

delay(1000);

}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 5: Serial Input
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------
void setup()
{
  lcd.begin(),        // inizializzazione dell'LCD
  lcd.backlight();    // attivazione della retroilluminazione
  Serial.begin(9600); // inizializzazione della porta seriale
}
//-----------------------------


void loop() {
  // quando un carattere viene inviato alla serial monitor...
  if (Serial.available()) {
    // attende un momento prima di inviare il testo sulla seril monitor
    delay(100);
    // cancella lo schermo
    lcd.clear();
    // legge tutti i caratteri disponibili sulla seriale
    while (Serial.available() > 0) {
      // visualizza i caratteri sul display
      lcd.write(Serial.read());
    }
  }
}

/* Prof. Michele Maffucci

* Utilizzo di un display LCD 16×2 Hitachi HD44780 1602

* con modulo i2C PCF8574T

* Esempio 5: Serial Input

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin

LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

//-----------------------------

void setup()

{

lcd.begin(), // inizializzazione dell'LCD

lcd.backlight(); // attivazione della retroilluminazione

Serial.begin(9600); // inizializzazione della porta seriale

}

//-----------------------------

void loop() {

// quando un carattere viene inviato alla serial monitor...

if (Serial.available()) {

// attende un momento prima di inviare il testo sulla seril monitor

delay(100);

// cancella lo schermo

lcd.clear();

// legge tutti i caratteri disponibili sulla seriale

while (Serial.available() > 0) {

// visualizza i caratteri sul display

lcd.write(Serial.read());

}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 6: setCursor()
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------

const int numRows = 2;
const int numColonne = 16;

void setup()
{
  lcd.begin(),        // inizializzazione dell'LCD
  lcd.backlight();    // attivazione della retroilluminazione
}
//-----------------------------


void loop() {
  // stampa in loop i caratteri ASCII da 'a' a 'z':
  for (int lettera = 'a'; lettera <= 'z'; lettera++) {
    // ciclo per le colonne
    for (int  riga = 0; riga < numRows; riga++) {
      // ciclo per le righe
      for (int colonna = 0; colonna < numColonne; colonna++) {
        // imposta la posizione del cursore
        lcd.setCursor(colonna, riga);
        // stama il carattere
        lcd.write(lettera);
        delay(200);
      }
    }
  }
}

/* Prof. Michele Maffucci

* Utilizzo di un display LCD 16×2 Hitachi HD44780 1602

* con modulo i2C PCF8574T

* Esempio 6: setCursor()

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin

LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

//-----------------------------

const int numRows = 2;

const int numColonne = 16;

void setup()

{

lcd.begin(), // inizializzazione dell'LCD

lcd.backlight(); // attivazione della retroilluminazione

}

//-----------------------------

void loop() {

// stampa in loop i caratteri ASCII da 'a' a 'z':

for (int lettera = 'a'; lettera <= 'z'; lettera++) {

// ciclo per le colonne

for (int riga = 0; riga < numRows; riga++) {

// ciclo per le righe

for (int colonna = 0; colonna < numColonne; colonna++) {

// imposta la posizione del cursore

lcd.setCursor(colonna, riga);

// stama il carattere

lcd.write(lettera);

delay(200);

}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 7: leftToRight() - rightToLeft()
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
//-----------------------------

int lettera = 'a';

void setup()
{
  lcd.begin(),        // inizializzazione dell'LCD
  lcd.backlight();    // attivazione della retroilluminazione
  lcd.cursor();       // attiva il cursore
}
//-----------------------------


void loop() {
  // cambia direzione (da destra a sinistra)
  // quando l'ultima lettera stampata è la 'm':
  if (lettera == 'm') {
    // sposta il cursore a destra per stampare la lettera successiva
    lcd.rightToLeft();
  }
  // cambia direzione (da sinistra a destra)
  // // quando l'ultima lettera stampata è la 's':
  if (lettera == 's') {
    // sposta il cursore a sinistra per stampare la lettera successiva
    lcd.leftToRight();
  }
  // reset quando atriviamo alla 'z':
  if (lettera > 'z') {
    // spostare il cursore a (0,0):
    lcd.home();
    // ricomincia dalla posizione 0
    lettera = 'a';
  }
  // stampa il carattere
  lcd.write(lettera);
  // aspetta un secondo
  delay(1000);
  // incrementa la lettera
  lettera++;
}

/* Prof. Michele Maffucci

* Utilizzo di un display LCD 16×2 Hitachi HD44780 1602

* con modulo i2C PCF8574T

* Esempio 7: leftToRight() - rightToLeft()

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin

LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

//-----------------------------

int lettera = 'a';

void setup()

{

lcd.begin(), // inizializzazione dell'LCD

lcd.backlight(); // attivazione della retroilluminazione

lcd.cursor(); // attiva il cursore

}

//-----------------------------

void loop() {

// cambia direzione (da destra a sinistra)

// quando l'ultima lettera stampata è la 'm':

if (lettera == 'm') {

// sposta il cursore a destra per stampare la lettera successiva

lcd.rightToLeft();

}

// cambia direzione (da sinistra a destra)

// // quando l'ultima lettera stampata è la 's':

if (lettera == 's') {

// sposta il cursore a sinistra per stampare la lettera successiva

lcd.leftToRight();

}

// reset quando atriviamo alla 'z':

if (lettera > 'z') {

// spostare il cursore a (0,0):

lcd.home();

// ricomincia dalla posizione 0

lettera = 'a';

}

// stampa il carattere

lcd.write(lettera);

// aspetta un secondo

delay(1000);

// incrementa la lettera

lettera++;

}

Buona sperimentazione 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi | Contrassegnato alternanza, alternanza scuola lavoro, arduino, asl, automazione, azienda simulata, coding, EduRobot, i2c, ITI Pininfarina, lcd, moncalieri, robot, robotica | Lascia un commento

Errori comuni nell’uso di Arduino – confondere pin analogici con pin digitali

Pubblicato il Gennaio 22, 2019 da admin

Come sicuramente saprete i pin analogici di Arduino UNO, da A0 a A5 possono essere utilizzati anche in modalità digitale e questa caratteristica alcune volte crea qualche confusione in quanto i pin se vengono utilizzati in modalità analogica non è necessario dichiararne il pinMode all’interno del setup(), ciò ovviamente non accade se bisogna usarli in modalità digitale.
Dopo un po’ questa funzionalità viene memorizzata, un modo per non dimenticare questa caratteristica potrebbe essere quella di inserire una dichiarazione “inutile” che ne rammenta la modalità di utilizzo:

void setup() {
   Serial.begin(9600);
   analogRead(A2); // Sensore di luminosità
   pinMode(13, OUTPUT);
   pinMode(2, INPUT);
}

void setup() {

Serial.begin(9600);

analogRead(A2); // Sensore di luminosità

pinMode(13, OUTPUT);

pinMode(2, INPUT);

}

In ogni caso, per i miei studenti chiedo di ricordare a mente senza aggiungere dichiarazioni inutili, ma se si è all’inizio tale notazione può essere accettata.

Un’altra cosa che noto confonde è l’uso della notazione Ax per i pin digitali e non del valore decimale.
In Arduino.h viene definito ad esempio A2 come una costante di tipo intero. Su Arduino UNO ad A2 è assegnato il valore numerico 16 e poiché è una costante di tipo intero possiamo trattare a tutti gli effetti A2 come se si trattasse del numero 16.

Per completezza ricordo che:

A0 -> 14
A1 -> 15
A2 -> 16
A3 -> 17
A4 -> 18
A5 -> 19

In generale sconsiglio di indicare i pin analogici con il loro valore numerico per due motivi:

la notazione Ax immediatamente mette in evidenza che si tratta di pin analogico,
se utilizziamo su una scheda con più pin I/O, come un Arduino Mega non andremo in confusione e non rischieremo far andare in collisione un pin digitale con un pin analogico nel caso ad esempio che stessimo mettendo mano ad uno sketch funzionante su Arduino Uno e che vogliamo far funzionare sul Mega, infatti su Arduino UNO l’A0 corrisponde al pin 14 della scheda mentre sull’Arduino Mega corrsiponde al pin 54 della scheda, se usiamo la notazione Ax non ci sbagliamo.

Ricordate inoltre che se all’interno del nostro loop() passiamo ad una digitalRead un valore da 0 a 5 non intendiamo segnalare un pin digitale da 0 a 5, ma uno dei pin da A0 ad A5.

Buon lavoro 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi | Contrassegnato analog, arduino, digital, equal, errori, pin, programmazione | Lascia un commento

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

Pubblicato il Gennaio 22, 2019 da admin

Nella guida che segue illustro un schema molto semplice per la realizzazione del controllo di EduRobot effettuata con Arduino. Fornirò passo passo gli sketch di esempio che dovrete migliorare. è può essere considerato la base di partenza per ogni sperimentazione basata appunto su Arduino.
Per il pilotaggio dei motori ho utilizzato e L298N Dual H-Bridge Motor Controller di cui vi ho dato indicazioni nella lezione precedente.

Ovviamente anche la soluzione proposta in questo tutorial potranno essere migliorate da voi, lo scopo è quello di svolgere l’attività di Alternanza Scuola Lavoro di questi giorni, ma nelle settimane che seguiranno potrete migliorare ogni aspetto del robot in quanto il corso su Arduino che state svolgendo nelle mie ore sarà svolto proprio sulla piattaforma EduRobot.

Potrete sostituire alle batterie che io ho utilizzato, batterie ricarrabili, o pacchi batterie con autonomia maggiore che potrete fissare utilizzando gli appositi fori predisposti sullo chassis, durante le lezioni in classe vi fornirò suggerimenti e modalità diverse di utilizzo della scheda L298N.

Nelle parti che seguono costruiamo passo passo il programma che consente la realizzaizone di un robot che si muove in modo autonomo.

Negli esempio che seguono verranno di volta aggiunte nuove funzioni, la lista completa è la seguente:

rotazioneOraria(tempo necessario per effettuare una determinata rotazione, velocità con cui ruota il robot)

Rotazione oraria di EduRobot sul proprio asse

stopEduRobot()

Blocca il movimento del robot

distanzaOstacolo()

restituisce la distanza in cm dell’ostacolo rilevato

paragonaDistanze()

verifica la distanza dell’ostacolo che si trova a distanza maggiore dal robot

scegliDirezione()

sceglie la direzione da prendere in funzione della distanza a cui si trova l’ostacolo

La spiegazione del funzionamento d ogni parte del codice è inclusa all’interno dello sketch come commento.

Nota per lo studio:

i 6 sketch proposti variano solo nel loop per la realizzazione delle funzioni richieste, la variazione tra uno sketch e l’altro consiste nell’aggiunta di poche linee di codice, sarà quindi necessario effettuare uno studio preliminare di tutte le parti dello sketch 1.

Sketch 1

Rotazione di 90° in senso orario del robot sul proprio asse e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 4
  Rotazione di 90° in senso orario del robot sul proprio asse
  e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

  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 velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

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

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

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

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

void loop() {
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 4

Rotazione di 90° in senso orario del robot sul proprio asse

e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

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 velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

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

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

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

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

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

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

void loop() {

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

}

Dalla lezione precedente si sono utilizzati le parti di sketch che permettono la rotazione in senso antiorario ed orario dei motori.

La funzione rotazioneOraria e rotazioneAntioraria, di seguito evidenziate, consentono la rotazione di EduRobot sul proprio asse in una delle due direzioni. Le funzioni accettano due parametri:

tempo: tempo per compiere uno specifico angolo di rotazione
velocita_rotazione: velocità con cui gira il robot

Il tempo per compiere un angolo di 90° deve essere valutato sperimentalmente in quanto funzione della carica della batteria. Per regolare il tempo di rotazione per un angolo di 90° variare il valore della variabile globale: tempo_rotazione_angolo che trovate all’inizio dello sketch.

...
void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

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

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}
...

...

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

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

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

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

...

...
void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

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

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}
...

...

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

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

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

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

...

Per interrompere la rotazione di EduRobot è sufficiente inviare sui pin 9 e 5 di Arduino di tipo PWM il valore 0

...
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}
...

...

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

...

Sketch 2

Rotazione di 180° in senso orario del robot sul proprio asse e ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

Per eseguire questa esercitazione sarà sufficiente aggiungere allo sketch precedente un’ulteriore chiamata alle funzioni rotazioneOraria e rotazioneAntioraria, oppure variare il valore della variabile tempo_rotazione_angolo per un tempo doppio rispetto al tempo necessario per compiere una rotazione di 90°.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 5
  Rotazione di 180° in senso orario del robot sul proprio asse e
  ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

  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 velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

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

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

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

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

void loop() {
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 5

Rotazione di 180° in senso orario del robot sul proprio asse e

ritorno alla posizione di partenza con intervallo di stop di 3 secondi.

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 velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

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

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

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

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

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

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

void loop() {

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

}

Sketch 3

Rotazione di 360° in senso orario del robot sul proprio asse, rotazione di 360° in senso antiorario del robot sul proprio asse con intervallo di stop a 180° di 1 secondo e stop di 3 secondi a 360°.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 6
  Rotazione di 360° in senso orario del robot sul proprio asse, rotazione di 360°
  in senso antiorario del robot sul proprio asse con intervallo di stop a 180°
  di 1 secondo e stop di 3 secondi a 360°.

  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 velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

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

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

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

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

void loop() {

  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);
  
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);

  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);
  
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(3000);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 6

Rotazione di 360° in senso orario del robot sul proprio asse, rotazione di 360°

in senso antiorario del robot sul proprio asse con intervallo di stop a 180°

di 1 secondo e stop di 3 secondi a 360°.

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 velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

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

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

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

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

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

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

void loop() {

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(3000);

}

Facendo eseguire ad EduRobot i medesimi spostamenti, ottimizzare il codice presente nel loop riducendo il numero di istruzioni.

Sketch 4

Ripetere la sequenza: avanti per 500 millisecondi, stop per 3 secondi, rotazione di 180° in senso orario del robot, stop di 1 secondo, avanti per 500 millisecondi, stop di 3 secondi, rotazione di 180° in senso antiorario, stop di 1 secondo, movimento in avanti per 500 millisecondi.

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 7
  Sequenza: avanti per 500 millisecondi, stop per 3 secondi, rotazione di 180° in senso orario del robot,
  stop di 1 secondo, avanti per 500 millisecondi, stop di 3 secondi, rotazione di 180° in senso antiorario,
  stop di 1 secondo, movimento in avanti per 500 millisecondi.

  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 velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse
int velocita_avanti = 150;        // velocità di avanzamento in avanti di EduRobot

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

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

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

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

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

// Movimento in Avanti di EduRobot
void avantiPer(int tempo_avanti)
{
  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_avanti); // Imposta la velocità del motore M1 a velocita_avanti
  analogWrite(velocita_M2, velocita_avanti); // Imposta la velocità del motore M2 a velocita_avanti

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo_avanti);

}

void loop() {

  // avanti per 500 millisecondi, stop per 3 secondi
  avantiPer(500);
  stopEduRobot();
  delay(3000);

  // rotazione di 180° in senso orario del robot, stop di 1 secondo
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);

  // avanti per 500 millisecondi, stop di 3 secondi
  avantiPer(500);
  stopEduRobot();
  delay(3000);

  // rotazione di 180° in senso antiorario, stop di 1 secondo
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);
  stopEduRobot();
  delay(1000);

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 7

Sequenza: avanti per 500 millisecondi, stop per 3 secondi, rotazione di 180° in senso orario del robot,

stop di 1 secondo, avanti per 500 millisecondi, stop di 3 secondi, rotazione di 180° in senso antiorario,

stop di 1 secondo, movimento in avanti per 500 millisecondi.

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 velocita_scelta_dir = 150; // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500; // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.

int velocita_rotazione = 150; // velocità di rotazione di EduRobot sul proprio asse

int velocita_avanti = 150; // velocità di avanzamento in avanti di EduRobot

int attesa = 3000; // tempo di attesa prima che il robot si muova

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);

}

// rotazione oraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

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

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

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, LOW);

digitalWrite(direzione2_M1, HIGH);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo);

}

// rotazione antioraria di EduRobot sul proprio asse

// tempo: tempo per compiere uno specifico angolo di rotazione

// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

// Motore 1 (Sx) - senso orario

// Motore 2 (Dx) - senso antiorario

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

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

// per far girare il motore M1 (Sx) in senso orario

// per far girare il motore M2 (Dx) in senso antiorario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, LOW);

digitalWrite(direzione2_M2, HIGH);

delay(tempo);

}

// ferma i motori

void stopEduRobot() {

// Per fermare il motore impostare a 0 il secondo parametro

analogWrite(velocita_M1, 0);

analogWrite(velocita_M2, 0);

}

// Movimento in Avanti di EduRobot

void avantiPer(int tempo_avanti)

{

// Motore 1 (Sx) avanti - senso antiorario

// Motore 2 (Dx) avanti - senso orario

analogWrite(velocita_M1, velocita_avanti); // Imposta la velocità del motore M1 a velocita_avanti

analogWrite(velocita_M2, velocita_avanti); // Imposta la velocità del motore M2 a velocita_avanti

// per far girare il motore M1 (Sx) in senso antiorario

// per far girare il motore M2 (Dx) in senso orario

digitalWrite(direzione1_M1, HIGH);

digitalWrite(direzione2_M1, LOW);

digitalWrite(direzione1_M2, HIGH);

digitalWrite(direzione2_M2, LOW);

delay(tempo_avanti);

}

void loop() {

// avanti per 500 millisecondi, stop per 3 secondi

avantiPer(500);

stopEduRobot();

delay(3000);

// rotazione di 180° in senso orario del robot, stop di 1 secondo

rotazioneOraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

// avanti per 500 millisecondi, stop di 3 secondi

avantiPer(500);

stopEduRobot();

delay(3000);

// rotazione di 180° in senso antiorario, stop di 1 secondo

rotazioneAntioraria(tempo_rotazione_angolo, velocita_rotazione);

stopEduRobot();

delay(1000);

}

Sketch 5

Realizzare uno sketch che permetta di realizzare in sequenza le tre rotazioni:

45° in senso antiorario del robot
dalla posizione raggiunta rotazione di 90° in senso orario
dalla posizione raggiunta, rotazione di 45° in senso antiorario

Sketch 6

Utilizzando il sensore ad ultrasuoni HC-SR04 per rilevare gli ostacoli ed effettuare la scelta della direzione da intraprendere in funzione dell’ostacolo che si trova a distanza maggiore dal robot.

Funzionamento del sensore HC-SR04

Per l’utilizzo del sensore ad ultrasuoni ne avevo già dato spiegazione in EduRobot UNO – Come costruire il vostro primo Arduino Robot – Lezione 2 ma per permetterne un’agevole studio duplico quanto già scritto nel tutorial in modo che abbiate un punto unico di riferimento.

Per far evitare gli ostacoli al nostro robot utilizzeremo un sensore ad ultrasuoni, in altro modo useremo questo sensore per misurare la distanza dell’ostacolo, ma potremo anche pensare di usare questo sensore, ad esempio, in un sistema anti-intrusione che deve far suonare un allarme. In questa lezione viene utilizzato il sensore HC-SR04, dispositivo economico e con un buon range operativo, ha una sensibilità dichiarata nei datasheet che va da 2 centimetri a 4,5 metri circa, in realtà la massima distanza da esperimenti che ho effettuato arriva a circa 3,5 metri, molto comunque dipende dai materiali colpiti e dalla loro capacità di assorbimento sonoro.

Ma come funziona un sensore di questo tipo?

I sensori ad ultrasuoni non forniscono direttamente la misura della distanza dell’oggetto più vicino, ma misurano il tempo impiegato da un segnale sonoro a raggiungere l’oggetto e ritornare al sensore.

L’impulso ad ultrasuoni inviato all’HC-SR04 è di circa 40KHz il tempo viene misurato in microsecondi, la tensione di funzionamento è di 5V, quindi potremo alimentarlo direttamente utilizzando Arduino.

L’HC-SR04 è dotato di 4 piedini: GND, eco, trigger, +Vcc.

Per convertire l’intervallo di tempo misurato in una lunghezza, bisogna ricordare che la velocità del suono è di 331,5 m/s a 0 °C e di 343,4 m/s a 20 °C ed in generale varia secondo la relazione:

v = 331,4 + 0,62 T

dove la temperatura T è misurata in °C.

Per effettuare una misura di distanza di un ostacolo assumiamo di lavorare ad una temperatura ambiente di 20 °C e quindi la velocità del suono sarà di 343 m/s (approssimiamo) che vuol dire anche 0,0343 cm/microsecondi.

Quindi, ricordando che v=s/t (v: velocità, s: spazio, t: tempo) allora lo spazio percorso sarà:

s = v*t

da cui

s = 0,0343 *t

però, per calcolare lo spazio percorso, bisogna tener conto che il suono percorre due volte la distanza da misurare (giunge sull’oggetto e ritorna indietro al sensore) quindi il valore di t ottenuto deve essere diviso per 2. La formula corretta per la misura dello spazio percorso è:

s = 0,0343 * t/2

eseguendo la divisione di 0,0343/2 possiamo scrivere:

s = 0,01715 * t

oppure:

s = t/58,31

approssimando

s = t/58

formula più semplice da ricordare.

Per calcolare la distanza dell’oggetto dal sensore sarà sufficiente dividere il tempo t (tempo impiegato dal segnale per giungere sull’oggetto e tornare al sensore) per 58.

Per poter effettuare una misurazione viene mantenuto a livello basso il pin Trigger, dopo di che viene fornito un impulso a livello alto della durata minima di 10µs riportandolo poi a livello basso, dopo questo momento la capsula trasmittente emette un burst (sequenza di livelli alti/bassi) a circa 40KHz, l’onda ultrasonica generata (burst) colpisce l’ostacolo, torna indietro venendo rilevata dalla capsula ricevente. L’elettronica del sensore effettua un calcolo del tempo di andata e ritorno del segnale emettendo sul pin Echo, normalmente a livello basso, un segnale a livello alto direttamente proporzionale alla distanza dell’ostacolo:

/*
  Prof. Maffucci Michele
  21.01.19

  EduRobot - Programma test n. 8
  Utilizzando il sensore ad ultrasuoni rilevare gli ostacoli ed effettuare la scelta
  della direzione da intraprendere in funzione dell’ostacolo che si
  trova a distanza maggiore dal robot.

  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 velocita_scelta_dir = 150;    // velocità di rotazione dei motori per la scelta direzione. Valore compreso tra 0 e 255

int tempo_rotazione = 500;        // quantità di tempo di rotazione o di fermo motore

int tempo_rotazione_angolo = 350; // tempo per far ruotare il motore di 90°. Da variare in funzione della carica della batteria.
int velocita_rotazione = 150;     // velocità di rotazione di EduRobot sul proprio asse
int velocita_avanti = 150;        // velocità di avanzamento in avanti di EduRobot

int attesa = 3000; // tempo di attesa prima che il robot si muova

// Impostazione sensore ultrasuoni
const int distanzaPericolo = 20;      // distanza minima dell'ostacolo (in cm)
int distanzaSinistra, distanzaDestra; // distanza sinistra e destra
int misuraDistanza = 0;

long durata;            // durata dell'impulso
long distanza;          // distanza dell'oggetto
int pin_segnale = 7;    // pin Arduino a cui è collegato il sensore SR04
int pin_trig = 6;       // pin Arduino a cui è collegato il sensore SR04

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);

  // impostazione pin per sensore ultrasuoni SR04
  pinMode(pin_trig, OUTPUT);
  pinMode(pin_segnale, INPUT);

  delay(attesa);
}

// rotazione oraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneAntioraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

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

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, LOW);
  digitalWrite(direzione2_M1, HIGH);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo);
}

// rotazione antioraria di EduRobot sul proprio asse
// tempo: tempo per compiere uno specifico angolo di rotazione
// velocita_rotazione: velocità con cui gira il robot

void rotazioneOraria(int tempo, int velocita_rotazione) {

  // Motore 1 (Sx) - senso orario
  // Motore 2 (Dx) - senso antiorario

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

  // per far girare il motore M1 (Sx) in senso orario
  // per far girare il motore M2 (Dx) in senso antiorario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, LOW);
  digitalWrite(direzione2_M2, HIGH);
  delay(tempo);
}

// ferma i motori
void stopEduRobot() {
  // Per fermare il motore impostare a 0 il secondo parametro
  analogWrite(velocita_M1, 0);
  analogWrite(velocita_M2, 0);
}

// Movimento in Avanti di EduRobot
void avantiPer(int tempo_avanti)
{
  // Motore 1 (Sx) avanti - senso antiorario
  // Motore 2 (Dx) avanti - senso orario

  analogWrite(velocita_M1, velocita_avanti); // Imposta la velocità del motore M1 a velocita_avanti
  analogWrite(velocita_M2, velocita_avanti); // Imposta la velocità del motore M2 a velocita_avanti

  // per far girare il motore M1 (Sx) in senso antiorario
  // per far girare il motore M2 (Dx) in senso orario

  digitalWrite(direzione1_M1, HIGH);
  digitalWrite(direzione2_M1, LOW);
  digitalWrite(direzione1_M2, HIGH);
  digitalWrite(direzione2_M2, LOW);
  delay(tempo_avanti);

}

void avantiSempre(int velocita)
{

  // Motore 1 (Sx) - 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);

  // Motore 2 (Dx) - 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);
}

// Indietro senza stop
void indietroSempre(int velocita)
{

  // Motore 1 (Sx) - 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);

  // Motore 2 (Dx) - 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);
}

// restituisce la distanza in cm dell’ostacolo rilevato
long distanzaOstacolo()
{
  digitalWrite(pin_trig, LOW);
  delayMicroseconds(2);
  digitalWrite(pin_trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pin_trig, LOW);
  durata = pulseIn(pin_segnale, HIGH);
  distanza = (durata / 2) / 29.1;
  delay(100);
  return distanza;
}

// verifica la distanza dell’ostacolo che si trova a distanza maggiore dal robot
void paragonaDistanze()
{
  if (distanzaSinistra > distanzaDestra) // vai a sinistra perchè ostacolo a sx più lontano
  {
    rotazioneAntioraria(tempo_rotazione_angolo, velocita_scelta_dir);
    delay(500);
  }
  else if (distanzaDestra < distanzaSinistra) // vai a destra perchè ostacolo a dx più lontano
  {
    rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
    delay(500);
  }
  else // se le distanze degli ostacoli a
  { // sx e dx sono uguali gira di 180 gradi (circa)
    rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
    rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
    delay(1000);
  }
}

// sceglie la direzione da prendere in funzione della distanza a cui si trova l’ostacolo
void scegliDirezione() {
  rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
  distanzaDestra = distanzaOstacolo();   // lettura distanza ostacolo di dx
  delay(500);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_scelta_dir);
  rotazioneAntioraria(tempo_rotazione_angolo, velocita_scelta_dir);
  distanzaSinistra = distanzaOstacolo(); // lettura distanza ostacolo di sx
  delay(500);
  rotazioneOraria(tempo_rotazione_angolo, velocita_scelta_dir);
  delay(100);
  paragonaDistanze();
}

void loop() {
  misuraDistanza = distanzaOstacolo();
  if (misuraDistanza > distanzaPericolo) // vai avanti
  {
    avantiSempre(velocita_avanti);                      // se non ci sono ostacoli vai avanti
  }
  // valutazione dell'ostacolo che si trova a distanza maggiore
  // se l'ostacolo si trova a distanza minore di "distanzaPericolo"
  // bisogna scegliere la direzione
  else
  {
    stopEduRobot();
    scegliDirezione();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

Prof. Maffucci Michele

21.01.19

EduRobot - Programma test n. 8

Utilizzando il sensore ad ultrasuoni rilevare gli ostacoli ed effettuare la scelta

della direzione da intraprendere in funzione dell’ostacolo che si

trova a distanza maggiore dal robot.