Arduino MKR1000

Arduino 

Arduino è una piattaforma hardware composta da una serie di schede elettroniche dotate di un microcontrollore.
Tramite l’utilizzo di Arduino si possono realizzare in maniera relativamente semplice alcuni progetti come robot, controllori di parametri (Arduino integrato con sensori e/o attuatori come nel nostro caso) e altri progetti. È abbinato ad un semplice ambiente di sviluppo integrato per la programmazione del microcontrollore.

Tutto il software a corredo è libero, e gli schemi circuitali sono distribuiti come hardware libero,infatti Arduino è open source,ovvero tutti i programmi per realizzare diversi progetti sono facilmente reperibili o direttamente sul sito di Arduino o comunque sulla rete.

La piattaforma fisica si basa su un circuito stampato che integra un microcontrollore con dei pin connessi alle porte I/O, un regolatore di tensione e un’interfaccia USB che permette la comunicazione con il computer utilizzato per programmare e l’alimentazione di Arduino. A questo hardware viene affiancato un ambiente di sviluppo integrato (IDE) che serve per programmare Arduino per la funzione che andrà a svolgere. I programmi in Arduino vengono chiamati sketch.

Grazie alla base software comune ideata dai creatori del progetto, per la comunità Arduino è stato possibile sviluppare programmi per connettere, a questo hardware, più o meno qualsiasi oggetto elettronico, computer, sensori, display o attuatori. Dopo anni di sperimentazione, è oggi possibile fruire di un database di informazioni vastissimo.

 

Arduino MKR100

Arduino MKR1000  è stata progettata per dare una soluzione pratica per tutti gli utenti che vogliono aggiungere connettività Wifi ai loro progetti. Questa scheda è basata sul modulo ATSMAW25, creata apposta per progetti e periferiche IoT.

La scheda include un circuito di carica per batterie Li-Po, che permette all’Arduino MKR1000 di funzionare a batteria o con una fonte di alimentazione esterna a 5 Volt, il passaggio da una sorgente all’altra è gestito automaticamente. La scheda è composta da un processore a 32 bit simile alla Zero, una grande quantità di I/O, un Wifi a bassa potenza insieme ad un chip di criptazione.

A differenza della maggior parte delle schede, la MKR1000 funziona a 3.3 Volt. Il valore massimo che i pin di I/O possono supportare sono 3.3 Volt. Sorgenti collegate ai pin di I/O che erogano più di 3.3 Volt possono danneggiare la scheda.

Programma gestione MyLegalPlants con WebApp

Questo sketch invia in GET a mylegalplants.it attraverso file php il valore di T, H e L letto da Arduino per memorizzarlo su DB, e attiva o meno l’Irrigazione, il Riscaldamento e/o l’Illuminazione settati da WebApp.
Gestisce anche il controllo del sistema attraverso Bots di Telegram, sia per leggere il valore dei sensori che per l’attivazione di Irrigazione, Riscaldamento e/o Illuminazione.

