Archivi categoria: i miei allievi

Errori comuni nell’uso di Arduino – ordine esecuzione operazioni matematiche e overflow nei calcoli

In realtà l’errore che viene commesso non è di carattere informatico, ma puramente matematico, dimenticando l’ordine con cui vengono eseguite le operazioni matematiche.
L’ordine delle operazioni segue le regole di base: moltiplicazioni e divisioni hanno precedenza massima seguono addizioni e sottrazioni. Se si vuole cambiare l’ordine di precedenza bisogna utilizzare le parentesi. Vediamo alcuni esempi.

int valore = 1 + 2 * 3 + 4;

il risultato sarà 11.

// Prof. Michele Maffucci
// Data: 08.02.2020
// Esempio 01: Ordine di esecuzione operazioni matematiche in C

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della comunicazione seriale
  Serial.begin(9600);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Calcolo:");
    Serial.println("valore = 1 + 2 * 3 + 4");
    int valore = 1 + 2 * 3 + 4;
    Serial.print("valore = ");
    Serial.println(valore);
    abilitaMessaggio = 1;
  }
}

Per rendere più evidente la sequenza di esecuzione del calcolo possiamo usare le parentesi, pertanto otterremo:

int valore = 1 + (2 * 3) + 4;

Che fornisce sempre il valore 11.

// Prof. Michele Maffucci
// Data: 08.02.2020
// Esempio 02: Ordine di esecuzione operazioni matematiche in C

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della comunicazione seriale
  Serial.begin(9600);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Calcolo:");
    Serial.println("valore = 1 + (2 * 3) + 4");
    int valore = 1 + (2 * 3) + 4;
    Serial.print("valore = ");
    Serial.println(valore);
    abilitaMessaggio = 1;
  }
}

Per modificare la precedenza utilizziamo le parentesi:

int valore = ((1 + 2) * 3) + 4;

il risultato sarà 13. Viene eseguito prima il calcolo della parentesi più interna (1+2), poi si passa alla parentesi immediatamente successiva, quindi (3 * 3) e poi il risultato viene sommato a 4.

// Prof. Michele Maffucci
// Data: 08.02.2020
// Esempio 03: Ordine di esecuzione operazioni matematiche in C

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della comunicazione seriale
  Serial.begin(9600);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Calcolo:");
    Serial.println("valore = ((1 + 2) * 3) + 4");
    int valore = ((1 + 2) * 3) + 4;
    Serial.print("valore = ");
    Serial.println(valore);
    abilitaMessaggio = 1;
  }
}

Ovviamente, come già spiegato precedentemente, bisognerà sempre fare attenzione che il risultato faccia parte del tipo di dati giusto, ad esempio quando effettuate una divisione tra interi il cui risultato è un numero decimale, o ancora se superate il valore massimo del tipo di dato che state utilizzando. In entrambi i casi il compilatore non vi segnalerà nessun errore.

Vediamo un esempio:

// 60 secondi in un minuto, 60 minuti in un'ora, 24 ore in un giorno
long secondi_in_un_giorno = 60 * 60 * 24;

In teoria, poiché il risultato è 86.400, questo valore potrà essere contenuto in un tipo long.
Ma in realtà il valore realmente memorizzato in “secondi_in_un_giorno” è 20.864.
86.400 supera più di due volte la dimensione di un intero, il calcolo fatto dal compilatore sarà il seguente:
86.400 – 32.768 * 2 = 20.864

// Prof. Michele Maffucci
// Data: 08.02.2020
// Esempio 04: Ordine di esecuzione operazioni matematiche in C
//             errore di calcolo dovute al tipo del dato (dimensione massima).

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della comunicazione seriale
  Serial.begin(9600);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Calcolo (errato) numero di secondi in un giorno:");
    Serial.println("secondi_in_un_giorno = 60 * 60 * 24");
    long secondi_in_un_giorno = 60 * 60 * 24;
    Serial.print("Secondi in un giorno = ");
    Serial.println(secondi_in_un_giorno);
    Serial.println("Errore! Il valore doveva essere: 86.400");
    Serial.println("L'errore si verifica perchè il compilatore considera i numeri di tipo int.");
    abilitaMessaggio = 1;
  }
}

