AutoBalance

SelfBalancing of a twowheeled robot

Luca Moschella
V A ITI

INDICE
1.Introduzione .................................................................................................................................................. 3
2.Componenti Hardware del sistema ............................................................................................................... 3
2.1 Piattaforma Hardware Arduino UNO ...................................................................................................... 3
2.1.1 Arduino UNO ................................................................................................................................... 4
2.1.2 Alimentazione.................................................................................................................................. 5
2.1.3 Memoria .......................................................................................................................................... 5
2.1.4 Input e Output ................................................................................................................................. 5
2.1.5 Comunicazione ................................................................................................................................ 6
2.1.6 Programmazione ............................................................................................................................. 7
2.1.7 Protezione USB da sovracorrente .................................................................................................... 7
2.1.8 Caratteristiche fisiche ...................................................................................................................... 7
2.2 Struttura ................................................................................................................................................. 8
2.2.1 Dimensionamento della struttura ................................................................................................... 8
2.2.2 Realizzazione della struttura .......................................................................................................... 10
2.3 Driver Motore ....................................................................................................................................... 11
2.3.1 Schema elettrico ............................................................................................................................ 12
2.3.2 Funzionamento Driver Motore ...................................................................................................... 13
2.4 Amplificatore Differenziale ................................................................................................................... 14
2.4.1 Schema elettrico ............................................................................................................................ 14
2.4.2 Dimensionamento Amplificatore Differenziale ............................................................................. 15
2.4.3 Funzionamento di VShift .................................................................................................................. 18
2.5 Sensori a Infrarossi (IR) ......................................................................................................................... 20
2.6 Attuatori ............................................................................................................................................... 21
2.7 Altri componenti ................................................................................................................................... 22
2.8 Rendering del sistema fisico in esame .................................................................................................. 22
3.Algoritmo di Controllo ................................................................................................................................. 23
3.1 Controllo PID ........................................................................................................................................ 23
3.2 Diagramma di flusso ............................................................................................................................. 24
3.3 Sketch ................................................................................................................................................... 25

1.Introduzione
In questo progetto stato realizzato un robot a due ruote in grado
di mantenersi in equilibrio.
Lobiettivo quello di bilanciare il robot con un controllo software PID.

2.Componenti Hardware del sistema

In questa sezione, come da titolo, verranno analizzati i componenti
hardware utilizzati per realizzare il sistema AutoBalance.

2.1 Piattaforma Hardware Arduino UNO

Arduino un sistema open-source di prototipazione elettronica
basato su una piattaforma flessibile, con hardware e software facili da
usare. destinato ad artisti, designer, hobbisti e a chiunque sia
interessato a creare oggetti o ambienti interattivi. Arduino pu percepire
l'ambiente, ricevere input da una variet di sensori e pu influenzare
l'ambiente circostante con luci ed attuatori.
Il microcontrollore della scheda programmato usando il linguaggio di
programmazione Arduino e l'ambiente di sviluppo Arduino.
I progetti di Arduino possono essere stand-alone o comunicare con il
software in esecuzione su un computer (ad esempio Flash, Processing,
MaxMSP). Le board possono essere costruite a mano o acquistate gi
preassemblate e il software pu essere scaricato gratuitamente.
I riferimenti di progetti hardware (i file CAD) sono disponibili sotto una
licenza open-source e liberi di adattarli alle proprie esigenze. Arduino ha
ricevuto una Menzione d'Onore nella Comunit sezione digitale del Prix
Ars Electronica 2006.

2.1.1 Arduino UNO

Il cervello del sistema di controllo senza dubbio il
microcontrollore, capace di ricevere segnali in ingresso provenienti da
sensori, elaborarli e trasmettere il giusto comando all'attuatore, nel
nostro caso ai due motoriduttori.
Nella realizzazione del robot si fatto uso della piattaforma ARDUINO,
precedentemente descritta, che implementa il linguaggio Process/Wiring.
Pi nello specifico stata scelta la versione UNO, illustrata nella figura
seguente, dotata di un microcontrollore ATMega-328.

La scheda Arduino UNO contiene tutto il necessario per sostenere il

microcontrollore ed sufficiente connettersi a un computer con un cavo
USB, ad un alimentatore o ad una batteria, per iniziare la trasmissione.

