• Codice Python sul Raspberry SQLite
• Codice sull’Arduino MKR Zero

Il progetto che ho realizzato riguarda il monitoraggio di temperatura e umidità all’interno di un locale tecnico. I dati rilevati da un sensore DHT22 vengono acquisti da una Arduino MKR Zero e tramite una shield MKR ETH inviati a un computer Raspberry PI 4 che dopo averli acquisiti li memorizza all’interno di una tabella SQLite.

Il protocollo utilizzato per l’invio dei dati si basa su UDP come abbiamo visto in questo articolo.

I dati sarebbero potuti essere memorizzati in un semplice file di testo ma ho preferito usare un database in modo tale da estrarli in modo rapido utilizzando semplici query. Il database contiene per ora una tabella contenente i seguenti campi:

Il codice seguente gira sul Raspberry Pi 4; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

import sqlite3
import socket
import threading
import time

#IP computer locale
UDP_IP_ADDR = "192.168.178.50"
#Porta computer locale
UDP_PORT_NUMBER = 20002

ip_port_Data = (UDP_IP_ADDR, UDP_PORT_NUMBER)
   
def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
    msgToSend = str.encode("DB_OK")
    
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
        
    try:            
        while True:            
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")
         
            sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])
            
            print(sql)
            
            cursor.execute(sql)
            connection.commit()

            #invia al device una risposta
            serversocket1.sendto(msgToSend, ip_port_Data)
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

def crea_tabella():
    #una volta creata la tabella possiamo evitare di chiamare
    #questa funzione ad ogni esecuzione del programma
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
 
    #Se esiste la tabella cancellala
    #cursor.execute("DROP TABLE IF EXISTS tbl_log")
 
    # Crea la tabella se non esiste
    table = """ CREATE TABLE IF NOT EXISTS tbl_log (
            ID INTEGER PRIMARY KEY AUTOINCREMENT,
            Data TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            Temperatura VARCHAR(50) NOT NULL,
            Umidita VARCHAR(50) NOT NULL      
        ); """
 
    cursor.execute(table)
    cursor.close()
    connection.close()

 
def list_rows():
    print("list rows..")
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')

    sql = """ SELECT * FROM tbl_log;"""

    cursor = connection.cursor()
    cursor.execute(sql)
    rows = cursor.fetchall()

    for row in rows:
        print(row)

    # Close the connection
    connection.close()

if __name__=="__main__":
    #Rimuovere il commento per creare la tabella
    #crea_tabella()
    #list_rows()
    #Avvio un thred
    print("Start program")
    t1 = threading.Thread(target=client_Receive_Data)
    t1.start()

Questo è invece il codice che gira sulla Arduino MKR Zero; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <DHT.h>

#define DHTPIN 6
#define DHTTYPE DHT22

// creo un MAC address e un IP address per la scheda Arduino
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 178, 50);

//creo un ip address per il raspberry
IPAddress ip_remote(192, 168, 178, 30);
//creo una porta per la scheda Arduino
unsigned int localPort = 20002; 

//creo degli array di char per la ricezione e l'invio dei
//dati via udp
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
char chrBuffer[11];

//altre variabili 
String strTempUmid = "";
byte ciclo = 0;

// Creo degli oggetti per l'utilizzo di udp e del 
//sensore dht
EthernetUDP Udp;
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  //inizializzo lo shield mkr eth
  Ethernet.init(5);

  //inizializzo la scheda di rete
  Ethernet.begin(mac, ip);

  //inizializzo la seriale
  Serial.begin(9600);
  
  // verifico la ethernet shield
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("MKR ETH non presente o configurata in modo errato!");
    while (true) {
      delay(1);
    }
  }

  //inizializzo l'oggetto udp
  Udp.begin(localPort);
  //inizializzo l'oggetto dht
  dht.begin();
}

void loop() {

  //verifico presenza pacchetti udp in arrivo
  int packetSize = Udp.parsePacket();
  
  //se coi sono pacchetti
  if (packetSize) {
    //Serial.println(packetSize);
    //leggo i pacchetti e gli inserisco nell'array di char
    Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
    //printo i dati ricevuti
    Serial.println(packetBuffer);
  }

  //leggo umidità e temperatura dal sensore dht
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  //creo una stringa del tipo temp:umid
  strTempUmid = "";
  strTempUmid.concat(t);
  strTempUmid.concat(":");
  strTempUmid.concat(h);
  //printo la stringa sul ser mon
  Serial.println(strTempUmid);
  //converto la stringa in un array di char
  strTempUmid.toCharArray(chrBuffer, strTempUmid.length());

  //inizializzo la connessione con ip e porta del Raspberry
  Udp.beginPacket(ip_remote, 20001);
  //Scrivo i dati nel buffer
  Udp.write(chrBuffer);
  //invio i dati
  Udp.endPacket();

  //attendo un minuto prima del prossimo invio
  for (ciclo = 0; ciclo < 60; ciclo++)
    delay(1000);

}

