Wi-Fi Body Scale with Arduino
In this post we present the design of a scale that connects to the Internet and automatically sends weight info on a Google Document.
The project is composed of
- Arduino Uno board
- Wi-Fi shield
- additional shield that we used to manage data collection and I/O with a clear and comfortable and clear LCD display
- Velleman scale (or another commercial product)
Hardware
Taking a look at the diagram, we can distinguish three sections:
one for handling digital inputs (two buttons and scale’s switch),
the LCD manager
the analog signal acquisition from load cells
You may notice that P1 and P2 buttons are respectively managed by Arduino’s A3 and A4 inputs (configured as digital), while the INT switch reads the A5 signal (digital as well).
The LCD display used in our project belongs to the family of those based on HD44780 chipset, equipped with seven-pin control (RW, D4, D5, D6, D7, RS and Enable). As you can see from the diagram, RW is permanently connected to ground so it’s only operating in writing mode.
D4, D5, D6 and D7 pins are respectively managed by 3, 5, 6 and 7 digital pins of the Arduino Uno; RS is managed by pin 8 and the Enable pin from pin A0 (this configuration will also be specified in the software).
Besides the power supply (a VCC connected to 5V) and the ground (GND), the display requires a level of voltage between 0 and 5 volts to adjust the contrast in the input pin VO (adjustment made through R6 potentiometer).
Finally the display has 2 pin (A and K respectively anode and cathode) for switching on the backlight: feeding the pin with a voltage of 5V, the backlight is turned on, otherwise it is off.
The switching on and off is handled via a push-button switch that connects or disconnects the ground from the cathode.
Finally let’s analyze the part that manages the analog signal from the load cells: this is done by INA125 integrated component, a high precision amplifier developed specifically for measuring tools like scales.
The IC is fitted with two pins (6 and 7) representing the input of the differential amplification stage. These pins are connected to the two ends of the Wheatstone bridge (which in our project correspond to two of the load cell pins).
As you can figure out, the differential signal coming from the bridge has an absolute value of just a few millivolts: our project requires an amplification of about 500 times, obtained with a 120 ohm resistor.
The amplified output is provided at pins 10 and 11 of INA125; these pins are connected to A1 analog of the Arduino board, which therefore will be used for reading the value ADC.
R2: 1 kohm
R3: 4,7 kohm
R4: 4,7 kohm
R5: 330 ohm
R6: Trimmer 10 kohm
R7: 4,7 kohm
C1: 100 nF 63 VL
C2: 100 µF 25 VL
U1: INA125
P1: Microswitch
P2: Microswitch
LCD: Display LCD 8×2
Hacking the Velleman scale
Our system is designed to be matched to the high-capacity scale produced by Velleman. But you can using any scale usign 4 load cells. The original Velleman electronics and display must be phased out and replaced with our project.
The scale structure is made up of 4 load cells (arranged on the 4 corners), which are configured between them so as to create a single Wheatstone bridge.
To make the connection to our board you must disassemble the lower section of the scale in order to access the electronics.
Referring to Fig A, which shows the structure of the scale viewed from below, with a quick visual analysis is easy to figure out that some blue and red wires are connected to each other while the yellow wires are connected to the switches positioned on the front of the two cells that identify the presence of a person.
To hack the scale follow these steps:
-
unsolder or cut all the red and blue wires, push in short those that were already shorted previously,
-
unsolder or cut the yellow wires coming from the cells numbered 1 and 3, put them in parallel (possibly by welding), extend them and take them to the two terminals on the new INT printed board (Fig.B)
-
unsolder or cut the white wire that is referred to as G3 (Wheatstone bridge mass) on the original printed circuit, extend take it to terminal 1 on the new printed circuit;
-
unsolder or cut the white wire that is referred to as G2 (Wheatstone bridge positive) on the original printed circuit, extend take it to terminal 3 on the new printed circuit;
-
unsolder or cut the white wire that is referred to as G1 and G4 on the original printed circuit, extend take it to terminal 4 and 2 on the new printed circuit (differential signal on the Wheatstone bridge)
The Sketch
As for the LCD, Arduino provides a convenient library (<LiquidCrystal.h>) already supporting different kinds of LCD (both 8 and 16 chars for 2 lines) based on the parallel interface chipset HD44780.
After the inclusion of the library, you must initialize the connection to the display, through LiquidCrystal LCDDisplay (8, A0, 3, 5, 6, 7), in this command, the parameters passed to the function and indicate Arduino’s hardware pins used to connect RS, Enable, D4, D5, D6 and D7 pins of the display.
Depending on the Arduino setup could be necessary to execute LCDDisplay.begin (width, height) in which the parameters indicate the physical dimensions of the display: LCDDisplay.begin (8, 2) in this case.
The library makes available instructions:
- LCDDisplay.setCursor (x, y) to position the cursor in a certain position
-
LCDDisplay.print (String) to print strings
Management of Arduino’s EEPROM is done by the <EEPROM.h> library that, once included, provides the functions:
-
EEPROM.write (add, date) to write a byte in a particular cell and
-
EEPROM.read (add) that the instead reads a byte from one cell (the add parameter specifies the address of the EEPROM cell).
Wi-Fi network and internet connection are managed thanks to the <WiServer.h> library; you just need to define some variables to configure the network (like IP’s and Network masks).
The adapter to connect and publish data on Google Documents shall operate as a Web Client: this configuration is done in the setup instruction WiServer.init (NULL) in which the NULL parameter specifies client mode.
You must create a function that will receive and handle the response from the server, this is done by the googlePublish.setReturnFunc (Gestione_Risposte_Web) instruction in our example. This function must be defined later in the code: in our example is void Gestione_Risposte_Web (char * data, int len) and receives as parameters both a pointer to a string containing the response and the length (in bytes) of the response.
Sending information requires to make a POST request to Google’s servers: WiServer library makes available a POSTrequest just to do this.
You must define the IP address of the server to which you want to connect (Google in our case) and define a structure of the POSTrequest (in our case, the variable is called googlePublish) containing the IP address of the server, the TCP / IP port the server name (spreadsheets.google.com), URL of POST execution and finally a function (SearchQuery in our case) that builds POST request body.
/******************************************************
BilanciaWiFi
Autori: Ingg. Tommaso Giusto e Ing. Alessandro Giusto
Email: tommro@libero.it
******************************************************/
// Inclusione Libreria per Display LCD 8x2
#include <LiquidCrystal.h>
// Inclusione Libreria per EEPROM scheda
#include <EEPROM.h>
// Inclusione Libreria per Server Web WiFi
#include <WiServer.h>
// Inclusione Libreria per SD Card
//#include <SD.h>
// Definizione pin INPUT/OUTPUT
const int PinVPeso = A1; // Ingresso analogico uscita peso
const int PinPulsanteP1 = A3; // Ingresso pulsante P1 su A3
const int PinPulsanteP2 = A4; // Ingresso pulsante P2 su A4
const int PinInterruttore = A5; // Ingresso interruttore su A5
// Definizione/Inizializzazione PIN Display LCD
// LCD RS pin D8
// LCD Enable on pin A0
// LCD D4, D5, D6, D7 on pins D3, D5, D6, D7
// LCD R/W pin a massa
// LCD V0 pin trimmer tra +5V e massa
LiquidCrystal LCDDisplay (8, A0, 3, 5, 6, 7);
/******************************************************
Definizione struttura EEPROM
******************************************************/
/*****************************************************/
// Byte 0x000 Nome
// ... Utente
// Byte 0x01F 000 (0x00 Carattere fine stringa)
// ...
// ...
// ...
// Byte 0x120 Nome
// ... Utente
// Byte 0x13F 009 (0x00 Carattere fine stringa)
/*****************************************************/
#define StartNomiUtentiEEPROMADD 0x0000
#define EndNomiUtentiEEPROMADD 0x013F
#define DimensioneNomeUtenteEEPROMADD 32
#define NumMaxNomiUtenti 10
/*****************************************************/
// Byte 0x140 Parte Alta Peso Utente 000
// Byte 0x141 Parte Bassa Peso Utente 000
// ...
// ...
// ...
// Byte 0x152 Parte Alta Peso Utente 009
// Byte 0x153 Parte Bassa Peso Utente 009
/*****************************************************/
#define StartPesiUtentiEEPROMADD 0x0140
#define EndPesiUtentiEEPROMADD 0x0153
#define DimensionePesoUtenteEEPROMADD 2
#define PesoMIN 100
#define PesoMAX 2000
#define AnalogDifferenzaPesoMAX 15
#define CalibrazioneSensoreMIN 0
#define CalibrazioneSensoreMAX 80
/******************************************************
Definizione variabili globali
******************************************************/
// Definizione Parametri Rete Wireless
#define WIRELESS_MODE_INFRA 1 // Infrastrutturata (basata su Access Point)
#define WIRELESS_MODE_ADHOC 2 // Ad-hoc (senza Access Point)
// Parametri di rete
unsigned char local_ip[] = {192, 168, 0, 89}; // Indirizzo IP
unsigned char gateway_ip[] = {192, 168, 0, 254}; // Indirizzo gateway IP
unsigned char subnet_mask[] = {255, 255, 255, 0}; // Subnet Mask
const prog_char ssid[] PROGMEM = {"FlashMob"}; // SSID access point
// Selezione tipo di cifratura rete Wireless
unsigned char security_type = 0; // 0 -> nessuna cifratura
// 1 -> cifratura WEP
// 2 -> cifratura WPA
// 3 -> cifratura WPA2
// Password cifratura per WPA/WPA2 (max. 64 cratteri)
const prog_char security_passphrase[] PROGMEM = {"12345678"};
// Password cifratura per WEP 128-bit keys
prog_uchar wep_keys[] PROGMEM = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
// Selezione tipo di rete Wireless infrastrutturata
unsigned char wireless_mode = WIRELESS_MODE_INFRA;
// Variabili per lunghezza SSID e password di cifratura
unsigned char ssid_len;
unsigned char security_passphrase_len;
// Definizione Parametri Pubblicazione Google
// Indirizzo IP per server www.google.it
uint8 google_ip[] = {209, 85, 229, 101};
// Richiesta POST verso GOOGLE
POSTrequest googlePublish (google_ip, 80, "spreadsheets.google.com", "", searchQuery);
// Stringa per eseguire pubblicazione
char newURL[] = {"/formResponse?formkey=dDFPcWhxNlZxMEpnUnhNdE5fT1lDcWc6MQ&ifq&entry.0.single=++++++++++++++++++++++++++++++++&entry.1.single=999,9&submit=Submit"};
// This function generates the body of our POST request
void searchQuery() {
}
// Indica presenza SD Card
//boolean presenzaSDCard;
// Inizializzazione Scheda
void setup() {
// Inizializzo dimensioni LCD (8x2)
LCDDisplay.begin (8, 2);
// Inizializzo pin usati come INPUT/OUTPUT
pinMode (PinInterruttore, INPUT);
pinMode (PinPulsanteP1, INPUT);
pinMode (PinPulsanteP2, INPUT);
// Se all'accensione rilevati tutti e 2 i pulsanti premuti
if ((PulsantePremuto (PinPulsanteP1) == 1) &&
(PulsantePremuto (PinPulsanteP2) == 1)) {
// Segnalo inizializzazione in corso
LCDDisplay.setCursor (0, 0);
LCDDisplay.print ("Init EEP");
LCDDisplay.setCursor (0, 1);
LCDDisplay.print ("in corso");
// Inizializzo EEPROM scheda
InizializzaEEPROM();
// Attesa
delay (500);
}
// Inizializzo porta seriale
Serial.begin (9600);
Serial.println ("Bilancia WiFi");
Serial.println ("By Ingg. Tommaso e Alessandro Giusto");
// Invio stato utenti
InviaProgrammazioneUtenti();
// Segnalo Avvio Web
LCDDisplay.setCursor (0, 0);
LCDDisplay.print (" Init ");
LCDDisplay.setCursor (0, 1);
LCDDisplay.print (" web ");
// Inizializzo WiServer
WiServer.init (NULL);
WiServer.enableVerboseMode (false);
// Inizializzazione richiesta POST (parametro indica funzione a cui verra' passata la risposta)
googlePublish.setReturnFunc (Gestione_Risposte_Web);
/*
// Inizializzo SD Card
pinMode(10, OUTPUT);
presenzaSDCard = SD.begin (4);
// Se inizializzazione SD fallita
if (presenzaSDCard == false)
Serial.println ("Init SD FAULT!");
// Se inizializzazione SD riuscita
else
Serial.println ("Init SD OK!");
*/
}
// Programma Principale
void loop() {
// Ciclo infinito di esecuzione
for (;;) {
// Gestione Peso
GestionePeso();
// Per circa 1 sec
for (byte tmp = 0; tmp < 250; tmp++) {
// Gestione programmazione seriale
GestioneSeriale();
// Gestione WiServer
GestioneWiServer();
// Attesa
delay (4);
} // Chiusura ciclo for per circa 1 sec
} // Chiusura ciclo infinito di esecuzione
}
/******************************************************
Definizione funzioni
******************************************************/
// Funzione Gestione Peso
void GestionePeso() {
// Indice utente selezionato
// 0,..,(NumMaxNomiUtenti-1) -> selezionato utente 1,..,NumMaxNomiUtenti
// 0xFF -> nessun utente selezionato
static int IndiceUtenteSelezionato = 0xFF;
// Indica l'indice carattere visualizzato
static int IndiceCarattere = 0;
String NomeUtenteSelezionato;
int PesoUtenteSelezionato;
int LunghezzaNomeUtenteSelezionato;
int ValoreSensorePeso1, ValoreSensorePeso2;
int ValoreSensorePesoTMP1, ValoreSensorePesoTMP2, ValoreSensorePesoTMP3, ValoreSensorePesoTMP4;
static int CalibrazioneSensore;
int CalibrazioneSensoreTMP;
int PesoCalcolato;
int tmp;
// Se non premuto interruttore (utente non salito)
if (PulsantePremuto (PinInterruttore) == 0) {
// Leggo valore sensore per calibrazione
CalibrazioneSensoreTMP = analogRead (PinVPeso);
// Se valore sensore per calibrazione valido
if ((CalibrazioneSensoreTMP >= (int) (CalibrazioneSensoreMIN)) &&
(CalibrazioneSensoreTMP <= (int) (CalibrazioneSensoreMAX)))
// Aggiorno valore sensore per calibrazione
CalibrazioneSensore = CalibrazioneSensoreTMP;
} // Chiusura if non premuto interruttore (utente non salito)
// Se premuto tasto 1
if (PulsantePremuto (PinPulsanteP1) == 1) {
// Azzero indice carattere visualizzato
IndiceCarattere = 0;
// Verifico tutte le posizioni utente
for (tmp = 0; tmp < NumMaxNomiUtenti; tmp++) {
// Seleziono utente selezionato
switch (IndiceUtenteSelezionato) {
// Se selezionato ultimo utente/nessun utente selezionato
case (NumMaxNomiUtenti - 1): case 0xFF:
// Seleziono primo utente
IndiceUtenteSelezionato = 0;
break; // Chiusura case selezionato ultimo utente/nessun utente selezionato
// Se selezionato altro utente
default:
// Seleziono prossimo utente
IndiceUtenteSelezionato++;
break; // Chiusura case nessun utente selezionato
} // Chiusura switch seleziono utente selezionato
// Se trovato utente con nome non nullo
if (LeggiNomeUtente (IndiceUtenteSelezionato).length() != 0x00)
// Blocco ciclo for verifico tutte le posizioni utente
break;
} // Chiusura ciclo for verifico tutte le posizioni utente
// Se non trovato utente con nome non nullo
if (tmp == NumMaxNomiUtenti)
// Seleziono nessun utente
IndiceUtenteSelezionato = 0xFF;
} // Chiusura if premuto tasto 1
// Se utente selezionato
if (IndiceUtenteSelezionato != 0xFF) {
// Leggo nome/peso utente
NomeUtenteSelezionato = LeggiNomeUtente (IndiceUtenteSelezionato);
PesoUtenteSelezionato = LeggiPesoUtente (IndiceUtenteSelezionato);
// Calcolo lunghezza nome utente
LunghezzaNomeUtenteSelezionato = NomeUtenteSelezionato.length();
// Seleziono lunghezza nome utente
switch (LunghezzaNomeUtenteSelezionato) {
case 0:
// Indico nessun utente selezionato
IndiceUtenteSelezionato = 0xFF;
break;
case 1: case 2: case 3: case 4: case 5: case 6: case 7:
LCDDisplay.clear();
LCDDisplay.setCursor ((8 - LunghezzaNomeUtenteSelezionato) / 2, 0);
LCDDisplay.print (NomeUtenteSelezionato);
break;
case 8:
LCDDisplay.setCursor (0, 0);
LCDDisplay.print (NomeUtenteSelezionato);
break;
default:
if ((IndiceCarattere + 8) > LunghezzaNomeUtenteSelezionato)
IndiceCarattere = 0;
LCDDisplay.setCursor (0, 0);
LCDDisplay.print (&NomeUtenteSelezionato[IndiceCarattere]);
// Messaggio scorrevole
IndiceCarattere++;
if ((IndiceCarattere + 8) > LunghezzaNomeUtenteSelezionato)
IndiceCarattere = 0;
break;
} // Chiusura switch seleziono lunghezza nome utente
LCDDisplay.setCursor (0, 1);
LCDDisplay.print (PesoUtenteSelezionato / 1000);
LCDDisplay.print ((PesoUtenteSelezionato % 1000) / 100);
LCDDisplay.print ((PesoUtenteSelezionato % 100) / 10);
LCDDisplay.print (".");
LCDDisplay.print (PesoUtenteSelezionato % 10);
LCDDisplay.print (" Kg");
// Se premuto interruttore (utente salito)
if (PulsantePremuto (PinInterruttore) == 1) {
LCDDisplay.setCursor (0, 1);
LCDDisplay.print ("..... Kg");
// Leggo valore analogico peso
for (;;) {
// Attesa
delay (500);
// Eseguo prima lettura peso
ValoreSensorePesoTMP1 = analogRead (PinVPeso);
delay (125);
ValoreSensorePesoTMP2 = analogRead (PinVPeso);
delay (125);
ValoreSensorePesoTMP3 = analogRead (PinVPeso);
delay (125);
ValoreSensorePesoTMP4 = analogRead (PinVPeso);
delay (125);
ValoreSensorePeso1 = ((ValoreSensorePesoTMP1 + ValoreSensorePesoTMP2 + ValoreSensorePesoTMP3 + ValoreSensorePesoTMP4) / 4);
// Attesa
delay (500);
// Eseguo seconda lettura peso
ValoreSensorePesoTMP1 = analogRead (PinVPeso);
delay (125);
ValoreSensorePesoTMP2 = analogRead (PinVPeso);
delay (125);
ValoreSensorePesoTMP3 = analogRead (PinVPeso);
delay (125);
ValoreSensorePesoTMP4 = analogRead (PinVPeso);
delay (125);
ValoreSensorePeso2 = ((ValoreSensorePesoTMP1 + ValoreSensorePesoTMP2 + ValoreSensorePesoTMP3 + ValoreSensorePesoTMP4) / 4);
// Se peso stabilizzato
if ((ValoreSensorePeso1 <= ValoreSensorePeso2) && ((ValoreSensorePeso2 - ValoreSensorePeso1) < (int) (AnalogDifferenzaPesoMAX)) ||
(ValoreSensorePeso1 > ValoreSensorePeso2) && ((ValoreSensorePeso1 - ValoreSensorePeso2) < (int) (AnalogDifferenzaPesoMAX)))
// Blocco ciclo for leggo valore analogico peso
break;
} // Chiusura ciclo for leggo valore analogico peso
// Calcolo peso utente
PesoCalcolato = (int) (ValoreSensorePeso2 - CalibrazioneSensore);
PesoCalcolato = (PesoCalcolato + (((int) (PesoCalcolato * (int) (10))) / (int) (62)));
// 68.1 KG
// 642 con calibrazione: 62 -> Veff = 580
// Se peso valido
if ((PesoCalcolato >= (int) (PesoMIN)) && (PesoCalcolato <= (int) (PesoMAX))) {
// Memorizzo peso utente
ScriviPesoUtente (IndiceUtenteSelezionato, PesoCalcolato);
// Visualizzo peso calcolato
LCDDisplay.setCursor (0, 1);
LCDDisplay.print (PesoCalcolato / 1000);
LCDDisplay.print ((PesoCalcolato % 1000) / 100);
LCDDisplay.print ((PesoCalcolato % 100) / 10);
LCDDisplay.print (".");
LCDDisplay.print (PesoCalcolato % 10);
LCDDisplay.print (" Kg");
// Richiedo pubblicazione
LCDDisplay.setCursor (0, 0);
LCDDisplay.print ("Pubblic?");
// Per massimo 5 secondi attendo pressione tasto 2
for (tmp = 0; tmp < 10; tmp++) {
// Se premuto tasto 2
if (PulsantePremuto (PinPulsanteP2) == 1) {
// Indico pubblicazione in corso
LCDDisplay.setCursor (0, 0);
LCDDisplay.print ("Pubblic.");
LCDDisplay.setCursor (0, 1);
LCDDisplay.print (" wait ");
// Eseguo pubblicazione
for (tmp = 0; tmp < NomeUtenteSelezionato.length(); tmp++) {
newURL[76 + tmp] = NomeUtenteSelezionato.charAt(tmp);
if (newURL[76 + tmp] == ' ')
newURL[76 + tmp] = '+';
}
newURL[124] = ((PesoCalcolato / 1000) + 0x30);
newURL[125] = (((PesoCalcolato % 1000) / 100) + 0x30);
newURL[126] = (((PesoCalcolato % 100) / 10) + 0x30);
newURL[128] = ((PesoCalcolato % 10) + 0x30);
googlePublish.setURL(newURL);
googlePublish.submit();
delay (500);
// Blocco ciclo for
break;
}
delay (500);
} // Chiusura ciclo for per massimo 5 secondi attendo pressione tasto 2
/*
// Se SD rilevata
if (presenzaSDCard == true) {
// Verifico/Creo directory BilanciaWiFi
if (!(SD.exists ("BilanciaWiFi")))
SD.mkdir ("BilanciaWiFi");
// Memorizzo il peso su file
File filePeso;
// Apro il file in scrittura
char nomeFilePeso[50] = {"BilanciaWiFi/"};
for (tmp = 0; tmp < NomeUtenteSelezionato.length(); tmp++) {
charTmp[0] = NomeUtenteSelezionato.charAt(tmp);
strcat (nomeFilePeso, charTmp);
}
strcat (nomeFilePeso, ".txt");
filePeso = SD.open (nomeFilePeso, FILE_WRITE);
// Se apertura file OK
if (filePeso) {
// Memorizzo il peso
filePeso.print ((PesoCalcolato / 1000) + 0x30);
filePeso.print (((PesoCalcolato % 1000) / 100) + 0x30);
filePeso.print (((PesoCalcolato % 100) / 10) + 0x30);
filePeso.print (".");
filePeso.print ((PesoCalcolato % 10) + 0x30);
filePeso.print (" Kg");
// Chiudo il file:
filePeso.close();
}
}
*/
LCDDisplay.setCursor (0, 0);
LCDDisplay.print (" Step ");
LCDDisplay.setCursor (0, 1);
LCDDisplay.print (" off ");
// Attendo utente scende dalla bilancia
for (;;) {
// Se non premuto interruttore (utente non salito)
if (PulsantePremuto (PinInterruttore) == 0)
break;
}
} // Chiusura if peso valido
} // Chiusura if premuto interruttore (utente salito)
} // Chiusura if utente selezionato
// Se nessun utente selezionato
else {
LCDDisplay.setCursor (0, 0);
LCDDisplay.print (" Chose ");
LCDDisplay.setCursor (0, 1);
LCDDisplay.print (" user ");
} // Chiusura if nessun utente selezionato
}
// Funzione Gestione Seriale
void GestioneSeriale() {
String comandoRicevutoString = "";
int numeroUtenteRicevuto;
String nomeUtenteRicevuto = "";
// Se ricevuti dati dalla porta seriale
if (Serial.available()) {
// Attendo tutti i dati
delay (250);
// Ricevo i dati
while (Serial.available())
comandoRicevutoString += (char) (Serial.read());
// Invio comando ricevuto
Serial.println (comandoRicevutoString);
// Se ricevuti almeno 15 caratteri
if (comandoRicevutoString.length() >= 15) {
// Se ricevuto comando programmazione nome utente (NOME_UTENTE_xx=)USER_NAME_01=Boris
if ((comandoRicevutoString.substring (0, 12).equals("P_USER_NAME_")) &&
(isdigit(comandoRicevutoString.charAt (12))) &&
(isdigit(comandoRicevutoString.charAt (13)))) {
// Estraggo numero utente ricevuto
numeroUtenteRicevuto = (((comandoRicevutoString.charAt (12) - 0x30) * 10) +
(comandoRicevutoString.charAt (13) - 0x30));
// Se ricevuto numero utente corretto
if ((numeroUtenteRicevuto >= 1) && (numeroUtenteRicevuto <= NumMaxNomiUtenti)) {
// Estraggo nome utente
nomeUtenteRicevuto = comandoRicevutoString.substring (15);
// Se nome troppo lungo
if (nomeUtenteRicevuto.length() > DimensioneNomeUtenteEEPROMADD)
// Tronco il nome
nomeUtenteRicevuto = nomeUtenteRicevuto.substring (0, DimensioneNomeUtenteEEPROMADD);
// Memorizzo il nome
ScriviNomeUtente (numeroUtenteRicevuto - 1, nomeUtenteRicevuto);
// Azzero il relativo peso
AzzeraPesoUtente (numeroUtenteRicevuto - 1);
// Indico OK
Serial.println ("OK");
// Invio su porta seriale lo stato utenti
InviaProgrammazioneUtenti();
// Termino funzione
return;
}
}
}
// Indico errore
Serial.println ("FAULT");
// Termino funzione
return;
}
}
// Invia su porta seriale lo stato utenti
void InviaProgrammazioneUtenti() {
for (int numeroUtente = 0; numeroUtente < NumMaxNomiUtenti; numeroUtente++) {
Serial.print ("Us. ");
Serial.print ((numeroUtente + 1) / 10);
Serial.print ((numeroUtente + 1) % 10);
Serial.print (": ");
Serial.println (LeggiNomeUtente (numeroUtente));
}
}
// Funzione Gestione WiServer
void GestioneWiServer() {
// Gestione WiServer
WiServer.server_task();
}
// Gestione diverse risposte provenienti dal WEB
void Gestione_Risposte_Web (char* data, int len) {
// Print the data returned by the server
// Note that the data is not null-terminated, may be broken up into smaller packets, and
// includes the HTTP header.
while (len-- > 0) {
Serial.print(*(data++));
}
}
// Scrive il nome di un utente
// INPUT: Posizione utente (0,..,9)
// Nome utente in formato stringa
// OUTPUT: -
// Note: -
void ScriviNomeUtente (int NomePosition, String NomeUtente) {
// Azzero nome utente selezionato
AzzeraNomeUtente (NomePosition);
// Scrivo i caratteri nome utente selezionato
for (int tmp = 0; tmp < NomeUtente.length(); tmp++)
EEPROM.write (StartNomiUtentiEEPROMADD + tmp +
(NomePosition * DimensioneNomeUtenteEEPROMADD), NomeUtente.charAt(tmp));
}
// Legge il nome di un utente
// INPUT: Posizione utente (0,..,9)
// OUTPUT: Nome utente in formato stringa
// Note: -
String LeggiNomeUtente (int NomePosition) {
String NomeUtente = "";
char NomeUtenteChar;
// Leggo i caratteri nome utente selezionato
for (int tmp = 0; tmp < DimensioneNomeUtenteEEPROMADD; tmp++) {
// Leggo singolo carattere
NomeUtenteChar = EEPROM.read (StartNomiUtentiEEPROMADD + tmp +
(NomePosition * DimensioneNomeUtenteEEPROMADD));
// Se trovato carattere fine nome
if (NomeUtenteChar == 0x00)
// Blocco ciclo for leggo i caratteri nome utente selezionato
break;
// Accodo carattere letto
NomeUtente = NomeUtente + NomeUtenteChar;
}
// Ritorno il nome
return (NomeUtente);
}
// Azzera il nome di un utente
// INPUT: Posizione utente (0,..,9)
// OUTPUT: -
// Note: -
void AzzeraNomeUtente (int NomePosition) {
// Azzero caratteri nome utente selezionato
for (int tmp = 0; tmp < DimensioneNomeUtenteEEPROMADD; tmp++)
EEPROM.write (StartNomiUtentiEEPROMADD + tmp +
(NomePosition * DimensioneNomeUtenteEEPROMADD), 0);
}
// Scrive il peso di un utente
// INPUT: Posizione utente (0,..,9)
// Peso utente
// OUTPUT: -
// Note: -
void ScriviPesoUtente (int PesoPosition, int PesoUtente) {
// Memorizzo peso nome utente
EEPROM.write (StartPesiUtentiEEPROMADD +
(PesoPosition * DimensionePesoUtenteEEPROMADD), (byte) (PesoUtente >> 8));
EEPROM.write (StartPesiUtentiEEPROMADD + 1 +
(PesoPosition * DimensionePesoUtenteEEPROMADD), (byte) (PesoUtente & 0x00FF));
}
// Legge il peso di un utente
// INPUT: Posizione utente (0,..,9)
// OUTPUT: Peso utente
// Note: -
int LeggiPesoUtente (int PesoPosition) {
// Ritorno il peso
return (((int) (EEPROM.read (StartPesiUtentiEEPROMADD +
(PesoPosition * DimensionePesoUtenteEEPROMADD))) << 8) +
(int) (EEPROM.read (StartPesiUtentiEEPROMADD + 1 +
(PesoPosition * DimensionePesoUtenteEEPROMADD))));
}
// Azzera il peso di un utente
// INPUT: Posizione utente (0,..,9)
// OUTPUT: -
// Note: -
void AzzeraPesoUtente (int PesoPosition) {
// Azzero peso nome utente
ScriviPesoUtente (PesoPosition, 0);
}
// Inizializza EEPROM scheda
// INPUT: -
// OUTPUT: -
// Note: -
void InizializzaEEPROM() {
// Azzero i nomi/pesi di tutti gli utenti
for (int tmp = 0; tmp < NumMaxNomiUtenti; tmp++) {
AzzeraNomeUtente (tmp);
AzzeraPesoUtente (tmp);
}
}
// Verifica lo stato di un pulsante
// INPUT: Pin pulsante
// OUTPUT: Stato pulsante 0 -> pulsante non premuto
// 1 -> pulsante premuto
// Note: -
int PulsantePremuto (int PinPulsante) {
if (digitalRead (PinPulsante) == LOW)
return (1);
else
return (0);
}
Install the WiShield libraries
To work properly, the Wifi shield requires specific libraries that must be installed in the Arduino IDE used to compile the sources so you’ll need to put these libraries in the Arduino libraries path.
The library supports multiple operating modes (APP_WEBSERVER, APP_WEBCLIENT, APP_SOCKAPP, APP_UDPAPP and APP_WISERVER).
The default value is APP_WEBSERVER, which runs on most Arduino systems but has several limitations. The main limitation is that it can’t function both as a client and server simultaneously.
It is therefore recommended the APP_WISERVER (in the library named “WiServer.h“) which allows the Arduino shield equipped with Wi-Fi to be configured and operated either as a Web Server as a Web Client.
In the first case, you can serve connection requests from external web clients and send HTML pages in response, in the second it will be possible to connect to a web server and send GET or POST requests.
To configure the WiShield library as APP_WISERVER you must open the apps-conf.h file, comment the “#define“ APP_WEBSERVER row and uncomment the “#define” of APP_WISERVER row.
Something like:
/ / # define APP_WEBSERVER
/ / # define APP_WEBCLIENT
/ / # define APP_SOCKAPP
/ / # define APP_UDPAPP
# defineAPP_WISERVER
Configuring publishing
Performing data publication on Google Documents requires three distinct steps:
- Configuring Wi-Fi network access;
- Creating a Google Docs form module: each module is characterized by an identifying 34 characters string – FormKey) and each field is characterized by an identification number (called Entry).
- Inserting the FormKey / Entry in the Arduino software.
Configuring network parameters
First you must configure and update the IP address, Subnet Mask, Gateway IP and Network SSID, then select the encryption mode and change password information for your network. Save all, compile and run the upload Software tab.
Creating the Google module doc
Create a form on Google Docs, modify the form with two fields (username and weight, both of type string) and save the job. (the result is something like the one shown in Figure). In our case, we left the default file name and called the two fields “User Name” and “User weight”
take note of this key string because then it will be inserted in the Arduino software: as you can see from the picture, the link shows the form key assigned to the module (in this example, the link is: https://docs.google.com/spreadsheet/viewform?formkey=dDFPcWhxNlZxMEpnUnhNdE5fT1lDcWc6MQ which implies that the form assigned key is “dDFPcWhxNlZxMEpnUnhNdE5fT1lDcWc6MQ”);
Clicking on the link will open a new page that shows the data entry form: within this form text fields are marked with “entry.0.single“, “entry.1.single“, etc … (basically with an integer id)
To see which number has been assigned to our fields you need to display the HTML source of the form (the result is something like the one shown in this Figure).
You can easily find the ID numbers assigned to different fields (in our example “entry.0.single” is the “Name” and “entry.1.single” is the “weight“).
Take note of this information because it will be included in the source Arduino as well.
Formkey / entry
Once you have created the form, the Arduino source will be configured so that it is compatible with the form you created.
A variable is defined in Arduino source named newURL[]: the variable is initialized with a standard format then modified to perform publication (refer to Figure 11 to identify it in the code).
Replace the default values with those obtained at the time of the creation of the form, compile and download it to the Arduino board.
How to program user names
The configuration of user names can be made via serial port and Serial Monitor. To program it, connect to the board (via USB cable) and open the Arduino Serial Monitor. As a first step the card sends a summary of the current configuration.
To program a new user name you must send a string in the format “P_USER_NAME_xx = User Name” with xx between 01 and 10 ID (put an empty string to delete the selected user.) If all the posted information is correct, this is confirmed by the message “Ok” otherwise “Fault”.
Using the scale
The scale software is able to distinguish up to 10 users (each identified by its name) and, for each one, it stores the last measured weight.
If you want to clear the memory (which we recommend at first use) is sufficient to hold down either of the two buttons (the display indicates the operation with “EEP init in progress”).
Later, you can configure names following the procedure described in the “Programming user names” section.
As the next step the Web management interface will start and the system will enter its normal operation. The user selection is done by pressing button P1.
Going over the scale starts the weighing procedure (lasting several seconds): weight is displayed and stored and the scale asks for publishing on the web: by pressing P2 the operation is performed.
#define RELE_PIN 9 //scegliere il pin che si vuole utilizzare in base alla scelta fatta con il jumper sulla scheda (9 | 10)
#define BUZZ_PIN 3 //scegliere il pin che si vuole utilizzare in base alla scelta fatta con il jumper sulla scheda (3 | 11)
#define GREEN_LED_PIN 8 //pin relativo al led verde
#define RED_LED_PIN 6 //pin relativo al led rosso
//scegliere cosa fare quando viene letta una scheda
#define RELE 0 //scegliere '1' per fare in modo che alla lettura di una scheda il relè venga attivato '0' per non fare nulla
#define BUZZER 1 //scegliere '1' per fare in modo che alla lettura di una scheda il buzzer emetta un suono '0' per non fare nulla
#define LED 1 //scegliere '1' per fare in modo che alla lettura di una scheda corretta venga acceso il led verde e per una scheda incorretta il led rosso '0' per non fare nulla
#define DURATA_RELE 1000 //scegliere il tempo per il quale deve rimanere acceso il relè (se viene inserito '0' il relè funzionerà in modo bistabile)
boolean check; //variabile con la quale eseguo tutti i controlli all'interno dello sketch
int on_off=0; //variabile che utilizzo per controllare lo stato del led in modalità bistabile
NewSoftSerial mySerial(DATA_PIN,1); //inizializzo il pin sul quale leggere i dati trasmessi dall'ID-12
void setup() {
if(DURATA_RELE>60000) //controllo che il tempo impostato per la durata di attivazione del relè sia inferiore a 1 minuto
while(1){ //in caso contrario stampo su seriale un messaggio di errore in un ciclo infinito
delay(2000);
Serial.print("Tempo relè non valido, troppo alto");
}
pinMode(PULSANTE,INPUT); //imposto il pin del pulsante in modalità input per verificare quando il pulsante viene premuto
digitalWrite(PULSANTE,HIGH); //e lo setto alto, in modo tale da attivare la resistenza di pull-up
if(RELE) //controllo se è stato scelto di attivare o meno il relè, nel primo caso, imposto il pin assegnatogli come output
pinMode(RELE_PIN,OUTPUT);
if(BUZZER) //controllo se è stato scelto di attivare o meno il buzzer, nel primo caso, imposto il pin assegnatogli come output
pinMode(BUZZ_PIN,OUTPUT);
if(LED){ //controllo se è stato scelto di attivare o meno i led, nel primo caso, imposto i pin assegnatogli come output
pinMode(GREEN_LED_PIN,OUTPUT);
pinMode(RED_LED_PIN,OUTPUT);
}
Serial.begin(9600); //Inizializzo la porta seriale sulla frequenza di 9600 baud
mySerial.begin(9600); //inizializzo la seriale sulla quale leggo i dati delle schede a 9600 baud
if(digitalRead(PULSANTE)==LOW) azzera(); //controllo che il il pulsante sia premuto in fase di accensione del dispositivo, in caso affermativo azzero tutta la memoria EEPROM
}
void loop () {
byte val; //variabile che utilizzo per leggere i valori dalla tessera appena passata
byte code[6]; //vettore nel quale salvo il codice letto completo
byte checksum; //variabile sulla quale calcolo e salvo il checksum
byte bytesread; //variabile che viene utilizzata per per contare quanti byte sono stati letti
byte tempbyte; //variabile che mi serve per memorizzare temporaneamente mezzo byte letto
unsigned long int tempo=0; //variabile che utilizzo per salvare il tempo attuale, per contare i millisecondi passati
boolean scrivere=false; //variabile che utilizzo per controllare se la tessera appena letta è da salvare o da controllare
boolean controllo=false; //variabile che utilizzo per controllare se la tessera appena letta è da cancellare oppure no
if(digitalRead(PULSANTE)==LOW){ //controllo se il pulsante è premuto
tempo=millis(); //se lo è salvo gli attuali millisecondi passati dall'avvio del dispositivo
while((digitalRead(PULSANTE)==LOW)&&(tempo+3000>millis())); //quindi mando in esecuzione un ciclo che non fa nulla
if(millis()>tempo+2999){ //controllo dopo la fine del ciclo se esso è stato in esecuzione per 3 secondi, confrontando il tempo iniziale + 3000 con il tempo attuale
if(LED)
digitalWrite(GREEN_LED_PIN,HIGH); //se così è, accendo il led verde
Serial.println("Modalità registrazione"); //e stampo sulla seriale che sono entrato in modalità registrazione
if(BUZZER){
analogWrite(BUZZ_PIN,50);
delay(50); //e faccio fare un suono di avviso al buzzer
digitalWrite(BUZZ_PIN,LOW);
}
scrivere=true; //e pongo a vero la variabile scrivere
}
if(digitalRead(PULSANTE)==LOW){ //se dopo ciò il pulsante è ancora premuto
while((digitalRead(PULSANTE)==LOW)&&(tempo+5000>millis())); //mando in esecuzione un altro ciclo nullo
if(millis()>tempo+4999){ //se esso è stato in esecuzione per 2 secondi significa che sono entrato in modalita eliminazione
Serial.println("Modalità eliminazione"); //quindi lo scrivo sulla seriale
if(LED){
digitalWrite(RED_LED_PIN,HIGH); //accendo il led rosso
digitalWrite(GREEN_LED_PIN,LOW); //spengo quello verde, precedentemente acceso
}
if(BUZZER){
analogWrite(BUZZ_PIN,50);
delay(50); //faccio fare un suono di avviso al buzzer
digitalWrite(BUZZ_PIN,LOW);
}
while(digitalRead(PULSANTE)==LOW); //mando in esecuzione un ciclo finchè il pulsante non viene rilasciato
controllo=true; //e pongo a vero la variabile controllo
}
}
}
//-------------------------------------------------------------------------------------inizio do-while------------------------------------------------------------------------------------------
do{ //inizio un ciclo che finirà solo quando verrà premuto nuovamente il pulsante
val = 0;
checksum = 0; //azzero le variabili precedentemente dichiarate
bytesread = 0;
tempbyte = 0;
if(mySerial.available() > 0) { //controllo se sulla mia seriale è presente qualche dato
if((val = mySerial.read()) == 2) { //se così è leggo da essa il valore
bytesread = 0; //e se è uguale a 2 (carattere di controllo) pongo a 0 la variabile bytesread
while (bytesread < 12) { //mando in esecuzione un ciclo per 12 volte, in modo da poter leggere tutti i 12 caratteri della tessera (5 byte del codice + 1 del cehcksum
if( mySerial.available() > 0) { //controllo se i dati sono disponibili ad essere letti
val = mySerial.read(); //quindi assegno a 'val' il valore dell'i-esimo carattere
if((val == 0x0D)||(val == 0x0A)||(val == 0x03)||(val == 0x02)) { //se leggo un carattere 'header' o un carattere di stop
break; // fermo la lettura
}
if ((val >= '0') && (val <= '9')) {
val -= '0';
} //traduco in esadecimale il carattere appena letto
else if ((val >= 'A') && (val <= 'F')) {
val = 10 + val - 'A';
}
//ogni 2 caratteri letti, aggiungo il byte così creato al vettore 'code'
if (bytesread & 1 == 1) { //se ho letto un solo carattere fin'ora
code[bytesread >> 1] = (val | (tempbyte << 4)); //assegno alla seconda parte del byte in posizione bytesread-esima il valore esadecimale del carattere letto
if (bytesread >> 1 != 5) { //se ho letto l'ultimo byte della scheda calcolo il checksum
checksum ^= code[bytesread >> 1]; //facendo la XOR sull'ultimo byte letto
};
} else {
tempbyte = val; //altrimenti assegno il valore letto alla variabile tempbyte
};
bytesread++; //mi preparo a leggere il prossimo byte
}
}
if (bytesread == 12) { //se ho letto tutti i 6 byte
(code[5]==checksum) ? check = true : check = false ; //controllo che il checksum sia corretto
if(check){ //se lo è passo a controllare se devo salvare o cancellare
check=false; //rimetto a false la variabile check per successivi utilizzi
if(scrivere&&!controllo){ //controllo se devo scrivere
for(int i=0;i<1021;i+=5){ //in caso affermativo eseguo un ciclo che controlla tutta la EEPROM
if((EEPROM.read(i)==code[0])&&(EEPROM.read(i+1)==code[1])&&(EEPROM.read(i+2)==code[2])&&(EEPROM.read(i+3)==code[3])&&(EEPROM.read(i+4)==code[4])){
check=true; //se trovo il codice della tessera letta già salvato nella EEPROM metto a true la variabile 'check'
break; //ed esco dal ciclo
}
}
if(check){ //quindi controllo il valore della variabile check, se è vero, significa che la tessera è già stata registrata
Serial.print("Tessera già registrata!"); //quindi lo comunico su seriale
stampa_code(code);
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
delay(50);
if(BUZZER)
analogWrite(BUZZ_PIN,50); //e mando un segnale di errore luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
delay(50);
if(BUZZER)
digitalWrite(BUZZ_PIN,LOW);
if(LED)
digitalWrite(RED_LED_PIN,LOW);
}
else{ //se la tessera non è stata trovata
check=false; //rimetto a false la variabile check per successivi utilizzi
for(int i=0;i<1021;i+=5){ //quindi eseguo un ciclo che controlla tutta la EEPROM in cerca di 5 byte successivi liberi
if((EEPROM.read(i)==0xff)&&(EEPROM.read(i+1)==0xff)&&(EEPROM.read(i+2)==0xff)&&(EEPROM.read(i+3)==0xff)&&(EEPROM.read(i+4)==0xff)){
for(int j=i;j<i+5;j++) //una volta trovati, partendo dal primo, fino al quinto, ci salvo il valore della tessera
EEPROM.write(j,code[j-i]); //eseguendo un ciclo 5 volte
check=true; //pongo a true la variabile check
break; //ed esco dal ciclo
}
}
if(check){ //se la variabile check è vera, significa che ho salvato con successo, quindi
Serial.print("Tessera Salvata"); //lo stampo su seriale
stampa_code(code);
if(BUZZER){
analogWrite(BUZZ_PIN,50);
delay(100);
digitalWrite(BUZZ_PIN,LOW);
}
if(LED){
for(int i=0;i<5;i++){
digitalWrite(GREEN_LED_PIN,HIGH); //e mando un segnale luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
delay(50);
digitalWrite(GREEN_LED_PIN,LOW);
delay(50);
}
digitalWrite(GREEN_LED_PIN,HIGH);
}
}
else{ //se la variabile check non è vera, significa che ho controllato tutta la memoria senza trovare 5 byte sequenziali liberi
Serial.println("Memoria piena"); //quindi spamo su seriale che la memoria è piena
for(int i=0;i<5;i++){
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
if(BUZZER)
analogWrite(BUZZ_PIN,50);
delay(50); //e mando un segnale di errore luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
if(LED)
digitalWrite(RED_LED_PIN,LOW);
if(BUZZER)
digitalWrite(BUZZ_PIN,LOW);
delay(50);
}
}
}
}
else if(scrivere&&controllo){ //se non bisogna salvare, controllo se bisogna eliminare una tessera
int posizione=-1; //quindi inizializzo a -1 la variabile posizione, che mi servirà per salvare la posizione nella EEPROM della tessera
for(int i=0;i<1021;i+=5){ //ed eseguo un ciclo che controlla tutta la EEPROM per cercare il codice corrispondente
if((EEPROM.read(i)==code[0])&&(EEPROM.read(i+1)==code[1])&&(EEPROM.read(i+2)==code[2])&&(EEPROM.read(i+3)==code[3])&&(EEPROM.read(i+4)==code[4])){
posizione=i; //se viene trovato salvo la posizione del primo byte nella variabile posizione
break; //ed esco dal ciclo
}
}
if(posizione!=-1){ //quindi controllo che la variabile posizione sia diversa da -1 così da sapere se è stato trovato o meno il codice
for(int j=posizione;j<posizione+5;j++) //eseguo quindi un ciclo partendo dalla posizione 'posizione' nella EEPROM
EEPROM.write(j,0xff); //sovrascrivendo i 5 byte corrispondenti alla tessera, con il byte di default '0xff'
Serial.print("Scheda cancellata"); //una volta fatto ciò, stampo su seriale l'avvenuta cancellazione
stampa_code(code);
if(LED){
digitalWrite(GREEN_LED_PIN,HIGH);
digitalWrite(RED_LED_PIN,HIGH);
}
if(BUZZER)
analogWrite(BUZZ_PIN,50); //e mando un segnale luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
delay(250);
if(LED)
digitalWrite(GREEN_LED_PIN,LOW);
if(BUZZER)
digitalWrite(BUZZ_PIN,LOW);
}
else{ //se la variabile posizione vale -1 significa che non ha trovato in memoria la tessera letta
Serial.print("Impossibile cancellare la scheda, non è salvata"); //quindi lo comunico su seriale
stampa_code(code);
for(int x=0;x<10;x++){
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
if(BUZZER)
analogWrite(BUZZ_PIN,50);
delay(25); //e mando un segnale di errore luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
if(LED)
digitalWrite(RED_LED_PIN,LOW);
if(BUZZER)
digitalWrite(BUZZ_PIN,LOW);
delay(25);
}
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
}
}
check=true; //rimetto a vero il valore della variabile check siccome il checksum è corretto
}
else{ //se il checksum fosse incorretto
Serial.print("Checksum incorretto"); //lo comunico su seriale
for(int i=0;i<3;i++){
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
if(BUZZER)
analogWrite(BUZZ_PIN,50);
delay(30); //e mando un segnale di errore luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
if(LED)
digitalWrite(RED_LED_PIN,LOW);
if(BUZZER)
digitalWrite(BUZZ_PIN,LOW);
}
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
}
}
}
}
}
while((digitalRead(PULSANTE)==HIGH)&&(controllo||scrivere));
//-------------------------------------------------------------------------------------------fine do-while---------------------------------------------------------------------------------------
if(LED){
digitalWrite(GREEN_LED_PIN,LOW); //spengo gli eventuali led accesi per conoscere la modalità nella quale ero all'interno del ciclo
digitalWrite(RED_LED_PIN,LOW);
}
if (bytesread == 12) { //controllo di avere letto tutti i 6 byte della tessera
if(check){ //controllo che il checksum sia corretto
if(!scrivere){ //e controllo anche che non ci sia da salvare/scrivere una tessera
check=false; //rimetto a false la variabile check per successivi utilizzi
for(int i=0;i<1021;i+=5) //eseguo un ciclo che controlla tutta la EEPROM alla ricerca della tessera letta
if(EEPROM.read(i)==code[0]&&EEPROM.read(i+1)==code[1]&&EEPROM.read(i+2)==code[2]&&EEPROM.read(i+3)==code[3]&&EEPROM.read(i+4)==code[4]){
check=true; //se viene trovata metto a true la variabile check
break; //ed esco dal ciclo
}
if(check){ //quindi controllo il valore della variabile check
Serial.print("Tessera valida"); //se è vero, significa che la tessera è stata trovata e quindi è valida, e lo stampo su seriale
stampa_code(code);
if(LED)
digitalWrite(GREEN_LED_PIN,HIGH);
if(BUZZER){
analogWrite(BUZZ_PIN,50);
delay(200);
digitalWrite(BUZZ_PIN,LOW); //quindi in base alla selezione dell'utente
} //mando un segnale luminoso e/o sonoro
if(RELE){ //in più accendo il relè
if(DURATA_RELE){ //secondo la modalità impostata dall'utente
digitalWrite(RELE_PIN,HIGH);
tempo=millis();
while(tempo+DURATA_RELE>millis());
digitalWrite(RELE_PIN,LOW);
}
else{
if(on_off){
digitalWrite(RELE_PIN,LOW);
on_off--;
}
else{
digitalWrite(RELE_PIN,HIGH);
on_off++;
}
}
}
}
else{ //se al contrario il valore è falso
Serial.print("Tessera non valida!"); //significa che ho controllato tutta la memoria senza trovare la tessera, quindi lo comunico su seriale
stampa_code(code);
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
if(BUZZER){
analogWrite(BUZZ_PIN,50);
delay(50);
digitalWrite(BUZZ_PIN,LOW); //e mando un segnale di errore luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
delay(50);
analogWrite(BUZZ_PIN,50);
delay(50);
digitalWrite(BUZZ_PIN,LOW);
}
}
}
if(LED){
delay(500);
digitalWrite(GREEN_LED_PIN,LOW); //spegno gli eventuali led rimasti accesi
digitalWrite(RED_LED_PIN,LOW);
}
}
else{ //se il checksum fosse incorretto
Serial.print("Checksum incorretto"); //lo comunico su seriale
for(int i=0;i<3;i++){
if(LED)
digitalWrite(RED_LED_PIN,HIGH);
if(BUZZER)
analogWrite(BUZZ_PIN,50);
delay(30); //e mando un segnale di errore luminoso e/o sonoro in sempre in base al fatto che l'utente abbia specificato led e buzzer
if(LED)
digitalWrite(RED_LED_PIN,LOW);
if(BUZZER)
digitalWrite(BUZZ_PIN,LOW);
}
}
}
bytesread=0; //azzero la variabile bytesread per una prossima lettura
}
//--------------------------------------------------------------------------FUNZIONE PER AZZERARE LA MEMORIA EEPROM------------------------------------------------------------------------------
void azzera(){
if(LED){
digitalWrite(GREEN_LED_PIN,HIGH);
digitalWrite(RED_LED_PIN,HIGH);
}
for(int i=0;i<1023;i++)
EEPROM.write(i,0xff);
Serial.println("Memoria Azzerata!");
if(BUZZER)
analogWrite(BUZZ_PIN,50);
for(int i=0;i<5;i++)
if(LED){
digitalWrite(GREEN_LED_PIN,HIGH);
delay(100);
digitalWrite(GREEN_LED_PIN,LOW);
digitalWrite(RED_LED_PIN,HIGH);
delay(100);
digitalWrite(RED_LED_PIN,LOW);
}
if(BUZZER)
digitalWrite(BUZZ_PIN,LOW);
}
//--------------------------------------------------------------FUNZIONE PER STAMPARE IL CODICE DELLA TESSERA LETTA SU SERIALE-------------------------------------------------------------------
void stampa_code(byte * code){
Serial.print(": <");
for (int i=0; i<5; i++) {
if (code[i] < 16) Serial.print("0");
Serial.print(code[i], HEX);
if(i!=4)
Serial.print(" ");
}
Serial.println(">");
}
we recreated all using a system based on Arduino.