Ciò accade perché il compilatore C dell’IDE di Arduino vede un’espressione aritmetica composta da soli numeri interi e quindi considera il risultato come tipo int. Per evitare questo problema bisogna dire al compilatore che deve trattare l’intera espressione come un long aggiungendo L al primo valore che viene valutato nell’espressione:

long secondi_in_un_giorno = 60L * 60 * 24;

// Prof. Michele Maffucci
// Data: 08.02.2020
// Esempio 05: Ordine di esecuzione operazioni matematiche in C
//             Uso corretto del tipo long.

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della comunicazione seriale
  Serial.begin(9600);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Calcolo corretto del numero di secondi in un giorno:");
    Serial.println("secondi_in_un_giorno = 60L * 60 * 24");
    long secondi_in_un_giorno = 60L * 60 * 24;
    Serial.print("Secondi in un giorno = ");
    Serial.println(secondi_in_un_giorno);
    Serial.println("Giusto! Abbiamo detto con la L che l'intera espressione è da trattate come un long.");
    Serial.println("");
    abilitaMessaggio = 1;
  }
}

Attenzione sempre alle parentesi!
Se le utilizzate ad esempio come nell’esempio che segue farà andare in overflow il risultato:

long secondi_in_un_giorno_piu_uno = 1L + 60 * (60 * 24);

// Prof. Michele Maffucci
// Data: 08.02.2020
// Esempio 06: Ordine di esecuzione operazioni matematiche in C
//             L'uso non corretto delle parentesi fa andare in overflow il risultato.

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della comunicazione seriale
  Serial.begin(9600);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Calcolo errato somma 1 al numero di secondi in un giorno");
    Serial.println("secondi_in_un_giorno_piu_uno = 1L + 60 * (60 * 24)");
    long secondi_in_un_giorno_piu_uno = 1L + 60 * (60 * 24);
    Serial.print("Secondi in un giorno + 1 = ");
    Serial.println(secondi_in_un_giorno_piu_uno);
    Serial.println("Sbagliato! Attenzione sempre alle parentesi!");
    Serial.println("Se le utilizzate ad esempio come indicato farà andare in overflow il risultato");
    abilitaMessaggio = 1;
  }
}

mentre la seguente espressione non farà andare in overflow il calcolo:

long secondi_in_un_giorno_piu_uno = 1 + 60 * (60L * 24);

// Prof. Michele Maffucci
// Data: 08.02.2020
// Esempio 07: Ordine di esecuzione operazioni matematiche in C
//             L'ordine del calcolo viene stabilito dalle parentesi, in questo modo
//             il calcolo non farà andare in overflow il risultato.

// per stampare una sola volta il messaggio sulla Serial Monitor
bool abilitaMessaggio = 0;

void setup() {
  // inizializzazione della comunicazione seriale
  Serial.begin(9600);
}

void loop() {
  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (abilitaMessaggio == 0) {
    // ritardo che evita la doppia stampa del messaggio
    delay(200);
    Serial.println("Calcolo errato somma 1 al numero di secondi in un giorno");
    Serial.println("secondi_in_un_giorno_piu_uno = 1 + 60 * (60L * 24)");
    long secondi_in_un_giorno_piu_uno = 1 + 60 * (60L * 24);
    Serial.print("Secondi in un giorno + 1 = ");
    Serial.println(secondi_in_un_giorno_piu_uno);
    Serial.println("Corretto! Il calcolo inizierà dalle parentesi tonde.");
    Serial.println("E' stata aggiunta la L al primo operando tra le parentesi tonde.");
    abilitaMessaggio = 1;
  }
}

Buon Coding a tutti 🙂

Arduino – Utilizzo dell’LCD1602 Keypad Shield della Keyestudio

Lascia una risposta