Ogni minuto viene inviata una unica stringa contenente i dati di temperatura e umidita che il codice python provvederà a separate in due dati distinti per essere caricati sul database.

Memorizzare solo le variazioni significative su Raspberry SQLite

Possiamo ottimizzare lo spazio sulla tabella (e di conseguenza sul filesystem del Raspberry) memorizzando solo i dati che hanno una variazione significativa. In questo modo il monitoraggio rimane costante perché comunque l’Arduino legge e invia i dati ogni minuto ma posso risparmiare spazio sul database salvando solo le variazioni significative. Sulla tabella memorizzo anche il timestamp e quindi posso ricostruire l’andamento di temperatura e umidità interpolando i dati.

Il codice seguente mostra la modifica alla funzione client_Receive_Data() in modo tale da memorizzare solo i dati che hanno una variazione di 0.5 rispetto ai dati della lettura precedente rilevata dalla scheda Arduino:

def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
        
    # crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
    #creo due variabili per memorizzare i dati delle 
    #letture di temp e umid
    temp_prec = 0
    umid_prec = 0
    
    try:
        while True:
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")

            #verifico se i dati appena letti differiscono di 0.5 dai valori della lettuare precedente
            if (abs(temp_prec - float(strData[0])) > 0.5) or (abs(umid_prec - float(strData[1])) > 0.5) :
                print("Variazione di Temp e Hum")  
                sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])

                #memorizzo i dati per poterli confrontare con quelli
                #che arrivano dalla scheda arduino
                temp_prec = float(strData[0])
                umid_prec = float(strData[1])
                #visualizzo la stringa sql
                print(sql)
                #eseguo la stringa sql insert avviando una transazione
                cursor.execute(sql)
                #confermo la transazione
                connection.commit()
                
                # invia al device una risposta
                msgToSend = str.encode("DB_OK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            else:
                print("Nessuna variazione di Temp e Hum")  
                # invia al device una risposta
                msgToSend = str.encode("DB_NOK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

L’utilizzo congiunto di Raspberry e Arduino ci permette di realizzare progetti che superano i limiti dati dalle singole schede.

The post Datalogger con Raspberry SQLite e Arduino appeared first on Esperimenti con logiche programmabili.

Se hai intenzione di imparare a programmare Arduino e non hai tante nozioni di elettronica puoi acquistare l’Arduino Sensor Kit.

Questo kit permette i dedicarsi totalmente alla stesura del codice senza preoccuparsi di conoscere il modo corretto per collegare i componenti e i sensori alla Arduino UNO.

Un vantaggio enorme che permette di abbassare la curva di apprendimento.

Molte persone hanno il desiderio di programmare una scheda Arduino, ma dopo aver comprato l’hardware necessario, iniziano ben presto a trovare difficoltà nella realizzazione dei collegamenti, per poi finire di abbandonare tutto nel cassetto della propria scrivania.

Con l’Arduino Sensor Kit invece, devi dedicarti solamente ad acquisire esperienza nella programmazione e questo permette di avere delle piccole soddisfazioni che non fanno spegnere la voglia di imparare a utilizzare una scheda Arduino.

Il kit sviluppato in collaborazione con Seed Studio viene venduto in versione base al costo di circa 28€ e in versione bundle con una  scheda Arduino UNO per una spesa di poco inferiore ai 50€. 

La Sensor Kit è compatibile con i sistema Grove ideato da Seed Studio, rendendola quindi espandibile con centinaia di moduli pre-assemblati pronti all’uso dandoti così la possibilità di provare ad utilizzare nuovi sensori o attuatori.

Per semplificare ulteriormente l’uso è stata sviluppata una libreria che con poche righe di codice puoi scrivere subito i primi programmi e se ancora non bastasse puoi trovare tutte le risorse sul sito dedicato (Sensor Kit arduino.cc) con tutti gli esempi di codice da utilizzare immediatamente!

Buon divertimento e buon codice!!

The post Il miglior modo per iniziare a programmare Arduino appeared first on Esperimenti con logiche programmabili.

E’ da diverso tempo che uso un Raspberry Pi come computer per navigare su internet e per imparare a programmare in Python. Con poche decine di euro è possibile creare il proprio desktop replacement.

Anche se le prestazioni non sono entusiasmanti possiamo utilizzare questa scheda come piccolo laboratorio di sviluppo. Nonostante la presenza di diverse linee gpio potremmo avere comunque l’esigenza di continuare ad utilizzare le schede Arduino, quindi perchè non utilizzare il Raspberry Pi per programmarle?

Installare l’Arduino IDE

La prima cosa da effettuare è quella di scaricare dal sito ufficiale Arduino il software dell’ide per piattaforma linux arm. Una volta ottenuto il pacchetto in formato compresso dobbiamo scompattarlo eseguendo il commando seguente

tar Jxvf arduino-1.8.8-linuxarm.tar.xz

Verrà creata automaticamente la cartella arduino-1.8.8 nella stessa directory dove abbiamo salvato il file arduino-1.8.8-linuxarm.tar.xz

[the_ad id=”6199″]

Ora dentro la cartella arduino-1.8.8 ci sarà il file di installazione install.sh. per eseguirlo dovremmo digitare quanto segue:

./arduino-linux-setup.sh pi

Attendiamo qualche istante finché il pacchetto software non viene installato correttamente sul nostro Raspberry Pi.

Ultimata l’installazione viene richiesto il riavvio del sistema operativo.

Durante l’installazione viene creata una voce di menu come potete osservare dalla figura seguente.

Collaudo

Ora che tutto è stato installato possiamo esegure subito una prova per  verificare se le nostre schede Arduino possano essere programmata attraverso il Raspberry pi.

Colleghiamo alla porta usb del Raspberry Pi una Arduino UNO. Avviamo ora l’Arduino IDE.
Se tutto funziona correttamente nella voce di menu Strumenti->Porta dovremmo osservare la presenza della scheda Arduino UNO e della relativa porta di comunicazione, come nella figura seguente:

Dal menu file->esempi->01 Basics carichiamo il classico sckecth Blink, ora dal menu Sketch clicchiamo sulla voce Carica. Se tutto è andato a buon fine lo sketch verrà caricato correttamente sulla scheda UNO.

The post Installare Arduino sul Raspberry PI appeared first on Esperimenti con logiche programmabili.

La famiglia di schede Arduino è composta da vari formati. A seconda del tipo di progetto che stiamo realizzando potremo scegliere un dispositivo che ci permetta di ottimizzare gli spazi. Una scheda che reputo molto utile è l’Arduino Mini, giunto alla quinta revisione, poiché le sue dimensioni sono davvero contenute (3 cm x 1.8 cm) ed il suo costo è attualmente di 15€ (sullo store ufficiale).

Essendo cosi compatto per poterlo programmare abbiamo bisogno di un convertitore usb seriale esterno, infatti non è disponibile sulla scheda un convertitore integrato.
Per questo tutorial ho utilizzato il convertitore ufficiale Arduino USB2Serial Light ed un convertitore DFrobot basato sul chip FTDI FT232RL.

Questo lo schema usando l’USB2Serial:

Il circuito è molto banale ma bisogna assicurarsi di inserire il condensatore C da 100nF per poter resettare il Mini e caricare il nuovo sketch.
Da notare anche che il TX del convertitore è collegato all’RX del Mini mentre l’RX del convertitore è collegato all’TX del Mini.

Lo schema elettrico utilizzando il convertitore della DFrobot è identico, tranne che nella serigrafia del convertitore non è presente la dicitura reset ma DTR:

La compilazione dello sketch e del caricamento sul Mini è identica ad un Arduino UNO, bisogna selezionare dall’IDE la board corretta (Arduino MINI /w ATmega328) e la porta COM dove è collegato il convertitore.

The post Come programmare l’Arduino Mini 05 appeared first on Esperimenti con logiche programmabili.

Ho acquistato di recente la nuova scheda Arduino Leonardo basata sul chip Atmel Mega32U4. Questo microcontrollore possiede un modulo usb integrato che sostituisce il modulo di conversione usb-ttl presente nella Arduino UNO, rendendo la scheda molto ‘snella’ visto l’esiguo numero di componenti che ospita.

La prima prova che voglio effettuare è il classico speed test che ho realizzato anche per le altre schede. Questa verifica consiste nel commutare un pin digitale in modo ripetitivo, utilizzando solamente le istruzioni che permettono di porre il pin digitale a livello alto e a livello basso e, avvalendomi di un oscilloscopio ,misurare la frequenza di commutazione.

Lo sketch caricato sulla Leonardo è il seguente:

void setup()
{
  //pin0 in uscita
  pinMode(0, OUTPUT);
}

void loop()
{
  //ciclo infinito
  while(true)
  {
    //metto il pin0 alto
    digitalWrite(0, HIGH);
    //metto il pin0 basso
    digitalWrite(0, LOW);
  }
}

mentre lo schema elettrico del test è il seguente

la frequenza misurata risulta pari a 106 Khz leggermente inferiore a quella ottenuta con la Arduino UNO(125Khz). Ho realizzato una semplice tabella riepilogativa con le varie frequenze delle diverse schede che ho sottoposto al test.

The post Arduino Leonardo speed test appeared first on Esperimenti con logiche programmabili.

DiScienza sta organizzando a Roma per il 20 Aprile l’edizione 2012 dell’Arduino Day, una giornata dedicata alla community Arduino. L’evento darà spazio alle presentazioni delle ultime novità riguardanti Arduino ed ospiterà, grazie ad un capiente open spaces, i migliori progetti di professionisti e appassionati.

La giornata sarà caratterizzata da una serie di Mini conferenze di circa 15 minuti nelle quali verranno presentati progetti basati su Arduino.

Ulteriori informazioni e il modulo di registrazione per partecipare all’evento disponibili su http://www.discienza.org/arduinoday

The post Arduino day 2012 una giornata con Arduino appeared first on Esperimenti con logiche programmabili.

Se anche tu hai difficoltà a ricordare le date degli appuntamenti e sei un tipo creativo e non ti accontenti dei classici promemoria via cellulare, tablet o computer, ma vuoi realizzare qualcosa di insolito, puoi sfruttare la tua passione per l’elettronica e la tua voglia di costruire per realizzare questo progetto di promemoria con Arduino.

Avendo già le basi per poter lavorare con l’integrato RTC DS1307 puoi sfruttare la ram non volatile di questo chip per memorizzare circa 18 date e permettere, ad Arduino, di avvisarti tramite display, led rgb, twitter o quello che ti viene in mente!!

L’idea è quella di utilizzare l’RTC per memorizzare il dato di tempo e sfruttare i 56 byte di flash ram aggiuntive per memorizzare le date degli avvenimenti. Arduino ha il compito di comparare le date e di agire di conseguenza pilotando le uscite digitali.

Parto dal presupposto che la data e l’ora del RTC sia già stata impostata come spiegato nel precedente tutorial.
Per memorizzare le date degli avvenimenti possiamo usare un array di 3 byte (Giorno Mese ed Anno), il codice è il seguente:

[c]
//inserisco la libreria per il bus I2C
#include <Wire.h>

//Variabile per memorizzare l’indirizzo della ram del DS1307
byte IndRam = 0x00;
//array per la data (G M A)
byte Data[3];

void setup()
{
//init bus I2C
Wire.begin();
//init seriale
Serial.begin(9600);

//imposto l’indirizzo iniziale della user ram
IndRam = 0x08;

//avvio la comunicazione con il DS1307
//indirizzo 0x68
Wire.beginTransmission(0x68);
//specifico l’indirizzo a cui voglio accedere
Wire.write(IndRam);

//imposto la data 25/04/12 in esadecimale
Data[0] = 0x19; //giorno 25
Data[1] = 0x04; //mese   04
Data[2] = 0x0C;  //anno   12

//scrivo i 3 byte negli indirizzi 0x08 0x09 0x0A
Wire.write(Data,3);

//chiudo la comunicazione
Wire.endTransmission();

}

void loop()
{}

[/c]

Nel datasheet del DS1307 la ram aggiuntiva inizia all’indirizzo 0x08 e finisce all’indirizzo 0x3F e, sapendo che per memorizzare una data servono 3 byte (G M A), devi sommare alla variabile IndRam valori multipli di 3.
Ad esempio per memorizzare la seconda data IndRam varrà 0x08 + 3 per la terza data 0x08+6 e cosi via fino a 0x08+51, ottenendo così 18 date memorizzabili.

Una volta memorizzate le date che ci interessano, è necessario scrivere del codice che confronti questi valori con quelli dell’RTC e di conseguenza eseguire delle operazioni di output.

Per primo recupero il giorno, mese e anno dell’RTC a partire dall’indirizzo  0x04

e poi recupero i dati della user ram per eseguire il confronto quindi:

[c]

void loop()
{
IndRam = 0x04;

//setto l’indirizzo da ddove iniziare
//a leggere
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero 3 byte G M A
Wire.requestFrom(0x68, 3);
byte Giorno = Wire.read();
byte Mese = Wire.read();
byte Anno = Wire.read();

Serial.print(Giorno, DEC);
Serial.print("/");
Serial.print(Mese,DEC);
Serial.print("/");
Serial.println(Anno, DEC);

//recupero tutte le date memorizzate nella user ram
//e le confronto con quella attuale dell’RTC

for( byte Ciclo = 0; Ciclo < 54; Ciclo += 3)
{
IndRam = 0x08 + Ciclo;
//Serial.println(IndRam, HEX);

Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

Wire.requestFrom(0x68, 3);
byte memGiorno = Wire.read();
byte memMese = Wire.read();
byte memAnno = Wire.read();

//confronta i dati

if(Giorno == memGiorno && Mese == memMese && Anno == memAnno)
{
//trovata data
//fai qualcosa
Serial.println("Data OK");
}

delay(10);
}

delay(1000);
}
[/c]

Il codice controlla ciclicamente se la data impostata nell’RTC è presente nella user ram in caso affermativo viene printata la stringa Data OK.
Il codice ha un problema, non tiene conto dell’andamento temporale, infatti viene fatto un controllo di valori che non permette di verificare se una data è precedente o successiva a quella impostata.
Il compito del codice dovrebbe essere quello di avvisarci degli avvenimenti futuri mentre dovrebbe escludere quelli passati.

Per poter confrontare le date tra di loro mi sono avvalso della libreria Time che tra le varie funzioni permette di restituire il numero di secondi trascorsi tra il 1 gennaio 1970 e una data definita.
Ottenendo un numero progressivo posso confrontare due date e capirne l’ordine temporale.

Installare e utilizzare la libreria Time

Sul sito ufficiale di Arduino, seguendo questo link possiamo scaricare la libreria. Scompattiamo il file zip nella cartella Arduino 1.0->libraries. Questa operazione produrrà tre cartelle una con nome Time, DS1307RTC e TimeAlarms. Riavviamo l’IDE per aggiornare le lista delle librerie e degli esempi.

Per utilizzare la libreria nello sketch del progetto che stiamo sviluppando, possiamo inserire a mano la clausola

[c]#include <Time.h>[/c]

oppure dal menu dell’ide eseguiamo Sketch->Import Library->Time

Per ottenere i secondi trascorsi dal 1 gennaio 1970 è disponibile la funzione now(), ma prima, giustamente bisogna settare la data di riferimento, per farlo si utilizza la funzione setTime(ora, minuti, secondi, giorno, mese, anno) quindi il codice precedente viene modificato così:

[c]
#include <Wire.h>
//includo la libreria Time
#include <Time.h>

byte IndRam = 0x00;
byte Data[3];

byte val = 0x00;

//queste variabili servono per memorizzare
//la data in secondi trascorsi dal 1 gen 1970
unsigned long UnixData = 0;
unsigned long memUnixData = 0;

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

//imposto l’indirizzo iniziale della user ram
IndRam = 0x08;

//carico una data da ricordare nei primi
//3 byte della user ram
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Data[0] = 0x05; //giorno 05
Data[1] = 0x04; //mese 04
Data[2] = 0x0C; //anno 12
Wire.write(Data,3);
Wire.endTransmission();

delay(100);

//verifico la data appena impostata
//nella user ram
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

Wire.requestFrom(0x68, 3);
byte data = Wire.read();
Serial.print(data);
Serial.print("/");
data = Wire.read();
Serial.print(data);
Serial.print("/");
data = Wire.read();
Serial.print(data);
Serial.println("/");

delay(100);
}

void loop()
{
//setto l’indirizzo per accedere alla data
//impostata nell’RTC
IndRam = 0x04;
//setto l’indirizzo da dove iniziare
//a leggere
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero 3 byte G M A
Wire.requestFrom(0x68, 3);
byte Giorno = Wire.read();
byte Mese = Wire.read();
byte Anno = Wire.read();

//visualizzo la data dell’RTC
Serial.print(Giorno, DEC);
Serial.print("/");
Serial.print(Mese,DEC);
Serial.print("/");
Serial.println(Anno, DEC);

//setto la libreria Time con la data dell’RTC
setTime(0,0,0, Giorno, Mese, (Anno + 2000));
//Recupero i secondi trascorsi tra la data 1 Gen 1970
//e la data dell’RTC
UnixData = now();
//Visualizzo i secondi trascorsi sul Serial Monitor
Serial.println(now());

//recupero tutte le date memorizzate nella ram
//e le confronto con quella attuale dell’RTC
//trasformandole in secondi in modo da poter confrontare
//le date

for( byte Ciclo = 0; Ciclo < 54; Ciclo += 3)
{
//imposto il primo indirizzo della user ram
//e poi proseguo ciclicamente incrementando di
//3 posizioni
IndRam = 0x08 + Ciclo;
//Serial.println(IndRam, HEX);

//setto l’indirizzo
Wire.beginTransmission(0x68);
Wire.write(IndRam);
Wire.endTransmission();

//recupero i tre byte G M A
//dalla user RAM
Wire.requestFrom(0x68, 3);
byte memGiorno = Wire.read();
byte memMese = Wire.read();
byte memAnno = Wire.read();

//imposto la libreria Time con la data dela user RAM
// per convertirla in secondi
setTime(0,0,0, memGiorno, memMese, (memAnno + 2000));
memUnixData = now();
//Serial.println(now());

//confronto la data in secondi dell’RTC con la data
//appena recuperata dalla user ram

if(UnixData == memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}

delay(10);
}

delay(1000);
}
[/c]

Il codice ha lo stesso comportamento di quello iniziale ma adesso c’è la possibilità di eseguire il confronto numerico grazie alla conversione in secondi. Ad esempio per escludere tutte le date passate possiamo fare questa semplice modifica

[c]

//escludi le date passate

if(UnixData >= memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}

[/c]

oppure eseguire del codice per avvisarci una settimana in anticipo:

[c] //avvisami una settimana prima
//settimana in secondi 60*60*24*7 = 604800

if((memUnixData – UnixData) <= 604800)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}
[/c]

