// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
D1- colorazione vernici – varnish coloring (some notes at section end)
In questo impianto Arduino gestisce la colorazione di una vernice bianca in un colore scelto dall’operatore tramite un display touchscreen. La colorazione viene eseguita tramite tre pompe peristaltiche aventi una portata da 50 millilitri al minuto, che attingono a boccette contenenti i coloranti base: blu,rosso e giallo.
Arduino attiva ogni pompa per un tempo (in millisecondi) calcolato in funzione del colore desiderato e del peso dalla vernice da colorare.
Sotto l’aspetto operativo l’operatore deve: 1. Posizionare un contenitore vuoto sul piatto della bilancia, al fine di calcolare la tara (solo al
momento dell’attivazione del sistema); 2. Posizionare sul piatto il contenitore con la vernice bianca da colorare 3. Selezionare, sul display, il colore desiderato (figura 1) 4. Premere il pulsante “avanti” (figura 2)
figura 1
figura 2
figura 3
A questo punto Arduino calcola i millisecondi di funzionamento di ognuna delle tre pompe ed attiva i rele’, che a loro volta attivano le pompe, per il suddetto tempo.
Poiche’ la capacita’ tingente dei coloranti, le caratteristiche delle vernici e la portata delle pompe sono differenti a seconda dei coloranti e dei tipi di vernice e delle pompe, qualora si intendesse replicare questo progetto sara’ necessario ridefinire ed inserire nel programma le dosi (in termini di millisecondi di attivazione della pompa) di colorante necessarie per colorare 100 grammi di vernice bianca.
In realta’ le proporzioni tra le dosi, riportate nella sottostante tabella, dovrebbero in teoria restare invariate, per cui, una volta trovato il tempo necessario per saturare di blu oppure di rosso oppure di giallo 100 grammi di vernice bianca, i valori in tabella tabcodici possono facilmente essere ricalcolati.
Il filmato di questo progetto e’ reperibile qui: https://youtu.be/l2l0bmyMW14
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
Tabella di miscelazione dei colori
Colore desiderato
Dose per 100 grammi di vernice bianca (millisecondi di funzionamento di ogni pompa)
rosso blu giallo
rosso 1200 0 0
blu 1200
giallo 0 0 1200
verde 0 600 1200
viola chiaro 300 600 300
oliva 600 600
rosa 600 0 0
azzurro 600
arancio 300 0 900
marrone 600 300 1200
viola intenso 1200 600 600
ambra 300 0 1800
Tabella degli oggetti Nextion utilizzati da Arduino
obj tipo Pagina Numero ID note
bo bottone 0 3 Pulsante rosso
b1 bottone 0 4 Pulsante blu
b2 bottone 0 5 Pulsante giallo
b3 bottone 0 6 Pulsante verde
b4 bottone 0 7 Pulsante viola chiaro
b5 bottone 0 8 Pulsante oliva
b6 bottone 0 9 Pulsante rosa
b7 bottone 0 10 Pulsante azzurro
b8 bottone 0 11 Pulsante arancione
b9 bottone 0 12 Pulsante marrone
b10 bottone 0 13 Pulsante viola intenso
b11 bottone 0 14 Pulsante ambra
t4 testo 1 3 Peso in grammi
b12 bottone 1 4 Pulsante avanti
tr testo 2 5 Millisecondi pompa rosso
tb testo 2 6 Millisecondi pompa blu
tg testo 2 7 Millisecondi pompa giallo
Note costruttive
Le indicazioni riguardanti la costruzione della bilancia e la programmazione del display touchscreen, sono presenti nelle schede:
41 bilancia digitale: http://giocarduino.altervista.org/e41-sensore-di-peso-bilancia-digitale.pdf
56 display Nextion: http://giocarduino.altervista.org/e56-display-nextion.pdf Nella scheda del progetto 41 sono presenti sia il programma che le indicazioni per il calcolo del valore di scala, specifico di ogni sensore. Questo valore, una volta calcolato, deve essere poi inserito nel programma prima della sua compilazione (vedi nel programma, nella zona di setup, l’istruzione contrassegnata dal commento “--------“).
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
Una volta calcolato il valore di scala e’ normalmente necessario procedere ad un lavoro di calibratura fine, sperimentando diversi valori (di poco maggiori o inferiori al valore calcolato) fino a quando la bilancia non arriva ad esporre, con precisione, il peso di un campione di riferimento.
Prima di procedere alla compilazione del programma e’ necessario, se non gia’ fatto, installare le seguenti librerie:
HX711, liberamente scaricabile da qui: https://github.com/bogde/HX711
Libreria del Nextion: Nextion library for Arduino – ITEADLIB_Arduino_Nextion Per installare una libreria:
scaricare la libreria
lanciare l’IDE e andare in sketch->include library->add.zip library
selezionare la libreria appena scaricata (dovrebbe essere c:/utenti/nome del tuo account/download) e premere “apri”
verificare che la libreria sia presente nel repository delle librerie (sketch->include library) e quindi chiudere e riaprire l’IDE per rendere operativa la nuova libreria (l’apertura e la chiusura dell’IDE sono necessarie solo per chi sta utilizzando una vecchia IDE).
In particolare, per installare la libreria del Nextion, si devono scrupolosamente seguire le indicazioni presenti nella scheda dell’esercizio 56, il cui link e’ riportato piu’ sopra.
Here some notes about this project, translated by google translator In this system Arduino manages coloring of a white paint in a color chosen by operator through a touchscreen display. Coloring is carried out by means of three peristaltic pumps having a flow rate of 50 milliliters per minute, which draw from bottles containing the basic colors: blue, red and yellow. Arduino activates each pump for a time (in milliseconds) calculated according to the desired color and varnish weight to be colored. From an operational point of view, the operator must:
Place an empty container on the weighing pan, in order to calculate the tare (only once, when the system is activated);
Place the container with varnish to be colored on plate
Select, on display, the desired color (see above figure 1)
Press the "avanti" button (see above figure 2) At this point, Arduino calculates the operating milliseconds for each of the three pumps and activates relays, which in turn activate pumps, for the mentioned time. Since the dyeing capacity of dyes, pumps flow and characteristics of varnish are different depending on dyes, pumps and types of varnish, if you intend to replicate this project it will be necessary to redefine (and insert in program) the doses dye (in terms of pump activation milliseconds) necessary to color 100 grams of white paint. In reality the proportions between doses, shown in below table, should in theory remain unchanged so, once the dose needed to saturate in blue or red or yellow 100 grams of white paint has been found, the values can easily be recalculated and inserted in program array: tabcodici
Here the project movie: https://youtu.be/l2l0bmyMW14
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
Color mixing table
Desired color Dose per 100 grams of white paint (operational milliseconds of each pump)
red blue yellow
red 1200 0 0
blue 0 1200 0
yellov 0 0 1200
green 0 600 1200
Ligt purple 300 600 300
Dark green 0 600 600
pink 600 0 0
Light blue 0 600 0
orange 300 0 900
brown 600 300 1200
Intense purple 1200 600 600
amber 300 0 1800
Nextion objects used by Arduino
obj type Page # ID note
bo button 0 3 red
b1 button 0 4 blue
b2 button 0 5 yellow
b3 button 0 6 green
b4 button 0 7 light purple
b5 button 0 8 dark green
b6 button 0 9 pink
b7 button 0 10 Light blue
b8 button 0 11 orange
b9 button 0 12 brown
b10 button 0 13 Intense purple
b11 button 0 14 amber
t4 text 1 3 Weight in grams
b12 button 1 4 Avanti (next page)
tr text 2 5 Milliseconds red pump
tb text 2 6 Milliseconds blue pump
tg text 2 7 Milliseconds yellow pump
Constructive notes Indications concerning construction of the scale and the touchscreen display programming, are present in files:
41 digital scale: http://giocarduino.altervista.org/e41-sensore-di-peso-bilancia-digitale.pdf
56 Nextion display: http://giocarduino.altervista.org/e56-display-nextion.pdf In project 41 tab there are both program and indications for calculating the scale value, specific to each sensor. This value, once calculated, must then be inserted into program (see in program, in the setup area, instruction marked with comment "< --------").
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
Once the scale value has been calculated, it is normally necessary to carry out a fine calibration work, experimenting with different values (slightly higher or lower than the calculated value) until the scale shows the weight of a sample accurately. Before proceeding to program compilation must be installed, if not already done, the libraries:
HX711, free from: https://github.com/bogde/HX711
Nextion library, free from: Nextion library for Arduino – ITEADLIB_Arduino_Nextion For library installation, see process shown in previous projects, and summarized in:
library download in compressed form;
Installation via IDE-> sketch-> includes Library-> add .zip library
After installation please verify the library. It must be present in IDE-> sketch-> includes Library-> Contributed library
In particular, to install the Nextion library, you must carefully follow instructions in the project card 56, whose link is reported above. Note: This project and this note is part of a series that sees, as main characters, Arduino and some of connectable components. For most projects there is also a video on youtube.
Projects collection
Movies on youtube
About Arduino and components (italian; pdf will be downloaded in your download area
Quick programming guide (almost english; pdf will be downloaded in your download area) For any questions or suggestions about this note (and on its english translation), please write to [email protected] (simple words and short sentences, please)
Materiali Una scheda Arduino Uno R3
Un sensore di peso e relativo driver HX711
tre rele’ da 5 volt
tre pompe peristaltiche, con una portata di 50 millilitri al minuto
Un po’ di cavetti
Un alimentatore da 5 volt, per alimentare Arduino ed il Nextion. Con il Nextion viene fornito un connettore USB che, collegato ad un alimentatore, puo’ alimentare sia il Nextion che Arduino
Un alimentatore da 6 volt, per alimentare le pompe peristaltiche
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
Schema
Programma /*
Attenzione: facendo il copia/incolla dal PDF all’IDE si perde la formattazione del testo. Per
rendere piu’ facilmente leggibile il programma e’ opportuno formattarlo subito dopo il
trasferimento nell’IDE, premendo CTRL+T.
Utilizzo di un sensore di peso, di un display touchscreen e di tre rele' per attivare
tre pompe persitaltiche che attingono ai colori base, al fine di colorare una vernice bianca
Prima di compilare il programma scaricare ed installare, se non gia' fatto, le seguenti librerie:
. gestione del driver XH711: https://github.com/bogde/HX711
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
. libreria del nextion: https://github.com/itead/ITEADLIB_Arduino_Nextion/archive/master.zip
Attenzione: la libreria del nextion deve essere modificata. Seguire scrupolosamente le note
presenti nella scheda Nextion: http://giocarduino.altervista.org/e56-display-nextion.pdf
connessioni del modulo H711:
Hx711.DO - porta #A1
Hx711.SCK - porta #A0
connessioni del sensore di peso:
rosso = E+
nero = E-
bianco = A-
verde = A+
connessioni del display nextion
rx = porta 1 (tx)
tx = porta 0 (rx)
connessioni altri componenti:
rele' giallo = porta 11
rele' blu = porta 12
rele' rosso = porta 13
Tabella degli oggetti nextion utilizzati da Arduino
obj tipo Pag #ID note
bo bottone 0 3 Pulsante rosso
b1 bottone 0 4 Pulsante blu
b2 bottone 0 5 Pulsante giallo
b3 bottone 0 6 Pulsante verde
b4 bottone 0 7 Pulsante viola chiaro
b5 bottone 0 8 Pulsante oliva
b6 bottone 0 9 Pulsante rosa
b7 bottone 0 10 Pulsante azzurro
b8 bottone 0 11 Pulsante arancione
b9 bottone 0 12 Pulsante marrone
b10 bottone 0 13 Pulsante viola intenso
b11 bottone 0 14 Pulsante ambra
t4 testo 1 3 Peso in grammi
b12 bottone 1 4 Pulsante avanti
tr testo 2 5 Millisecondi pompa rosso
tb testo 2 6 Millisecondi pompa blu
tg testo 2 7 Millisecondi pompa giallo
------------------------------------------------------------------------------------------------
Warning: cut&paste from PDF to IDE loses formatting. To restore it press CTRL + T.
Use a load cell, a touchscreen display and three relays to activate three peristaltic pumps
in order to color a white pain. Before compiling, download and install, if not already done, the
following libraries:
. XH711 driver management: https://github.com/bogde/HX711
. nextion library: https://github.com/itead/ITEADLIB_Arduino_Nextion/archive/master.zip
Warning the nextion library must be modified. Follow carefully notes in Nextion tab, available
here: http: //giocarduino.altervista.org/e56-display-nextion.pdf
H711 connections:
Hx711.DO - pin #A1
Hx711.SCK - pin #A0
load cell connection:
red = E+
black = E-
white = A-
green = A+
nextion connections:
rx = pin 1 (tx)
tx = pin 0 (rx)
rele' connections:
yellow rele' = pin 11
blu rele' = pin 12
red rele' = pin 13
Nextion objects used by Arduino:
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
obj tipo Pag #ID note
bo button 0 3 red
b1 button 0 4 blue
b2 button 0 5 yellow
b3 button 0 6 green
b4 button 0 7 light purple
b5 button 0 8 olive green
b6 button 0 9 pink
b7 button 0 10 light blue
b8 button 0 11 orange
b9 button 0 12 brown
b10 button 0 13 intense purple
b11 button 0 14 amber
t4 text 1 3 weight in grams
b12 button 1 4 "avanti" (next page)
tr text 2 5 Milliseconds red pump
tb text 2 6 Milliseconds blue pump
tg text 2 7 Milliseconds yellow pump
*/
#include "Nextion.h"
#include "HX711.h"
#define relerosso 13
#define releblu 12
#define relegiallo 11
#define DOUT A1
#define CLK A0
HX711 bilancia(DOUT, CLK);
//
int peso = 0; // zona di memorizzazione del peso corrente - curren weight
long tempoinizio = 0; // momento di inizio attivazione pompa - pump starting time
long tempocorrente = 0; // momento di riempimento - filling time
long tempounitario = 0; // tempo di attivazione di una pompa - pump time activation
int indcod = 0; // codice del colore - color code
int tcblu = 0; // tempo attivazione pompa rosso - red pum timing
int tcrosso = 0; // tempo attivazione pompa blu - blue pump timing
int tcgiallo = 0; // tempo attivazione pompa giallo - yellow pump timing
char st4 [5] = {0}; // stringa in cui inserire il peso in grammi, max 9999 - weight (string)
char str [6] = {0}; // stringa tempo attivazione della pompa rosso - Time red pump (string)
char stb [6] = {0}; // stringa tempo attivazione della pompa blu - time blue pump (string)
char stg [6] = {0}; // stringa tempo attivazione della pompa giallo- time yellow pum (string)
int tabcodici [61] = // tabella dei codici di colore e dei millisecondi (max 9999) di
// attivazione di ogni rele' per 100 grammi di vernice da colorare- Inserire i codici ed i
// millesimi di secondo per ogni rele', mantenendo inalterato il numero di rige (15) e di virgole
// (60) - colors array and milliseconds (max 9999) of activation of each relay for 100 grams of
// paint to be colored. Modify codes and milliseconds for each relay, keeping unchanged the number
// of lines (15) and commas (60)
{
//cod, rele1, rele2, rele3,
0, 1200, 0, 0, // <- rosso
1, 0, 1200, 0, // <- blu
2, 0, 0, 1200, // <- giallo
3, 0, 600, 1200, // <- verde
4, 300, 600, 300, // <- viola chiaro
5, 0, 600, 600, // <- oliva
6, 600, 0, 0, // <- rosa
7, 0, 600, 0, // <- azzurro
8, 300, 0, 900, // <- arancione
9, 600, 300, 1200, // <- marrone
10, 1200, 600, 600, // <- viola intenso
11, 300, 0, 1800, // <- ambra
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
};
//
// dichiarazione degli oggetti nextion che interagiscono con Arduino; tra parentesi
// il numero di pagina, il numero ID e tra apici il nome dell'oggetto in Nextion
// Nextion objects that interact with Arduino; in brackets
// page number, ID number and object name
NexButton b0 = NexButton (0, 3, "b0"); // pulsante rosso – red button
NexButton b1 = NexButton (0, 4, "b1"); // pulsante blu –blue button
NexButton b2 = NexButton (0, 5, "b2"); // pulsante giallo – yellow button
NexButton b3 = NexButton (0, 6, "b3"); // pulsante verde – green button
NexButton b4 = NexButton (0, 7, "b4"); // pulsante viola chiaro – light purple button
NexButton b5 = NexButton (0, 8, "b5"); // pulsante oliva – dark green button
NexButton b6 = NexButton (0, 9, "b6"); // pulsante rosa – pink button
NexButton b7 = NexButton (0, 10, "b7"); // pulsante azzurro – light blue button
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
NexButton b8 = NexButton (0, 11, "b8"); // pulsante arancione – orange button
NexButton b9 = NexButton (0, 12, "b9"); // pulsante marrone - brown button
NexButton b10 = NexButton (0, 13, "b10"); // pulsante viola intenso – intende purple button
NexButton b11 = NexButton (0, 14, "b11"); // pulsante ambra – amber button
NexText t4 = NexText (1, 3, "t4"); // peso in grammi . weight in grams
NexButton b12 = NexButton (1, 4, "b12"); // pulsante "avanti"
NexText tr = NexText (2, 5, "tr"); // tempo pompa rosso - time red pump
NexText tb = NexText (2, 6, "tb"); // tempo pompa blu – time ble pump
NexText tg = NexText (2, 7, "tg"); // tempo pompa giallo – time yellow pump
//
// lista degli oggetti touch - touch object list
NexTouch *nex_listen_list[] =
{
&b0,
&b1,
&b2,
&b3,
&b4,
&b5,
&b6,
&b7,
&b8,
&b9,
&b10,
&b11,
&b12,
NULL
};
//
// routine attivata nel momento in cui viene rilasciato il bottone "b0" - rosso.
// ************************ b0 button routine *******************
void rosso(void *ptr)
{
indcod = 0;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b1" blu.
// ************************ b1 button routine *******************
void blu (void *ptr)
{
indcod = 1;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b2" giallo.
// ************************ b2 button routine *******************
void giallo (void *ptr)
{
indcod = 2;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b3" verde.
// ************************ b3 button routine *******************
void verde(void *ptr)
{
indcod = 3;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b4" viola chiaro.
// ************************ b4 button routine *******************
void violachiaro (void *ptr)
{
indcod = 4;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b5" oliva.
// ************************ b5 button routine *******************
void oliva(void *ptr)
{
indcod = 5;
pesatura ();
}
//
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
// routine attivata nel momento in cui viene rilasciato il bottone "b6" rosa.
// ************************ b6 button routine *******************
void rosa(void *ptr)
{
indcod = 6;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b7" azzurro.
// ************************ b7 button routine *******************
void azzurro (void *ptr)
{
indcod = 7;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b8" arancione.
// ************************ b8 button routine *******************
void arancione (void *ptr)
{
indcod = 8;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b9" marrone.
// ************************ b9 button routine *******************
void marrone(void *ptr)
{
indcod = 9;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b10" viola intenso.
// ************************ b10 button routine *******************
void violaintenso (void *ptr)
{
indcod = 10;
pesatura ();
}
//
// routine attivata nel momento in cui viene rilasciato il bottone "b11" ambra.
// ************************ b11 button routine *******************
void ambra(void *ptr)
{
indcod = 11;
pesatura ();
}
//
// routine erogazione colore, attivata con il bottone "b12" avanti.
// ************* b12 button routine - color dispensing ***********
//
void avanti(void *ptr)
{
if (peso > 5) // se il piatto e' pieno (piu' di 5 grammi)- if more than 5 grams of varnish
{
//
//******* calcola ed espone i tempi di attivazione delle pompe *********************
// ************ compute time for each pump *************************************
//
tempounitario = tabcodici [indcod * 4 + 1];
tcrosso = (peso * tempounitario) / 100; // tempo erogazione rosso - red dispensing time
tempounitario = tabcodici [indcod * 4 + 2];
tcblu = (peso * tempounitario) / 100; // tempo erogazione bu - blue dispensing time
tempounitario = tabcodici [indcod * 4 + 3];
tcgiallo = (peso * tempounitario) / 100;// tempo erogazione giallo - yellow dispensing time
sprintf(str, " % d", tcrosso); // conversione numero -> stringa - integer to string conversion
tr.setText(str); // aggiorna il campo "tr" del nextion - send data to nextion
sprintf(stb, " % d", tcblu);
tb.setText(stb);
sprintf(stg, " % d", tcgiallo);
tg.setText(stg);
//
// ************ attivazione pompa rosso **********************
// ***************red pump activation ************************
tempoinizio = millis();
digitalWrite (relerosso , HIGH);
tempocorrente = millis ();
// Arduino: colorazione vernici – varnish coloring // sensore di peso, load cell, peristaltica, peristaltic, HX711, nextion
while (tcrosso > (tempocorrente - tempoinizio))
{
tempocorrente = millis ();
}
digitalWrite (relerosso , LOW);
//
// ************ attivazione pompa blu **********************
// ***************blue pump activation *********************
tempoinizio = millis();
digitalWrite (releblu , HIGH);
tempocorrente = millis ();
while (tcblu > (tempocorrente - tempoinizio))
{
tempocorrente = millis ();
}
digitalWrite (releblu , LOW);
//
// ************ attivazione pompa giallo **********************
// ************** yellow pump activation **********************
tempoinizio = millis();
digitalWrite (relegiallo , HIGH);
tempocorrente = millis ();
while (tcgiallo > (tempocorrente - tempoinizio))
{
tempocorrente = millis ();
}
digitalWrite (relegiallo , LOW);
}
}
//
// ************* routine di pesatura ****************
// **************** weighing routine ****************
void pesatura (void)
{
{
peso = bilancia.get_units(10), 1; // rileva il peso sul piatto
sprintf(st4, "%d", peso); // conversione da numero a stringa - integer to string conversion
t4.setText(st4); // invia i dati al nextion - send data to Nextion
}
}
//
//
void setup(void)
{
Serial.begin(9600);
nexInit();
// registrazione delle routines da attivate al verificarsi di un evento
b0.attachPop(rosso, &b0); // attiva routine "rosso" quando premuto il bottone rosso
b1.attachPop(blu, &b1); // attiva routine "blu"quando premuto il bottone blu
b2.attachPop(giallo, &b2); // attiva routine "giallo" premuto il bottone giallo
b3.attachPop(verde, &b3); // attiva routine "verde" premuto il bottone verde
b4.attachPop(violachiaro, &b4); // attiva routine "violachiaro" se premuto il viola chiaro
b5.attachPop(oliva, &b5); // attiva routine "oliva" quando premuto il bottone oliva
b6.attachPop(rosa, &b6); // attiva routine "rosa" premuto il bottone rosa
b7.attachPop(azzurro, &b7); // attiva routine "azzurro" premuto il bottone azzurro
b8.attachPop(arancione, &b8); // attiva routine "arancione" premuto il bottone arancione
b9.attachPop(marrone, &b9); // attiva routine "marrone" premuto il bottone marrone
b10.attachPop(violaintenso, &b10); // attiva routine "violaintenso" se premuto viola intenso
b11.attachPop(ambra, &b11); // attiva routine "ambra" quando premuto il bottone ambra
b12.attachPop(avanti, &b12); // attiva routine "avanti" quando premuto il bottone avanti
pinMode(relerosso, OUTPUT);
pinMode(releblu, OUTPUT);
pinMode(relegiallo, OUTPUT);
bilancia.set_scale(1680); // <----- dettagli presenti nella scheda del progetto 41:
// http://giocarduino.altervista.org/e41-sensore-di-peso-bilancia-digitale.pdf
bilancia.tare(20); // il peso iniziale e' considerato tara
}
//
//
void loop(void)
{
nexLoop(nex_listen_list); // lancia le routine di gestione delle azioni attivate dal nextion
}