2.1.2 Alimentazione
Arduino UNO pu essere alimentato attraverso la connessione USB
o con un alimentatore esterno. Il consiglio dato dal manuale quello di
farlo operare con un alimentatore esterno da 6V a 20V. Il pin 5V pu
fornire meno di 5V e di conseguenza la scheda potrebbe risultare
instabile. Se invece si utilizzano pi di 12V, il regolatore di tensione
potrebbe surriscaldarsi e danneggiare la scheda. L'intervallo consigliato
7-12V.
I pin di alimentazione sono i seguenti:
- VIN. Il pin con cui possibile alimentare la scheda Arduino con una
tensione superiore ai 5V. possibile fornire tensione attraverso
connessione USB o un'altra fonte di alimentazione regolata in
tensione. collegato direttamente al Jack di alimentazione;
- 5V. Il Pin di alimentazione regolata, utilizzata per alimentare il
microcontrollore e gli altri componenti sulla scheda. La tensione di
5V pu essere ricavata dal pin VIN tramite un regolatore a bordo o
essere fornita tramite USB o un altro 5V controllato;
- 3V3. generata dal board su chip FTDI e ha un assorbimento di
corrente massimo pari a 50mA;
- GND. Ground pin;
2.1.3 Memoria
L'Atmega-328 ha 32 KB, di cui 2KB utilizzati per il bootloader, 2KB di
SRAM e 1KB di EEPROM.
2.1.4 Input e Output
Ciascuno dei 14 pin digitali sull'Arduino UNO pu essere usato come
input o output, utilizzando funzioni attraverso il software specifico
(pinMode(),digitalWrite() e digitalRead() ). I pin operano a 5V e ognuno di
questi pu fornire o ricevere un massimo di 40mA; presentano una
5

resistenza di pull-up interna di 20- 50KW e inoltre alcuni pin hanno

funzioni specifiche:
- Pin: 0(RX) e 1(TX). Sono utilizzati per ricevere e trasmettere dati
seriali in formato TTL. Sono collegati ai pin 0 (RX) e 1 (TX)
corrispondenti della serie FTDI USB-to-chip TTL;
- Interrupt esterni: 2 e 3. Questi pin possono essere configurati per
attivare un interrupt, sia su un valore basso di salita o di discesa, sia
su una variazione del valore di ingresso;
- PWM: (pin 3, 5, 6, 9, 10 e 11). Sono pin utilizzati come uscite PWM;
- LED: (pin 13). Quando il valore del pin alto il LED corrispondente
acceso, viceversa, spento;
- Reset. un pin che permette di resettare il microcontrollore. La
stessa funzione di reset risulta possibile anche attraverso un
pulsante situato sulla scheda;
Inoltre Arduino UNO dispone di 6 ingressi analogici, ciascuno dei quali
fornisce 10 bit di risoluzione (ossia 1024 diversi valori).
2.1.5 Comunicazione
L' Arduino UNO ha un certo numero di strutture per la
comunicazione con un computer, con un altro Arduino o con altri
microcontrollori.
L'Atmega-328 fornisce una comunicazione seriale UART TTL (5V) che
disponibile sui pin digitali 0 (RX) e 1 (TX). Il software predisposto alla
comunicazione include un monitor Arduino seriale che consente di inviare
alla scheda Arduino semplici dati testuali. I led RX e TX sulla scheda
lampeggiano quando i dati vengono trasmessi sia tramite il chip FTDI, sia
tramite una connessione USB con il computer; ci non accade per la
comunicazione seriale. L'Atmega-328 dispone anche di un supporto I2C
(TWI) e di una comunicazione SPI. Il software include una libreria Arduino
Wire per semplificare l'utilizzo del I2C bus.
6

2.1.6 Programmazione
La scheda UNO pu essere programmata con il software Arduino.
L'Atmega-328 su Arduino UNO viene pre-caricato con un bootloader che
permette di caricare il nuovo codice senza l'uso di un programmatore
hardware esterno.
La comunicazione con la scheda avviene utilizzando l'originale protocollo
STK500 che ha come riferimento i file di intestazione C.
2.1.7 Protezione USB da sovracorrente
L'Arduino UNO ha un polyfuse azzerabile (componente di memoria
tempo-programmabile usato in circuiti a semiconduttori per la
memorizzazione dei dati unici), che protegge le porte USB del computer
da cortocircuiti e sovracorrenti.
Sebbene la maggior parte dei computer fornisce una propria protezione
interna, il fusibile fornisce un ulteriore livello di protezione. Se pi di
500mA vengono applicati alla porta USB, il fusibile automaticamente
interrompe la connessione fino a quando il corto o sovraccarico viene
rimosso.
2.1.8 Caratteristiche fisiche
La lunghezza e la larghezza massima del PCB UNO sono 2,7 * 2:1
pollici, con il connettore USB e il jack di alimentazione che fuoriescono, si
estende oltre la dimensione precedente. Tre fori per le viti consentono
alla scheda di essere fissata su di una superficie.