Avendo il modo di eseguire un confronto numerico tra le date ci offre la possibilità di realizzare ulteriori funzioni, come ad esempio sketch che gestiscono l’Arduino a seconda delle date impostate nella user ram.

Per le operazioni da eseguire quando viene trovata una data possiamo eseguire tutte le tipiche funzioni di output che può gestire Arduino.

[c]
//escludi le date passate
if(UnixData >= memUnixData)
{
//trovata data
//fai qualcosa
Serial.println("TROVATA!!!");
}
[/c]

The post Promemoria alternativo con Arduino e RTC appeared first on Esperimenti con logiche programmabili.

Oltre alle funzioni viste nel precedente articolo, Arduino è capace di eseguirne altre ed in particolare lo spostamento a destra o a sinistra bit a bit. L’operatore per lo spostamento a destra si esprime con questo operatore >> mentre per lo spostamento a sinistra viene usato questo operatore <<.
Per capire meglio cosa avviene utilizziamo delle immagini che semplificano la spiegazione. In questo caso ho una variabile di tipo byte (8 bit) il cui valore è 255. All’interno del chip atmega328 viene allocata, nella memoria ram, uno spazio di 8 bit i cui valori sono settati a 1

Eseguendo uno spostamento a sinistra <<, tutti i bit si spostano di una posizione verso sinistra e nel bit meno significativo (LSB) viene scritto uno zero:

Quindi il valore della variabile passa da 255 (in binario 11111111) a 254 (in binario 11111110).

Continuando ad eseguire uno spostamento a sinistra, di una posizione, otteniamo i seguenti valori

Il codice che esegue quanto detto è il seguente

[c]
//Variabile di tipo byte
byte MiaVar;

void setup()
{
//init seriale
Serial.begin(9600);
//init variabile 11111111
MiaVar= 255;
}

void loop()
{
//eseguo uno spostamento a sinistra di 1 posizione
//memorizzo il valore nella stessa variabile
MiaVar = MiaVar << 1;

//invio il dato al serial monitor
Serial.println(MiaVar);

//1 secondo di pausa tra una operazione e l’altra
delay (1000);

}

[/c]

Allo stesso modo lo spostamento a destra >> esegue un movimento dei bit dal più significativo al meno significativo:

in questo modo otteniamo i seguenti valori:

Gli operatori >> e << possono spostare i bit anche di diverse posizioni a seconda di come gestiamo l’operatore, ad esempio se voglio spostare i bit di quattro posizioni a sinistra dovrò scrivere:

[c]
MiaVar = MiaVar << 4;
[/c]

in questo modo la variabile MiaVar passerà dal valore 255 al 240.

Generalmente le operazioni bit a bit vengono usate perché sono eseguite molto velocemente da Arduino. Possono anche essere usate per semplici calcoli matematici, ad esempio moltiplicare o dividere un numero, come di seguito:

[c]
//Moltiplica * 2
Risultato = Miavar << 1;
//Moltiplica * 4
Risultato = Miavar << 2;
//Moltiplica * 8
Risultato = Miavar << 3;
//divide / 2
 Risultato = Miavar >> 1;
 //divide / 4
 Risultato = Miavar >> 2;
 //divide / 8
 Risultato = Miavar >> 3;
[/c]

Questo metodo non è molto intuitivo ma quando ci troviamo ad ottimizzare il nostro codice per essere eseguito nel minor tempo possibile, lavorare con i bit è sempre una risorsa.

The post Operatori per spostare i bit (bitwise) appeared first on Esperimenti con logiche programmabili.

Nonostante la semplicità di installazione dell’IDE e della board Arduino, capita che molti neofiti non riescano ad eseguire l’installazione Arduino su Windows 7. In effetti con questo sistema operativo l’installazione dei driver è automatica ma ci sono dei casi in cui non si riesce ad installare i driver, soprattutto per le schede che montano l’integrato Mega8U per convertire il segnale da usb a seriale.

La procedura seguente mostra, passo passo, come installare una Arduino Ethernet collegata con la scheda USB2Serial Light.

Il primo passo è scaricare la versione 1.0 del software Arduino IDE, che contiene sia i driver sia la il software necessario per lo sviluppo. Dopo la decompressione posizioniamo questa cartella in modo che sia facilmente accessibile. Nel mio caso l’ho decompressa nella cartella di sistema Documenti.