Questo post è dedicato ai miei allievi Paolo e Sami 🙂 della 3B Automazione, che amano i videogiochi platform a cui ho assegnato un’attività di PCTO in cui è richiesto appunto la progettazione di un gioco elettronico di tipo platform con Arduino.
A tal proposito, per ridurre i tempi di prototipazione verrà usato un LCD Keypad Shield della Keystudio, il tutto verrà poi inserito in un contenitore stampato in 3D, sempre progettato dai due studenti e che dovrà ricordare un Game Boy.

Per le specifiche tecniche della scheda seguire il link allegato, seguono alcune indicazioni della scheda ricavati dalla pagina del prodotto ed alcuni link a risorse per la produzione di semplici videogiochi con Arduino.

La shield della Keyestudio integra su di esso un display LCD 1602 e sei pulsanti ed si inserisce su qualdsiasi scheda Arduino UNO R3 compatibile. Il display può comunicare con la scheda Arduino in due modi: ad 8 bit o a 4 bit, la connessione predefinita del display è a 4 bit. Come riportato nell’immagine che segue, al di sotto del display sono presenti 5 pulsanti di controllo (Seleziona, Su, Giù, Sinistra, Destra) e un pulsante di reset, che è collegato direttamente al reset della scheda Arduino.

I 5 pulsanti sono collegati all’ingresso analogico A0, quindi potrete monitorare lo stato dei pulsanti utilizzando un solo ingresso analogico di Arduino. Attenzione però che potrete monitorare solamente la pressione di un pulsante alla volta, quaindi la pressione contemporanea di due o più pulsanti non potrà essere identificata. La shield è inoltre dotata di un trimmer che permette la regolazione della retroilluminazione dell’LCD.

Nel caso si abbia la necessità di utilizzare i restanti pin di Arduino, non utilizzati per il controllo del display, è possibile saldare sulla scheda pin passanti femmina.

Nello sketch che segue, modificato leggermente rispetto a quello usato da Keystudio, la pressione di ogni singolo pulsante, ad esclusione del reset, corrisponderà ad uno specifico valore restituito dall’analogRead sul pin A0, la pressione di ogni pulsante restituirà un valore numerico all’interno di un intervallo specificato, così come indicato nell’immagine precedente, ciò permetterà quindi di intercettare quale pulsante è stato premuto.
I valori dell’analogRead corrispondenti al pulsante premuto verranno visualizzati anche sulla SerialMonitor.

Nei commenti nel codice la spiegazione di ogni sezione.

/*
 * Prof. Michele Maffucci
 * Utilizzo dell'LCD Keypad Shield della Keystudio
 * Data: 08.02.2021
 */

// inclusione della libreria LiquidCrystal.h
#include <LiquidCrystal.h>

// inizializza la libreria con i numeri dei pin dell'interfaccia
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  // impostazione del numero di colonne e righe del display
  lcd.begin(16, 2);
  Serial.begin(9600);
  // Stampa 5 puntini per dare la sensazione di avvio programma
  for (int i = 0; i < 4; i++) {
    lcd.print(".");
    delay(250);
  }
  // Posiziona il cursore in colonna 0 e riga 0
  lcd.setCursor(0, 0);
  // Stampa il messaggio
  lcd.print("Salve Mondo!");
}

void loop() {
  // Posiziona il cursore in colonna 0 e riga 0
  lcd.setCursor(0, 1);
  // Stampa il numero di secondi dall'avvio
  lcd.print(millis() / 1000);

  // Memorizza in val il valore presente su A0
  int val = analogRead(A0);

  // Stampa il valore di val sulla Serial Monitor
  Serial.println(val);

  // In funzione del pulsante premuto val assumerà valori diversi
  if (val >= 0 && val <= 50)
  {
    lcd.setCursor(5, 1);
    lcd.print("Destra  ");
  }
  else if (val >= 50 && val <= 150)
  {
    lcd.setCursor(5, 1);
    lcd.print("Su'     ");
  }
  else if (val >= 150 && val <= 300)
  {
    lcd.setCursor(5, 1);
    lcd.print("Giu'    ");
  }
  else if (val >= 300 && val <= 500)
  {
    lcd.setCursor(5, 1);
    lcd.print("Sinistra");
  }
  else if (val >= 500 && val <= 750)
  {
    lcd.setCursor(5, 1);
    lcd.print("Set     ");
  }
}

