// 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 giocarduino@libero.it (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

}