Colleghiamo il cavo Usb della board USB2Serial Light al pc, Windows 7 avvia automaticamente la ricerca nuovo hardware

cliccando su l’icona contrassegnata, apriamo la finestra Installazione Driver, dove osserviamo che Windows tenta il download dei driver da Windows Update.

Annulliamo questa procedura cliccando sul link “Ignora download di driver da Windows Update” e confermando cliccando sul pulsante “Si”

Attendiamo qualche minuto fino a quando viene visualizzato il messaggio di errore seguente

Adesso andiamo sull’icona Computer e apriamo il menu contestuale cliccando con il pulsante destro del mouse. Selezioniamo la voce Proprietà

Dalla finestra appena visualizzata clicchiamo sulla voce Gestione Dispositivi:

Nella finestra Gestione Dispositivi vengono elencate tutte le periferiche del computer tra le quali appare la voce Arduino-Serial anteceduta dalla classica icona gialla con il punto esclamativo

Selezioniamo questa voce e cliccando con il pulsante destro del mouse selezioniamo, dal menu contestuale, la voce “Aggiornamento Software Driver…”

Viene avviata una semplice procedura guidata che porta all’installazione dei driver, selezioniamo la voce “Cerca il software del driver nel computer”

Nella finestra successiva, potete tentare di far cercare a Windows i driver contenuti nella cartella Arduino, ma e nel caso non viene trovato nessun driver dovete eseguire la procedura manuale come in questo caso, cliccando sulla voce “Scegli manualmente da un elenco di driver di dispositivo nel computer“:

la finestra successiva permette di scegliere il tipo di periferica da installare, cerchiamo la voce “Porte (COM e LPT)”

Cerchiamo un driver cliccando sul pulsante “Disco Driver”

Cerchiamo nel computer, e precisamente all’interno della cartella contente i driver e l’ambiente di sviluppo che precedentemente era stata scaricata dal sito Arduino.cc, il file Arduino UNO.inf (tipicamente presente nella sottodirectory Drivers del software Arduino 1.0).
Una volta selezionato clicchiamo sul pulsante Apri

Selezioniamo nel riquadro Produttore la voce Arduino LLC e nel riquadro modello la voce Arduino UNO R3, ignoriamo l’avviso che ci ricorda che il driver non possiede una firma digitale, e clicchiamo sul pulsante Avanti. Viene avviata l’installazione dei driver

una volta terminata l’installazione la procedura si conclude con una finestra che informa l’avvenuta installazione dei driver

Ritornando nella finestra “Gestione dispositivi” osserviamo che Arduino è stato riconosciuto ed installato corretamente.

L’installazione dei driver in modo manuale permette di risolvere quei casi in cui Windows 7 non riesce ad installare Arduino in modo autonomo.

[facebook_ilike]

The post Tutorial installazione Arduino su Windows 7 appeared first on Esperimenti con logiche programmabili.