Di seguito alcuni link a giochi in cui viene sfruttato un l’LCD 1602 e in cui potreste utilizzata la shield della Keyestudio.

Nel caso in cui fosse necessario realizzare caratteri o icone personalizzate consultare: Disegnare caratteri personalizzati con Arduino per un LCD 16×2

Buon divertimento 🙂

Supporto per motore a spazzola kit ELEGOO

Lascia una risposta

La quasi totalità dei miei studenti, per svolgere le attività di sperimentazione di elettronica e automazione a casa e a scuola in questo periodo di crisi pandemica, ha acquistato uno dei molti kit ELEGOO in cui, anche nella versione base del kit, sono presenti tutti i componenti per svolgere le prime esercitazioni di automazione. All’interno dei diversi kit è presente un motore CC a spazzola 3-6 V come quello indicato nell’immagine che segue a cui è possibile connettere una ventola.

Questo semplice motore viene utilizzato in diverse esperienze di laboratorio: marcia e arresto, controllo di velocità e molto altro. Per far si che il banco di lavoro sia ordinato ho realizzato in 3D tre elementi che permettono di disporre il motore su un supporto di legno ricavato da una comune bacchetta di legno 20×20 mm che può essere acquistata in qualsiasi brico.

Condivido su Thingiverse i sorgenti grafici per la realizzazione del supporto.

Di seguito alcune immagini della semplice struttura… e quando farà caldo tutti avranno il proprio ventilatore personale 🙂

Buon Making a tutti 🙂

SumoFoam – per realizzare velocemente una struttura per robot didattico

Lascia una risposta

“5 minuti da Maker” è orami un’abitudine che ho da qualche tempo: progettare in 5 minuti un oggetto o una soluzione e realizzarla. Alcune volte realizzarla mi richiede un po’ più di 5 minuti, ma cerco di non superare in tutto 60 minuti. E’ un’esercizio che mi sono imposto settimanalmente, un po’ come svago un po’ per dar sfogo ad idee nascenti che potrebbero diventare qualcosa di più importante.

Questa volta l’esercizio consiste nel rendere ancora più semplice la realizzazione del SumoBot, picco robot realizzato in compensato, trasformandolo in una versione realizzata con un materiale ancora più semplice da manipolare per gli studenti più giovani, il Foam Core, (per saperne di più continua la lettura 😉 ).

Durante una delle tante attività di PCTO feci realizzare ai miei studenti di 3′ automazione un il piccolo SumoBot su una base di compensato da 3mm, l’attività consisteva nel montare la struttura, l’elettronica e programmare i robot affinchè potessero gareggiare. Il tutto era stato realizzato con schede Arduino UNO R3 e anche con degli Arduino micro, due micro servo SG90 a rotazione continua ed un sensore ad ultrasuoni. Alcuni aggiunsero al robot una scheda Bluetooth per poter pilotare il robot anche via smartphone. Fu un’attività divertentissima che voglio riproporre ai ragazzi.

Nel riprendere in mano il progetto ho pensato di realizzare una versione della struttura in Foam Core, un materiale utilizzato dagli architetti per costruire plastici di abitazioni. Si tratta di uno strato di spugna racchiuso da due fogli di cartoncino. Viene venduto in fogli di diverso spessore e dimensione, attualmente sto utilizzando fogli A3 di spessore 5mm. Le strutture che se ne ricavano sono sufficientemente solide. Utilizzo questo materiale quando voglio prototipare rapidamente oggetti per le mie sperimentazioni, come quello che vedete nell’immagine che segue, un supporto per un display 16×2.