2.2 Struttura
stato deciso di sviluppare il sistema su tre piani, suddividendo i
componenti Hardware su ogni piano in questo modo:
- Primo piano: Attuatori, Batteria;
- Secondo piano: Driver Motore, Amplificatore Differenziale, Switch;
- Terzo piano: Sensori Sharp IR, Arduino;
Particolare importanza ha la posizione dei sensori.
2.2.1 Dimensionamento della struttura
Per capire dove posizionare i sensori, in modo tale che per un dato
spostamento angolare si abbia una variazione della distanza rilevata dai
sensori apprezzabile, sono necessari alcuni semplici calcoli.
Esaminiamo una circonferenza non goniometrica, quindi non di raggio
unitario:
noto che il seno il rapporto
fra la proiezione sullasse Y di un
punto generico A, individuato
sulla circonferenza, e il raggio
della stessa circonferenza.
Mentre il coseno il rapporto fra
la proiezione sullasse X di un
punto generico A, individuato
sulla circonferenza, e il raggio
della stessa circonferenza.
Si pu, quindi, dire che in una circonferenza generica:

Il

sistema

AutoBalance

pu

essere

cos

semplificato:

Quindi si pu dire che:

Ragionando in variazioni, e non in valori assoluti, la formula diventa:

Ora dobbiamo decidere di quanto deve variare AB per ogni variazione

dellangolo . Ipotizziamo che per ogni variazione angolare di 1, CB vari
di 3 mm, valore molto superiore alla risoluzione del sensore, in modo tale
da essere rilevato agevolmente.
Siamo ora in grado di calcolarci AO:

Una volta noto AO semplice calcolare laltezza ed il braccio necessari al

sistema. Imponendo laltezza siamo in grado di calcolare il braccio:

stato cos calcolato il braccio del sistema, cio la minima distanza alla
quale devono essere posizionati i sensori rispetto lasse delle ruote.
9

2.2.2 Realizzazione della struttura

Per costruire il robot stato realizzato prima il modello 3D,
attraverso il software SolidWorks.
Sono stati, quindi, realizzati i modelli 3D di ogni componente del sistema.
In seguito stata disegnata la struttura vera e propria e ogni componente
stato assemblato virtualmente.
In questo modo siamo riusciti a verificare la fattibilit del progetto,
identificando interferenze o eventuali problemi, altrimenti difficilmente
notabili.
Una volta realizzato il modello completo del robot, sono stati ricavati i
disegni meccanici dei vari piani, esportando le proiezioni 2D dei modelli in
un formato universale.
Questi disegni meccanici sono stati poi utilizzati, con una macchina a
controllo numerico ( CNC ), per tagliare lalluminio, ricavando lesatta
forma precedentemente disegnata al computer.
I piani, tagliati e levigati, sono stati poi verniciati.

10

2.3 Driver Motore

Si scelto di usare motori DC come attuatori, per questo si reso

necessario lutilizzo di un driver motore.
Il driver motore stato realizzato in modo tale da poter essere utilizzato
in diverse applicazioni, per questo stato progettato in modo tale da
poter comandare fino a 4 motori DC, esso utilizza, perci, due driver
SN75440. In questo utilizzo, comunque, vengono usati solo 2 motori.
Lo schema elettrico del driver motore stato realizzato al computer,
attraverso il software open-source Eagle, attraverso esso stato fatto
anche lo sbroglio e la stampa su basetta di rame.

11

2.3.1 Schema elettrico

12

2.3.2 Funzionamento Driver Motore