—————————–
Gli “include” di seguito sono le librerie necessarie che vengono inserite nel programma per far si che la scheda Wi-fi installata
nell’Arduino MKR1000 riesca a connettersi al Wi-fi (#include #include ),che possa utilizzare i bot di telegram (#include ) e che un numero con virgola possa essere trasformato in una stringa (#include “floatToString.h”).


#include<WiFiSSLClient.h>
#include <WiFi101.h>
#include <SPI.h>
#include <TelegramBot.h>
#include "floatToString.h"

Nel setup apriamo lo schermo seriale e impostiamo come uscita i tre pin degli attuatori che corrispondono alla temperatura,umidità e luminosità.


void setup() {
Serial.begin(9600);
while (!Serial) {} 
delay(3000);

NetworkConnection();
printWifiStatus();
bot.begin();

pinMode(pinAttuatore_T, OUTPUT);
pinMode(pinAttuatore_H, OUTPUT);
pinMode(pinAttuatore_L, OUTPUT);
}

Questo pezzo di codice mette nelle tre variabili float i rispettivi valori acquisiti dalla lettura analogica sul pin impostata precedentemente; una volta avuti i valori nelle variabili,questi vengono convertiti nei range di valori voluti,mettendoli in una stringa.


void loop() {
float acq_T = analogRead(A1); // T
t_value = (acq_T/1023)*330; // converto il valore di acq_T (0-1023) in °C sapendo che Vref=3,3v -> 330°C
floatToString(t_char, t_value, 2);
t_string = t_char;
float acq_H = analogRead(A2); // H
h_value = (acq_H/1023)*180; // converto il valore di acq_H (0-1023) in %H sapendo che in H2o acq_h=180 -> 100%H
floatToString(h_char, h_value, 2);
h_string = h_char;ppo; // L
l_value = (acq_L/1023)*6500; //nverto il valore di acq_L (0-1023) in LUX sapendo che acq_l=740 -> 4700 lux
floatToString(l_char, l_value, 2);
l_string = l_char;

Una volta ricevuta la richiesta di accensione/spegnimento degli attuatori dall’HTML (tramite HTML request), il programma salva gli
stati che andranno ad acquisire gli attuatori in una stringa. Converte questi in ASCII e li mette nelle tre rispettive variabili.


while (client.available()) {
char c = client.read(); 
counter++;
String txt = String(c);
risposta += txt; 
risposta_length = risposta.length() - 1;
int_risposta_T = int(risposta[risposta_length-4])-48; 
int_risposta_H = int(risposta[risposta_length-2])-48;
int_risposta_L = int(risposta[risposta_length])-48;
}

Una volta che abbiamo salvato i valori nelle variabili,troveremo 0 negli attuatori che andranno spent e 1 in quelli che andranno accesi.
Andiamo a settare gli attuatori in base allo stato richiesto. Se nella variabile vi è 0, andremo a spegnere
l’attuatore (digitalWrite (pinAttuatore_T, LOW); e se vi è 1 andremo ad accenderlo digitalWrite(pinAttuatore_T, HIGH);


risposta = "";
counter = 0;
if(int_risposta_T==1) digitalWrite(pinAttuatore_T, HIGH);
if(int_risposta_T==0) digitalWrite(pinAttuatore_T, LOW);
if(int_risposta_H==1) digitalWrite(pinAttuatore_H, HIGH);
if(int_risposta_H==0) digitalWrite(pinAttuatore_H, LOW);
if(int_risposta_L==1) digitalWrite(pinAttuatore_L, HIGH);
if(int_risposta_L==0) digitalWrite(pinAttuatore_L, LOW);

if (millis()- lastConnectionTime > postingInterval) {
httpRequest(); 
 }
}

Questo frammento di codice serve per collegare alla rete wi-fi la scheda Arduino. Tramite l’istruzione “WiFi.begin” inizializziamo le librerie affinchè questo si possa connettere e aspettiamo 10 secondi perchè possa farlo.


void NetworkConnection() {
while ( status != WL_CONNECTED) {
Serial.print("Attempting to connect to SSID: ");
Serial.println(ssid);
status = WiFi.begin(ssid, pass);
delay(10000);
}
}

Questa funzione tramite httpRequest,se il client è connesso, richiede al server database i valori delle tre variabili prelevandole con la funzione GET dal file “inserisci_valori.php” e le stampa.


void httpRequest() {
client.stop();
if (client.connect(server, 80)) {
Serial.println("connecting...");
http://www.mylegalplants.it/web_app/inserisci_valori.php?...
client.print("GET /web_app/inserisci_valori.php?");
client.print("T=");
client.print(t_value);
client.print("&H=");
client.print(h_value);
client.print("&L=");
client.print(l_value);
client.println(" HTTP/1.0");
client.println("Host: mylegalplants.it");
client.println("Connection: close");
client.println();
lastConnectionTime = millis();
}

Se per qualsiasi motivo la connessione al server database è fallita,ripetiamo l’accesso alla rete.


else {
Serial.println("connection failed");
NetworkConnection();
}
}

Queste tre funzioni,per ogni sensore,tramite GET dai file “attiva_x.php”, prelevano i rispettivi valori e li stampano. Questo se la connessione è stata effettuata correttamente,altrimenti,riprovano a connettersi.


void httpRequestBotT(int T) {
client.stop();

if (client.connect(server, 80)) {
Serial.println("connecting...");
client.print("GET /web_app/attiva_T.php?");
client.print("T=");
client.print(T);
client.println(" HTTP/1.0");
client.println("Host: mylegalplants.it");
client.println("Connection: close");
client.println();

lastConnectionTime = millis();
}
else {
Serial.println("connection failed");
NetworkConnection();
}
}
void httpRequestBotH(int H) {
client.stop();
if (client.connect(server, 80)) {
Serial.println("connecting...");
client.print("GET /web_app/attiva_H.php?");
client.print("H=");
client.print(H);
client.println(" HTTP/1.0");
client.println("Host: mylegalplants.it");
client.println("Connection: close");
client.println();

lastConnectionTime = millis();
}
else {
Serial.println("connection failed");
NetworkConnection();
}
}
void httpRequestBotL(int L) {
client.stop();

if (client.connect(server, 80)) {
Serial.println("connecting...");
client.print("GET /web_app/attiva_L.php?");
client.print("L=");
client.print(L);
client.println(" HTTP/1.0");
client.println("Host: mylegalplants.it");
client.println("Connection: close");
client.println();

lastConnectionTime = millis();
}
else {
Serial.println("connection failed");
NetworkConnection();
}
}

Effettuata la connessione,sul monitor seriale,viene stampato l’SSID della rete Wi-fi a cui ci si è appena connessi,viene stampato l’indirizzo IP della scheda Wi-fi dell’Arduino MKR1000 e viene stampato il valore dell’intensità del segnale della rete Wi-fi,dandoci come unità di misura i dB.


void printWifiStatus() {
Serial.print("SSID: ");
Serial.println(WiFi.SSID());

IPAddress ip = WiFi.localIP();
Serial.print("IP Address: ");
Serial.println(ip);

long rssi = WiFi.RSSI();
Serial.print("signal strength (RSSI):");
Serial.print(rssi);
Serial.println(" dBm");
}