Nei nostri sketch, quando utilizziamo variabili numeriche, impieghiamo, solitamente, degli operatori matematici per manipolare questi dati. I più semplici, come sappiamo bene, sono l’addizione, la sottrazione, la moltiplicazione e la divisione. Fortunatamente esistono anche altri metodi che ci permettono di velocizzare e di risolvere diverse situazioni che si presentano durante la scrittura degli sketch.

In questo articolo volevo analizzare alcune funzioni particolari come constrain, min, max, floor e ceil

Come limitare un valore entro un limite minimo e massimo

Quando si ha la necessità di ottenere sempre dei valori compresi in un intervallo definito, possiamo usare la funzione constrain(value, min, max). Il codice seguente mostra come impiegarla

[c]
int Var = 10;
int Result = 0;

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

void loop()
{
//il valore Result sarà uguale a 50
Var = 50;
Result = constrain(Var, 10, 100);
Serial.println(Result);

//il valore Result sarà uguale a 10
Var = 5;
Result = constrain(Var, 10, 100);
Serial.println(Result);

//il valore Result sarà uguale a 100
Var = 500;
Result = constrain(Var, 10, 100);
Serial.println(Result);

//non fa nulla
while(true)
;

}

[/c]

Se la variabile Valore è minore di 10 il risultato sarà 10 se il valore è maggiore di 90 il risultato sarà 90, negli altri casi il risultato sarà uguale alla variabile Valore.

Come trovare il minimo ed il massimo tra due numeri

la funzione per calcolare il valore minimo tra due numeri è min(val1, val2); e viene impiegata in questo modo

[c]

int Var1 = 10;
int Var2 = 50;
int Result = 0;

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

void loop()
{
//il valore Result sarà uguale a 10
Result = min(Var1, Var2);
Serial.print(Result);

//non fa nulla
while(true)
;

}
[/c]

mentre la funzione per calcolare il valore massimo tra due numeri è max(val1, val2); e viene utilizzata in questo modo

[c]

int Var1 = 10;
int Var2 = 50;
int Result = 0;

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

void loop()
{
//il valore Result sarà uguale a 50
Result = max(Var1, Var2);
Serial.print(Result);

//non fa nulla
while(true)
;

}

[/c]

Come arrotondare un numero per difetto o per eccesso

Le funzioni floor(val) e ceil(val) permettono di arrotondare rispettivamente per difetto e per eccesso un numero in virgola mobile. L’esempio seguente mostra come utilizzarle

[c]

float Var = 10.6598;
int Result = 0;

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

void loop()
{
//arrotonda per difetto
Result = floor(Var);
Serial.println(Result);

//arrotonda per accesso
Result = ceil(Var);
Serial.println(Result);

//non fa nulla
while(true)
;

}

[/c]

Come rimappare un intervallo di valori con un altro

Quando si rende necessario scalare un intervallo di valori con un altro ci viene incontro la funzione map. Ad esempio i valori che possiamo ottenere dalla lettura di un segnale applicato ad un pin analogico di Arduino sono compresi tra 0 e 1023, se volessimo ottenere un intervallo diverso ma equivalente potremmo utilizzare la funzione map(data,x1,y1,x2,y2); in questo modo:

[c]

int DataAN0 = 0;
int ValEqu = 0;

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

void loop()
{
//leggo dal pin analogico zero
DataAN0 = analogRead(0);

//i valoridi Result possono andare da 0 a 1024
//voglio rimappare questi valori per
//ottenere un intervallo equivalente che va
//da 0 a 255
ValEqu = map(DataAN0, 0, 1023, 0, 255);

Serial.print("Valore Originale ");
Serial.println(DataAN0);
Serial.print("Valore rimmapato ");
Serial.println(ValEqu);
Serial.println();
delay(1000);

}
[/c]

Ulteriori informazioni sono presenti nel sito ufficiale Arduino.cc, dove vengono illustrate ulteriori funzioni interessanti.

[facebook_ilike]

The post Arduino funzioni matematiche interessanti appeared first on Esperimenti con logiche programmabili.