Il driver utilizzato lSN75440, un driver motore molto versatile
che non necessita di unaletta di raffreddamento.
Questo integrato pu gestire fino a due motori, erogando una corrente
massima di 1A per motore.
Lalimentazione dei motori pu variare dai 4,5V ai 36V, mentre
lalimentazione della parte logica di 5V.
Nel nostro utilizzo necessario anche il controllo della velocit dei
motori, non solo del loro senso di rotazione. Per questo si reso
necessario un circuito leggermente pi complesso.
Il metodo pi efficiente per regolare la velocit di un motore DC,
attraverso un driver SN75440, quello di comandare il motore con due
segnali complementari. Si possono ottenere due segnali complementari
con il semplice utilizzo di due porte logiche NOT in serie, prelevando il
segnale alluscita di ogni porta NOT.
In questo modo si riesce a comandare un motore con un singolo segnale
PWM, in questo modo:
- PWM 0%: i motori muovono alla massima velocit indietro;
- PWM 100%: i motori muovono alla massima velocit avanti;
- PWM 50%: i motori sono fermi;
Ogni valore intermedio modula la velocit di rotazione.
Nel driver motore sono state inserite delle pull-up interne sui segnali di
ENABLE per evitare collegamenti esterni.
Sono presenti inoltre dei diodi Fast, i BYV27-50, per proteggere lintegrato
dalle extratensioni generate dai motori e due condensatori utilizzati per
stabilizzare le tensioni dingresso.
13

2.4 Amplificatore Differenziale

Si scelto di acquisire le distanze rilevate dai sensori tramite un

amplificatore differenziale. Tale amplificatore ha in ingresso la tensione di
uscita dei due sensori, effettua la differenza ed amplifica tale valore fra
0V e 5V.
In questo modo si riesce ad avere una maggiore risoluzione, considerando
che i 10bit dell ADC di Arduino vengono usati esclusivamente per leggere
lerrore, e non per leggere le distanze misurate dai sensori per poi
effettuare la differenza fra le due misure.
2.4.1 Schema elettrico

14

2.4.2 Dimensionamento Amplificatore Differenziale

stato utilizzato un circuito simile allamplificatore per
strumentazione, dove per lo zero non a massa ma ad una tensione di
riferimento VShift.
Questo circuito composto da tre amplificatore operazionali, dove i primi
due acquisiscono gli ingressi ed il terzo effettua la differenza, dando in
uscita un singolo segnale.
La funzione di trasferimento del circuito vale:

Sono note inoltre le uscite dei sensori e il comportamento voluto dal

sistema.
Si impone la massima inclinazione del robot a 3cm, quindi nellistante in
cui il robot inclinato 3cm in avanti, con una differenza fra le due
distanze rilevate di 6cm, si devono avere 5V in uscita. Quando inclinato
3 cm indietro si devono avere 0V. Mentre quando in equilibro, cio le
due distanze sono uguali, si deve avere VShift in uscita.
Il funzionamento pu quindi essere cos rappresentato:

15

Da questo possiamo ricavare tre condizioni del sistema che devono essere
rispettate, le seguenti:
1)

2)

3)

16

Definite le condizioni si pu quindi impostare il sistema, prendendo come

riferimento la funzione di trasferimento:

Come si pu facilmente notare, dalla seconda equazione risulta:

Quindi, il sistema si modifica in questo modo:

Si noti come le due equazioni siano riconducibili alla stessa espressione:

Si ha quindi un equazione a 4 incognite, in cui 3 incognite vanno

necessariamente imposte.
Si impongono valori di resistenze commerciali, tali che la resistenza
dipendente sia facilmente ottenibile:

17

Si pu ora calcolare R2, isolandola nellequazione precedentemente

ottenuta:

Sostituiamo le resistenze precedentemente imposte ed otteniamo:

Lequazione:

quindi valida con i seguenti valori di resistenze:

2.4.3 Funzionamento di VShift
Con le resistenze dimensionate in questo modo, quindi,
lamplificatore ha una dinamica di 5V. Questa dinamica non per
centrata a massa, 0V, ma centrata su VShift.
Variando VShift si pu quindi traslare lintera dinamica e centrarla su 2,5V:

18

Il centro stato quindi traslato da 0V a 2,5V.

Mantenere VShift variabile, attraverso un trimmer multigiro, rende il
sistema molto pi dinamico.
Regolare lo zero logico attraverso un trimmer permette, infatti, di
bilanciare il differente guadagno dei sensori, leggeri errori di
bilanciamento del robot e lievi inclinazioni del piano di riferimento.
In questo modo si riesce a mantenere il robot, oltre che in equilibrio,
fermo nella sua posizione iniziale.

19

2.5 Sensori a Infrarossi (IR)

Su questo robot sono montati una coppia di sensori ad infrarossi (IR)

analogici del tipo Sharp GP2Y0A21YK0F.
Sono stati scelti questi sensori per il buon rapporto qualit/prezzo, in
quanto con soli 11 si riusciti ad avere un sensore molto preciso in un
range di misura (10-80 cm) che include ampiamente quello di interesse.
Questi sensori si comportano in modo abbastanza uniforme nella zona di
funzionamento, come si pu vedere dai seguenti grafici:

20

2.6 Attuatori

Per quanto riguarda gli attuatori, sono stati scelti due semplici
motoriduttori SBGM9.
Le caratteristiche che ci hanno portato a scegliere questi motoriduttori
sono le seguenti:
- Rapporto di riduzione 143:1;
- Dimensioni 70.2 x 30.4 x 22.6mm;
- Peso 32.6g;
Le caratteristiche principali di questi motoriduttori possono essere
riassunte nella seguente tabella:

Questi motori sono facilmente gestibili da Arduino tramite segnali PWM,

con lutilizzo del Driver Motore precedentemente descritto.
Questi motoriduttori sono stati in seguito assemblati con le apposite
ruote in plastica ABS dal raggio di 69mm.
21

2.7 Altri componenti

Oltre a quelli gi elencati, sono stati utilizzati anche altri
componenti, di seguito ne riportato lelenco:
- 1 Batteria da 8V (con relativo connettore): con essa si fornita
lalimentazione ai motori ed Arduino (che regola la tensione a 5V
per i componenti elettronici del sistema);
- Elementi vari per il fissaggio dei componenti;
- Cavi di collegamento;
- 1 Interruttore;

2.8 Rendering del sistema fisico in esame

Le immagini del robot inserite sono tutte rendering 3D:

22

3.Algoritmo di Controllo
3.1 Controllo PID
Questo tipo di regolatore prevede un controllo proporzionale
allerrore rispetto ad un riferimento, derivativo ed integrativo. Leffetto
del controllo proporzionale quello di contrastare lerrore, quello del
derivativo quello di anticipare la risposta del sistema, quello
dellintegrativo di annullare lerrore a regime.
Questo si traduce nel calcolare i coefficienti del regolatore in modo che il
sistema abbia una risposta adeguata allerrore rilevato.
La scelta dei coefficienti del regolatore, come spesso avviene in questi
casi, stata fatta per lo pi basandosi su basi sperimentali. Seguendo
questa strada si arrivati a determinare i seguenti coefficienti:
- Kp = 0,6;
- Ki = 7;
- Kd = 0,02;
Un ulteriore concetto da sottolineare la scelta dellalgoritmo realmente
implementato sul microcontrollore Arduino. Come si legge nella maggior
parte dei libri di controlli automatici la ritmica di funzionamento
dellalgoritmo a tempo costante. Al contrario, in questo progetto stata
adottata una tecnica leggermente diversa. Infatti, invece di avere un
tempo costante e scartare il tempo avanzato aspettando il prossimo
turno, stato semplicemente cronometrato il tempo necessario per ogni
loop e le azioni integrative e derivative sono state rese proporzionali a
questo intervallo di tempo. Quindi, con questa tecnica, se un'acquisizione
durata pi di un'altra, avr pi peso nella correzione generata dal
controllore.
Il sistema presenta, comunque, un carattere oscillante che non possibile
eliminare.
23

3.2 Diagramma di flusso

Di seguito riportato il diagramma di flusso che descrive il
funzionamento del programma implementato in Arduino:
Inizio

Definizione PIN
utilizzati

Dichiarazione e
inizializzazione
variabili utilizzate
Setup dei pin come
OUTPUT

Acquisizione
Errore

Eliminazione
delloffset

Calcolo e limitazione
del PID

Calcolo PWM e
Controllo attuatori
tramite PWM
Calcolo del tempo
impiegato per
effettuare il ciclo
Memorizzo Errore
attuale

24

3.3 Sketch
Il programma, chiamato Sketch, stato diviso in funzioni per
comodit.
stato suddiviso nelle seguenti funzioni:
- Main Program: programma principale dedicato alle definizioni, alle
dichiarazioni, al setup ed al loop;
- Controllo Motori: funzione dedicata alla generazioni del segnale
PWM ed al controllo dei motori;
- GetErrore: funzione dedicata allacquisizione dellerrore;
- GetPID: funzione dedicata al calcolo e alla limitazione del PID;
Lo Sketch il seguente:
Main Program:
// Software AutoBalance
// Il programma legge l'errore
// Attraverso un controllo PID muove le ruote in modo da correggere tale errore.
// Definizione dei pin di INPUT
#define input A0
l'amplificatore differenziale

// Definisce il pin a cui collegato

// Definizione dei pin utilizzati dai motori

#define motore 3
// Definisce il pin PWM a cui sono collegati i
motori
// Variabili per la gestione dell'Errore
float Errore = analogRead( input );
float previousErrore = 0;
precedente

// Inclinazione dell'AutoBalance
// Inclinazione dell'AutoBalance al ciclo

// Variabili temporali, per il calcolo del PID

float time = 0;
// Tempo auttuale, dall'accensione del
dispositivo
float previousTime = 0;
// Tempo del precedente ciclo
float interval = 0;
// Tempo impiegato per l'esecuzione di un
ciclo di programma
// Variabili PID
float P = 0;
float I = 0;
float D = 0;
float PID = 0;

//
//
//
//

// Guadagni dei coefficenti PID

float kP = 0.6;
float kI = 7;
float kD = 0.02;

// Coefficiente PROPORZIONALE del PID

// Coefficiente INTEGRATIVA del PID
// Coefficiente DERIVATIVA del PID

Variabile
Variabile
Variabile
Parametro

PROPORZIONALE del PID

INTEGRATIVA del PID
DERIVATIVA del PID
PID

25

void setup()
{
//Serial.begin( 9600 );
pinMode( motore, OUTPUT );
}
void loop()
{
/*
Serial.print( " Errore = " );
Serial.print( Errore );
Serial.print( " Intervallo = " );
Serial.print( interval );
Serial.print( " P = " );
Serial.print( P );
Serial.print( " I = " );
Serial.print( I );
Serial.print( " D = " );
Serial.print( D );
Serial.print( " PID = " );
Serial.print( PID );
Serial.print( " PWM = " );
Serial.println( 127 + PID );
*/

// Avvia la comunicazione seriale

// Imposta il pin del motore1 come uscita

// Stampa dei dati

time = millis();
interval = (time - previousTime)/1000;
ciclo in secondi

// Salva il tempo corrente

// Calcola il tempo impiegato per eseguire un

getErrore();
ottenere l'errore
getPID();
i parametri del controllo PID
controllomotori();
il contorllo degli attuatori

// Richiama la funzione getErrore() per

previousTime = time;
previousErrore = Errore;

// Richiama la funzione detPID() per calcolare

// Richiama la funzione controllomotori() per
// Memorizza il tempo attuale
// Memorizza posizione attuale

GetPID:
void getPID()

// Algoritmo per il calcolo del PID

{
Errore = Errore - (511.5);

// Elimina l'offeset

P = Errore * kP;
I = I + (P * interval * kI) ;
D = kD * ( Errore - previousErrore ) / interval;

// Calcola la variabile proporzionale

// Calcola la variabile integrativa
// Calcola la variabile derivativa

PID = P + I + D;

// Calcola il PID

if( PID > 127 ) PID = 127;

impostato a 127
if( PID < -127 ) PID = -127;
valore impostato a -127
}

// Se il valore supera 127, il valore

// Se il valore minore di -127, il

Controllo Motori:
void controllomotori ()
motori DC

// Algoritmo per il controllo dei due

{
analogWrite( motore, 127 - PID );

// Controlla il motore1 in base al PID

26

GetErrore:
float getErrore()
sensore da cui misurare
{
int n = 50;
misura, per il calcolo della media
int array[n];
distanza
float somma = 0;
media
int C;
for ( C = 0; C < n; C++ )
{
array[C] = analogRead( input );

// Rilevazione della distanza, in ingresso il

// Numero di volte che si deve effettuare la
// Array di appoggio per la rilevazione della
// Variabile di appoggio per il calcolo della
// Contatore di appoggio

// Salva n valori letti in un array di dimensione

n
somma = somma + array[C];
nell'array
}

// Effettua la somma dei valori contenuti

Errore = somma / n ;
nella variabile Errore
}

// Effettua la media, e salva il valore ottenuto

27