Elaborato per esame di stato 2020/2021 5A ELE
Relatore: Corlito Tommaso
“Lancio dei dadi con il braccio robotico”
“Il progetto che presento come parte dell’elaborato attinge a quelle che sono le esperienze avute in merito alla materia di sistemi elettronici, soprattutto riguardo alla parte di programmazione.
Come lascia già intendere il titolo, il robot svolge una semplice funzione, ossia quella di lanciare dei dadi contenenti in un bicchiere di plastica. Per quanto nella sua semplicità egli non svolge altri compiti, questo ci permette di comprendere le funzionalità del braccio ed il modo con cui l’hardware si interfaccia con altri dispositivi.
Oltre a ciò chiaramente vi è anche un opportunità per implementare il sistema nella vita reale.”
“Si ma dove e a che scopo?”
“Ovviamente nei casinò. Non sono infatti rari i casi dove in un banco, lanciando i dadi, si verifichi il caso di scivolamento dei dadi, che implica un tentativo di avvantaggiarsi nel gioco. Questo genere di truffa non è nuovo ed è ancora in circolazione, soprattutto per via del fatto che spesso e volentieri il croupier è o inesperto oppure complice, rendendo quindi invisibile il misfatto ad occhi indiscreti. Il braccio robotico invece impedirebbe al giocatore di lanciare i dadi, privandolo quindi della possibilità di effettuare alcuna tecnica in grado di barare nel gioco. “
“Fondamenta matematiche in merito alla truffa”
“La tecnica dello scivolamento del dado non è una tecnica infallibile, ma sicuro molto efficace matematicamente parlando. Il procedimento comprende il lancio di entrambi i dadi consecutivamente, ma dando la possibilità a solo uno dei due di ruotare e rimbalzare, mentre l’altro dado semplicemente ruota sul suo asse senza realmente staccarsi dal piano, impedendogli quindi far uscire una faccia diversa da quella prefissata. Già da questa breve descrizione del procedimento si capisce qual è la base matematica che consente a molti truffatori di farla franca. Applicando questa tecnica solo uno dei dai avrà la possibilità di 1/6 di far uscire il numero utile al giocatore, mentre l’altro avrà sempre una garanzia del 100% di uscire già con il numero prefissato da chi lo lancia, rendendo molto più probabile la vittoria del truffatore rispetto agli altri (che avranno 1/6 di probabilità di riuscire a trovare la corretta uscita per entrambi i dadi). Ed ecco spiegato l’importanza di questo braccio. Privando il truffatore di quello che è la sua arma vincente, ossia il “lancio” dei dadi, si preverrebbero molti inganni orditi nei casinò.”
“In conclusione, questo progetto non rimane soltanto un piccolo lavoro per un esame di stato, ma acquista valore per la sua funzionalità ed estrema efficacia anche nella vita reale. Mi auguro quindi che l’accoglienza per questo braccio sia tanto ampia quanto lo stupore nel vederlo all’opera.“
Relazione elaborato per esame di stato Anno 2020/2021
Progetto: Controllo robot per il lancio dei dadi con Arduino
Relatore: Corlito Tommaso
Classe: 5A ELE
CAPITOLO 1
Arduino: dall’hardware al software
Arduino si compone di molti elementi al suo interno, attraverso i quali si può andare a creare un sistema dalle più svariate funzioni. E’ bene dunque distinguere gli elementi di un Arduino e comprendere, di ognuno, il suo rispettivo compito. Per fare ciò è necessario suddividere questi componenti in tre macro-categorie, ossia:
- il circuito;
- la scheda (l’hardware);
- l’IDE di Arduino (il software).
Il circuito
Il circuito consente di collegarsi alla scheda di Arduino, andando ad utilizzare quei componenti utili al funzionamento del sistema. Suddetto circuito ha diversi tipi di componenti, i quali possono essere delle più disparate configurazioni e valori, determinano il livello di complessità del sistema che si vuole andare a creare. Il circuito viene inoltre inserito su di una breadboard, può essere composto da:
Si possono notare nel dettaglio sia i ponticelli, che i LED
- Ponticelli: questi sono necessari non solo per collegare fisicamente il circuito alla scheda, ma anche i diversi altri elementi di cui si compone la breadboard, che altrimenti rimarrebbero disconnessi fra loro;
- Resistenze: Con i quali è possibile controllare e, all’occorrenza, modificare i valori di tensione e di corrente del circuito;
- LED: Un diodo che si illumina al passaggio di una determinata corrente elettrica (che varia a seconda dei valori del componente stesso);
- Pulsanti: Interruttori che permettono il passaggio o meno di corrente elettrica all’interno del ramo in cui questo è inserito. Tuttavia questo non mantiene la commutazione una volta premuto il tasto, ma bisogna tenerlo premuto per chiudere il circuito;
- Sensori: dispositivo atto ad interagire con il circuito qualora esso venga sollecitato da determinate grandezze fisiche. Tra questi si possono citare il sensore di temperatura, di posizione, di inclinazione e di peso;
- Potenziometro: Una resistenza variabile, a cui viene applicato una tensione particolare quando la manopola atta a controllare il valore resistivo viene mossa. A differenza delle resistenze normali, essa si compone di tre piedini,dove quelli esterni vengono inseriti in un punto dove è applicato un potenziale elettrico, mentre invece quello centrale finisce a massa;
- Fotoresistenza: Resistenza che varia in base alla quantità di luce che colpisce il componente.
Questi sono alcuni tra i componenti principali di cui si può far uso per creare un circuito per Arduino
La scheda (l’hardware)
La scheda è la parte di Arduino che si occupa di mettere in comunicazione il circuito ed il programma. Di fatto è proprio dispositivo a collegarsi ad il circuito (inserito nella breadboard) ed è sempre lui quello su cui bisogna caricare il programma. La scheda si compone di diversi, tuttavia esistono diverse versioni della stessa, non rendendo quindi univoco il numero dei componenti stessi. Ne consegue quindi che, in questo testo, quando verranno inseriti numeri precisi riguardanti un particolare componente, dovranno essere riferiti ad una scheda in particolare tra tutte. La scheda in questione è l’Arduino UNO. I componenti principali al suo interno sono:
immagine della scheda Arduino UNO nel dettaglio
- l’ingresso USB: da cui possiamo caricare il programma;
- l’ngresso per l’alimentazione:da cui, come dice il nome, possiamo alimentare il sistema (dalla scheda al circuito);
- il microcontrollore: colui che interpreta il programma caricato dall’ingresso USB;
- 14 pin digitali di input ed output: utili a collegarsi al circuito e inviare segnali digitali al sistema;
- 6 input analogici: svolgono la stessa funzione dei pin sopracitati, solo che funzionano solo ed esclusivamente con segnali di input analogici.
Insieme a ciò è necessario tuttavia spiegare quella che è un aggiunta alla scheda stessa, utile ai sistemi come appunto il braccio robotizzato esposto in questa relazione. Questo componente è chiamato “shield”.
La shield (dall’inglese “scudo”), sono schede da implementare con l’Arduino, i quali permettono all sistema stesso di avere una semplificazione ed una maggiore accessibilità con componenti esterni alla scheda di Arduino stessa, in questo caso, con i motori del braccio robotizzato, con i quali è piu facile interagire. La scheda shield e quella di Arduino UNO comunicano tramite i loro pin, che vengono collegati tra loro. Bisogna ricordare tuttavia che, seppur di norma le shield sono compatibili con Arduino UNO (proprio per via del fatto che la piedinatura è la stessa), lo stesso non si può dire con le altre schede. Tra tutti quella di Arduino Mega per esempio, i quali solo alcune shield possono interagire con esso, per via del fatto che il “Mega” è un normale Arduino UNO con un maggior numero di pin e di memoria. Discorso opposto invece per le versioni della scheda di Arduino Nano o Arduino Mini, i quali sono molto poco diffusi.
L’IDE di Arduino (il software)
L’IDE di Arduino, ovvero il programma da inserire nella scheda, si compone di diverse parti, le quali non tutte però sono obbligatoriamente da inserire, come nel caso del braccio robotico di questa relazione. Gli elementi che costituiscono il programma sono:
- Struttura: ovvero la base sul quale il programma comprende le istruzioni da seguire. Arduino in particolare ha 2 tipi diversi di istruzioni:
- Void loop(..) – Istruzioni da seguire ripetutamente;
- Void setup(..) – Istruzioni da eseguire una sola volta.
- Costanti: ad ognuna di queste costanti vengono attribuiti diversi significati/valori. Si dividono anch’essi in due tipi:
- HIGH (a quale viene attribuito un valore alto, ossia 1) e LOW (a cui viene attribuito un valore basso, ossia 0);
- INPUT(entrata di un segnale) e OUTPUT (uscita del segnale).
- Variabili: Valori che l’utente di Arduino può scegliere di cambiare tutte le volte che questo voglia;
- Controlli: E’ la funzione logica di Arduino, ossia il “sistema di ragionamento” per cui il programma funziona in un determinato modo. Tra queste funzioni le principali sono:
- If…Else: Il programma si trova davanti ad un bivio, nel quale bisogna guardare una condizione particolare del sistema. Se la condizione viene rispettata , allora il programma farà fare al sistema tutto ciò che comprende le azioni corrispondenti al
“vero”, altrimenti seguirà il funzionamento corrispondente al “falso”;
- For: ripete le stringhe di codice (che indicano delle azioni particolari che il sistema deve svolgere) per un numero finito di volte;
- While: ripete le stringhe di codice fino a che una determinata condizione viene rispettata (ergo, è vera).
- Operatori di comparazioni: inseriscono dei termini di comparazione per il quale il primo membro è:
- == “Uguale a”
- > “maggiore di”
- < “minore di”
- ! = “diverso da”
- <= “minore o uguale”
- >= “maggiore o uguale” al secondo membro
- Ingressi/Uscite digitali: queste si dividono in tre parti:
- pinMode (pin,mode): viene inserito in “ void setup (*)” e serve per stabilire se quel particolare pin sia di ingresso (INPUT) o di uscita (OUTPUT);
- digitalRead (pin): Legge lo stato del pin quando questo è un input, se è applicato una tensione è HIGH, altrimenti, in assenza di segnali, è LOW;
- digitalWrite (pin,valore): Riguarda esclusivamente i pin digitali e indica se questi siano ON oppure OFF.
- Ingressi/Uscite analogici: queste si dividono in:
- analogRead (pin): legge il valore di tensione applicato in quello specifico pin;
- analogWrite (pin,value): cambia la larghezza dell’impulso dei pin che hanno la sigla contrassegnata come “PWM”.
CAPITOLO 2
Circuito e braccio robotizzato:
Come già spiegato precedentemente, il compito del braccio robotizzato, per gli obbiettivi dell’elaborato, è quello di lanciare dei dadi. Prima di addentrarsi però verso quello che è il cuore del sistema, ossia il programma, la funzione logica che il braccio deve seguire, bisogna specificare il funzionamento del braccio stesso. Il sistema, per far si che esegua le azioni che il programma gli fa fare, ha bisogno del corretto collegamento della scheda di Arduino e della shield al circuito. l’Arduino (che in questo caso svolge sia il ruolo di scheda Arduino UNO che di shield) ed i motori. Di fatti il funzionamento del braccio avviene tramite suddetti motori, che controllano ognuno un movimento particolare di questi, facendo ruotare le diverse parti della macchina attorno ad uno specifico asse (eccetto il 6°). I motori sono:
- Ha il compito di spostare interamente il braccio, compiendo giri attorno ad un asse orizzontale, in quanto, a differenza degli alti motori, la base rimane perfettamente parallela alla superficie su cui appoggia, non cambiando mai inclinazione rispetto ad esso;
- Questo motore è capace di compiere all’intero braccio di sollevarsi o abbassarsi, mantenendo un asse verticale;
- Anche questo, come il precedente, fa muovere il braccio su di un asse verticale, solo che, essendo a metà del braccio, farà ruotare soltanto la parte anteriore dello stesso, non influenzando in alcun modo la parte inferiore;
- Ultimo motore in grado di muoversi su di un asse verticale. In questo caso si parla di un movimento molto simile a quello di un polso, permettendo di muovere su e giù soltanto le pinze;
- Il motore numero 5 compie lo stesso movimento sull’asse orizzontale visto nel motore 1, tuttavia qui il movimento riguarda solo le pinze, così come con il motore 4. ciò fa si che la pinza stessa, inclinandosi, inclini l’oggetto tenuto tra le due prese;
- Ultimo motore del braccio, nonché quello più peculiare, in quanto egli non ruota su di un asse come gli altri, ma ha il compito di chiudere (per afferrare un oggetto) o aprire (per lasciare un oggetto) le pinze.
Tuttavia il braccio ha la capacità si di prendere oggetti con la pinza, ma oggetti piccoli e di facile maneggevolezza per quelle che sono delle simil dita. Per sopperire a questo problema è stato inserito un apposito pezzo di plexiglass tra le due pinze, in modo tale da poter inserire il bicchiere senza il rischio che questo sfugga alla presa delle pinze stesse.
Inoltre è doveroso ricordare come il giro che possono compiere le prime 5 pinze non è di 360°, ma bensì di al massimo 180°. A questi andranno sottratti ulteriori gradi, come per il motore 2 (in quanto questi, rimanendo in una posizione perfetta di 180° andrebbe a danneggiare i cavi) che va circa da
15° a 165°, o per il motore 5, il quale non riesce, per difetto della macchina, ad inclinare perfettamente le pinze. Per quanto riguarda invece il motore 6, il valore che esso assume (come da programma) non viene definito in gradi, in quanto non si tratta di una rotazione, ma di apertura e chiusura delle due dita.
CAPITOLO 3 Il programma
Con questo capitolo si cercherà di spiegare in maniera sintetica ma esaustiva tutti gli elementi del programma, in modo da comprendere il perfetto funzionamento del sistema nelle sue istruzioni. Per tal motivo qui sotto si può osservare il programma completo del braccio robotizzato.
// 5AEle
// Corlito Tommaso // Data: 25/07/2021
// Controllo robot per lancio dadi con Arduino
#include <Braccio.h>
#include <Servo.h>
Servo base;
Servo shoulder;
Servo elbow;
Servo wrist_ver;
Servo wrist_rot; Servo gripper;
void setup()
{ Braccio.begin
();
}
void loop() {
//(step delay M1, M2, M3, M4, M5, M6);
| Braccio.ServoMovement(20, delay(1000); | 0, 45, 180, 170, 95, 10); // Posizione di Riposo Iniziale | |
| Braccio.ServoMovement(10, bicchiere | 0, 90, 180, 90, 95, 10); // Entra in Posizione per aspettare il | |
| Braccio.ServoMovement(10, delay(3000); | 0, 140, 180, 40, 95, 10); | // Aspetta il bicchiere |
| Braccio.ServoMovement(10, delay(2000); | 0, 140, 180, 40, 95, 73); | // Prende il bicchiere |
| Braccio.ServoMovement(10, delay(1000); | 0, 130, 170, 40, 95, 73); | // Tira un pò su |
| Braccio.ServoMovement(10, | 0, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 10, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 0, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 10, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 0, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 10, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 0, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 10, 130, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 0, 130, 170, 40, 95, 73); // Scuote | |
| Braccio.ServoMovement(10, | 10, 130, 170, 40, 95, 73); // Scuote | |
| Braccio.ServoMovement(10, | 0, 130, 170, 40, 95, 73); // Scuote | |
| Braccio.ServoMovement(10, | 10, 130, 170, 40, 95, 73); // Scuote | |
| Braccio.ServoMovement(10, | 0, 130, 170, 40, 95, 73); // Scuote | |
| Braccio.ServoMovement(10, | 10, 130, 170, 40, 95, 73); // Scuote | |
| Braccio.ServoMovement(10, delay(2000); | 0, 30, 180, 140, 95, 73); // Si mette in posizione | |
| Braccio.ServoMovement(10, dall’altra parte | 135, 30, 180, 140, 95, 73); // Per poi tornare in posizione | |
| Braccio.ServoMovement(10, delay(2000); | 170, 140, 180, 40, 95, 73); // Arriva alla posizione di lancio | |
| Braccio.ServoMovement(10, | 170, 140, 180, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 160, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 170, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 160, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 170, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 160, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 170, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 160, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 170, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 160, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 170, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 160, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 170, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 160, 140, 170, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, delay(1000); | 170, 140, 180, 40, 95, 73); | // Scuote |
| Braccio.ServoMovement(10, | 125, 140, 170, 40, 180, 73); | // Arriva alla posizione di lancio |
| Braccio.ServoMovement(10, | 115, 140, 170, 40, 180, 73); | // Lancia i dadi |
| Braccio.ServoMovement(10, | 125, 140, 170, 40, 180, 73); | // Torna alla posizione di lancio |
| Braccio.ServoMovement(10, delay(1000); | 170, 30, 180, 140, 95, 73); | // Ritorna in posizione |
| Braccio.ServoMovement(10, | 0, 30, 180, 140, 95, 73); | // Torna alla Base |
| Braccio.ServoMovement(10, | 0, 140, 170, 40, 95, 73); | // Vai Giù |
| Braccio.ServoMovement(10, delay(3000); } | 0, 140, 180, 40, 95, 10); | // Lascia il bicchiere |
Per comprendere la struttura del programma è necessario dividere in due parti l’analisi dello stesso:
- Il corpo programma
- Il movimento
Il corpo del programma
Con questi termini si intende identificare la base del software, ciò di cui si compone e cosa va a controllare.
Come è possibile osservare nell’immagine del programma, per far si che Arduino possa controllare un braccio ha dovuto fa uso di due librerie specifiche, ossia “Braccio.h” e “Servo.h”, i quali, come già fanno intendere i nomi, svolgono la propria funzione riguardanti il braccio robotizzato in uno ed i motori (servo) dall’altro.
Attraverso la libreria “Servo.h”, sono stati aggiunti tutti i sei diversi tipi di motori, qui indicati come base (motore 1), shoulder (motore 2), elbow (motore 3 ), wrist_ver (motore 4), wrist_rot (motore 5) e gripper (motore 6). In aggiunta a ciò è anche stato inserito il void setup riguardante il braccio.
Il movimento
Con l’arrivo del void loop il programma inizia a far muovere il braccio tramite i motori. All’interno del void loop si può osservare il “Braccio.ServoMovement”, ossia l’istruzione che serve al programma per capire come muovere i motori. All’interno della parentesi di questa istruzione si osservano dei valori. Il primo tra questi indica la velocità del movimento del braccio, che può andare da un valore di 10 (velocità massima) a 30 (velocità minima). Tutti i successivi numeri della parentesi, tranne l’ultimo, esprimono invece il numero in gradi verso cui i singoli motori hanno ruotato (ad esempio, il programma dice che per la prima stringa di movimento il motore 1 deve stare a 0°, il 2 a 45°, il 3 a 180° e così via). Come già detto negli altri capitoli, il motore 6 non lavora in gradi, in quanto non ruota, ma allarga o restringe le dita delle pinze, di fatti la sua presa va da un valore di 10 (amplio al massimo) fino a 73 (stretto al massimo). Come si osserva dalle prime 5 stringhe, il movimento del braccio parte da una posizione di base, fino a scendere per prendere il bicchiere, allarga le pinze (dove verrà inserito poi il bicchiere) ed infine stringe le pinze, alzandosi di poco da terra.
Il movimento successivo invece comprende lo scuotere il bicchiere per cambiare la posizione e l’orine dei dadi, in modo da rendere il lancio ancor meno prevedibile. Per far ciò è bastato solamente far muovere la base di 10 gradi, per dare velocità abbastanza al bicchiere per farne muovere il contenuto
In seguito il braccio si mette in posizione, per poi ruotare su se stesso, girando prima solo la base, e successivamente muovendosi anche con il “polso”, non prima di aver fatto scuotere il bicchiere un ultima volta, per favorire l’uscita dei dadi. Infine, l’ultimo passo, ossia la piccola spinta, sempre con solo il movimento del motore 1, per dare una spinta abbastanza forte da far rovesciare i dadi a terra.
Terminata la sua azione torna alla posizione di base, d quale potrà ripetere l’azione.
Chapter 4 The history of Arduino
Arduino is an open-source software and hardware project designed to make and share devices. In fact, the community under the Arduino company is very large and the simplicity of the system has contributed to increase its popularity.
The hardware is a microcontroller, that should not be confused with the microprocessor. A microcontroller carries out only a few specific functions. Some examples of devices that have microcontrollers are the washing machine, the oven, the dishwasher and other domestic appliances. Instead, a microprocessor can do a lot of actions, and is used in devices that are more complex than the majority of domestic appliances, for example a PC or a vehicle.
The Arduino project was born in Italy and precisely in Ivrea, at the Interaction Design Institute Ivrea (IDII). The opportunity to develop this microcontroller came in 2003, with a Master’s thesis project at IDII, an entire development platform called Wiring. In this process, the supervision of Massimo Banzi, Ben Fry and Casey Reas was essential, and especially Fry and Reas are known for having made this development platform. The goal of the project was to create a low-cost tool that could be used by everyone, a controller for both experts (or engineers) and amateurs. Initially, the students used a BASIC Stamp controller which cost 40€, but in the end the “Wiring platform” became a printed circuit board (PCB, that connects the electric components). A microcontroller called ATmega168 and a program called IDE were incorporated onto this board, to allow the system to perform simple actions.
In 2005, the students Massimo Banzi, David Mellis and David Cuartielles updated the project of the previous developer, adding a support for the ATmega8 microcontroller, and renamed the system “Arduino”, after the cafè where the students used to meet when they were developing the system.
And a fun fact is that the cafè was named after the King of Italy Arduino di Ivrea.