In genere stampo su fogli adesivi bianchi A4 la struttura che voglio realizzare, dispongo i fogli adesivi sul Foam Core e con un cutter ne ritaglio il profilo. Tutti gli elementi poi vengono incastrati e incollati con normalissima colla vinilica.

Con il Foam Core ho provato a realizzare una serie di piccoli robot e sono rimasto più che soddisfatto.

Di seguito la sequenza fotografica delle fasi di montaggio, il taglio degli elementi non è perfetto, con un po’ più tempo e pazienza si può fare molto meglio.

Tra qualche giorno, quando terminerò di effettuare le ultime prove sul SumoFoam renderò pubblico il file pdf.

Stampo su foglio adesivo bianco il profilo del robot ed incollo su Foam Core.

Si nota la struttura a sandwich del pannello: cartoncino – materiale spugnoso – cartoncino

Oltre ad incastrare i vari elementi ho utilizzato della colla vinilica.

Prossimamente il montaggio dell’elettronica da parte dei miei studenti.

Buon Making a tutti 🙂

EduRobot Lift/Elevator

Lascia una risposta

Nuova versione del kit EduRobot Lift, ascensore/montacarichi da utilizzare per le esercitazioni di laboratorio di sistemi elettronici e attività di PCTO negli istituti tecnici industriali e professionali.

Rispetto alla versione precedente alcune migliorie che ne facilitano la costruzione. Il controllo può essere effettuato in diverse modalità: Siemens Step 7 1200, Logo8!, Siemens IoT 2040, Arduino. La struttura è stata disegnata con Adobe Illustrator e tagliata a laser presso il Laboratorio Territoriale del mio istituto, l’ITIS G.B. Pininfarina di Moncalieri. Il materiale è costituito da compensato da 4 mm e due elementi stampati in 3D in PETG. Il montaggio della struttura richiede circa 40/45 min.

Se desideri realizzare il kit, seguire il link su Thingiverse, da cui potrete prelevare il file PDF per il taglio laser e i file STL per la stampa 3D della struttura del motore.

Volutamente per la realizzazione di questo kit sono stati scelti materiali economici in quanto il mio desiderio è quello di assegnarne un kit ad ogni studente.

foglio di compensato da 4mm 80×60 mm (costo indicativo: €4)
24 viti M3 da 12 mm
24 dadi M3
motorino passo passo 28BYJ-48
colla vinilica
due elementi stampati in 3D
spago

Nel kit viene utilizzato un motore passo passo economico il 28BYJ-48 in modo che possa essere acquistato da tutti gli studenti. Con qualche piccola modifica è possibile utilizzare anche un motorino DC da 6V, i classici “motorini gialli” utilizzati dagli studenti per la costruzione di piccoli robot.

Quattro gli obiettivi di questo progetto:

offrire una guida fotografica per i miei studenti della classe 3′ che dovranno svolgere il PCTO (ex Alternanza Scuola Lavoro) facendo una simulazione di attività aziendale, quest’anno dovranno diventare tecnici di un’azienda che produce ascensori e montacarichi;
mostrare agli studenti che è possibile imparare ad imparare attraverso attività laboratoriali che prevedono la progettazione e la costruzione dei propri strumenti di apprendimento;
il mercato offre molteplici strumenti, kit robotici di ogni tipo che rispondono a molteplici esigenze didattiche, ma alcune volte non rispondono ad esigenze specifiche di un percorso di studio o di un argomento, ecco che la scuola diventa produttrice dei propri ausili didattici specifici;
rispondere alle numerose richieste di realizzazione del kit pervenutemi da molti colleghi di scuole italiane dopo il mio intervento per SCE Siemens in cui ho mostrato le mie sperimentazioni didattiche nell’ambito dell’automazione, tra queste anche EduRobot Lift. Ringrazio tutti.

Di seguito un breve video che mostra la struttura generale del kit e di seguito una guida fotografica passo passo che ne dettaglia le fasi di costruzione.

In successive lezioni verranno proposti modalità di controllo del sistema.

Sentitevi liberi di apportare modifiche e migliorie alla struttura. Mi farebbe piacere avere un vostro parere ed eventualmente, se utilizzate il kit, inviatemi le fotografie dei vostri lavori in modo che io possa pubblicarle su questo sito.

Il progetto è rilasciato con la seguente licenza: Attribuzione 4.0 Internazionale (CC BY 4.0)

Come viene mostrato nell’immagine che segue il kit è costituito da 21 elementi di compensato e due elementi stampati in 3D, nell’immagine potete notare anche un 3′ elemento, una piccola rondella di plastica, che è stata poi sostituita da un dado M3 (i dettagli al fondo di questa lezione).

Struttura impiegata per fissare il motore passo passo e il rocchetto utilizzato per avvolgere lo spago a cui verrà fissata la cabina dell’ascensore.

Nell’immagine si vedono viti M3 da 12 mm e dadi M3.

La colla vinilica viene utilizzata solamente per fissare i piedini alla base della struttura.

Poiché sulla base del kit sono presenti delle viti, per evitare che queste raschino la base di appoggio, sono stati previsti dei piedini la cui altezza è di 8 mm, ciò si ottiene incollando tra loro due elementi.

Incollare i piedini sugli angoli della base.

Allineare i piedini come riportato nell’immagine che segue.

Fare in modo che ci sia anche un allineamento rispetto alla verticale.

Predisporre il montaggio della cabina dell’ascensore. Si consiglia di inserire prima il dato nella fessura così come riportato nell’immagine. La parte inferiore della cabina è identica a quella superiore con la differenza che la parte superiore ha un foro in cui andremo ad inserire lo spago.

Inserire la parete laterale e dalla parte opposta inserire la vite. Bloccare i due elementi, ma attenzione a non avvitare con forza.

Procedere allo stesso modo per la parte posteriore della cabina dell’ascensore: Inserire i dadi, incastrare nella fessura la parete ed avvitare con le due viti.

Inserire la parte superiore della cabina contraddistinta da un foro centrale.

Passiamo ora alle colonne. Sono presenti 6 colonne di due tipi: con fori e senza fori, hanno tutte la stessa dimensione. Le colonne con fori hanno un’orientamento, nell’immagine si nota che i fori hanno distanze diverse dal bordo che va incastrato alle basi. I fori che hanno una distanza di 4 cm dalla base vanno rivolti verso la base di appoggio dell’ascensore.

Tre sono le colonne frontali ed andranno inserite nelle apposite fessure. Anche in questo caso si consiglia di inserire prima i dadi.

Posizione in cui devono essere inserite le colonne frontali.

Inserire le viti dalla parte inferiore della base.

Inserire le colonne laterali. Prima di inserirle nelle fessure incastrare i dadi M3.

Bloccare con viti.

Montare la colonna posteriore.

Procedere nel montaggio così come fatto per le altre colonne.

Inserire la cabina dell’ascensore, con la parte aperta disposta frontalmente.

Le scanalature laterali permettono di far scorrere la cabina tra le guide.

Fissare la base superiore del kit. Inserire nelle colonne i dadi e successivamente inserire nella posizione indicata dalle frecce le viti.

Avvitare, ma attenzione a non serrare con forza, rischiereste di rompere il compensato.

Inserire 4 viti nella posizione indicate dalle frecce.

Avvitare i dadi.

Inserire il rocchetto all’interno dell’asse del motore. Attenzione che il rocchetto ha un’orientamento, ciò è mostrato nel video ad inizio di questa lezione. Come si nota l’asse del motore non è cilindrico.

Inserire la vite nella posizione indicata dalla freccia, questa costituisce un supporto per il rocchetto. Avvitare il motore alla struttura.

Fissiamo lo spago alla cabina. Inserite lo spago nel foro dalla parte superiore e legateci un dado.

Poggiate la cabina sulla base della struttura e fate in modo che il filo sia ben dritto ed incollatelo sul rocchetto. Il risultato dovrebbe essere il seguente:

Buon Making a tutti 🙂

Related posts:

Related posts:

Related posts:

Related posts:

Related posts: