Strumenti Utente

Strumenti Sito


simon

Progetto Simon

Vogliamo realizzare un clone di un gioco elettronico famoso negli anni '80, il Simon della MB.

Il gioco Simon della MB(fonte Wikipedia)

Il gioco è molto semplice:

  • ci sono quattro bottoni di colore diverso che si illuminano e producono un suono abbinato al colore
  • il gioco propone una sequenza di colori/suoni
  • il giocatore deve ricordare e ripetere la sequenza premendo i bottoni in successione
  • se indovina si aggiunge un colore/suono alla sequenza
  • se sbaglia il gioco termina

Per vedere come funzionava si può guardare lo spot trasmesso in TV in quegli anni o questo video che mostra bene il gameplay.

Abbiamo scelto di fare un clone di questo gioco perché è semplice da realizzare ma interessante sia per la parte di progettazione e scelta dei componenti che per quella del software1). Dal punto di vista dei componenti servono:

  • quattro LED di colore diverso
  • un buzzer (magnetico o piezoelettrico)
  • cinque bottoni (uno per avviare il gioco)
  • un microcontrollore che esegue il software che gestisce il gioco

Specifiche hardware e scelta componenti

Nel realizzare questo progetto bisogna considerare alcune limitazioni:

  • basso costo
  • PCB di piccole dimensioni (costa meno)
  • PCB single-layer e componenti a foro passante (per farlo a scuola)
  • alimentazione con batteria piccola e economica
  • materiale facilmente reperibile o disponibile a scuola

Alimentazione

Tenendo conto di questi requisiti si è scelto di alimentare la scheda con una batteria a bottone tipo CR20322). Sono batterie al litio da 3V piccole, economiche, facilmente reperibili e con buona autonomia. Disponendo di soli 3V bisogna scegliere con attenzione gli altri componenti: i LED devono avere una Vf3) al massimo di 2,5V4), il microcontrollore e il buzzer devono poter funzionare con soli 3V.

LED

Vanno bene anche i LED da 5mm del laboratorio ma bisogna controllare che la Vf non superi i 2,5V e che la luminosità sia adeguata anche con correnti basse.

Buzzer

Scegliamo un buzzer piezoelettrico perché è più facile da pilotare di uno magnetico - che richiede un condensatore in più e assorbe correnti più elevate - e perché li abbiamo già a disposizione in laboratorio. Per una semplice panoramica sulle due tipologie di buzzer si può leggere questo articolo dal blog di un produttore.

Microcontrollore

I requisiti sono tanti:

  • funzionante a 3V e a basso consumo
  • con 5 ingressi per i pulsanti e 5 uscite per i quattro LED e il buzzer
  • economico e facilmente reperibile
  • facile da usare, possibilmente con ambienti di sviluppo che già conosciamo (IDE Arduino)
  • disponibile in un package a foro passante

La scelta cade quasi obbligatoriamente su un prodotto della serie tinyAVR di Atmel: l'ATtiny13A. Le sue caratteristiche sono:

  • basso consumo e alimentazione da 2V
  • 6 piedini utilizzabili sia come input che come output
  • economico (meno di 1€) e molto utilizzato
  • supportato da più ambienti di sviluppo, compreso quello di Arduino
  • disponibile nel package DIP8

Schema elettrico

Considerazioni preliminari

L'uso del microcontrollore ATtiny13A è possibile perché i suoi pin di I/O possono essere utilizzati alnternativamente come ingressi o come uscite nello stesso programma cambiando la modalità con un'istruzione. In questo modo con soli 6 pin si riescono a gestire 5 pulsanti, 4 LED e un buzzer.

I segnali sono tutti digitali:

  • in ingresso troveremo una tensione al livello alto o basso generata dai 5 pulsanti
  • in uscita porremo un livello alto o basso di tensione per attivare i 4 LED colorati e il buzzer

Coi pulsanti - che a tutti gli effetti sono dei contatti normalmente aperti - si può generare un segnale alto o basso utilizzando i 3 Volt di alimentazione e una resistenza di resistenza di pull-up. Queste resistenze sono già disponibili negli ingressi dell'ATtiny13 e devono solo essere attivate via software. Il problema del anti-rimbalzo, sempre presente ogni volta che ci sono parti mobili in un contatto, può essere gestito via software per risparmiare componenti.

I LED si collegano ai pin dei pulsanti corrispondenti. Quando i pin, usati come uscite, saranno al livello basso permetteranno alla corrente di scorrere dall'alimentazione a massa accendendo il LED. Naturalmente serve un resistore per limitare la corrente nel LED; il suo dimensionamento si fa considerando una Vf di 2 Volt uguale per tutti i LED e una corrente di 5 mA5):

`R = (V_(\C\C)-V_F)/(I_d) = (3 - 2)/0.002 = 500 \Omega`

Scegliamo il valore più vicino della serie commerciale E12, quindi 470Ω.

Il buzzer può essere collegato direttamente tra l'alimentazione e un'uscita del microcontrollore. Per produrre un suono di una certa tonalità (una nota) l'uscita dovrà commutare tra il valore alto e basso ad una determinata frequenza (ad esempio a 440Hz sentiremo la nota La).

Circuito di principio e circuito finale

Fatte queste considerazioni il circuito di principio si presenta così:

schematico di principio simon

Osserviamo che:

  • il circuito non è simulabile (non si simula un microcontrollore!)
  • il componente ATtiny13A non è disponibile in Multisim e va creato
  • tutti i componenti neri non hanno un footprint e non vengono considerati quandi si passa Ultiboard per progettare il PCB; bisogna assegnargli un footprint o sostituirli con componenti blu o verdi
  • il colore dei LED non è importante perché in fase di montaggio si possono montare in qualunque ordine (i resistori sono tutti uguali)

Ci sono allora una serie di modifiche da fare e bisogna:

  • creare i footprint di alcuni componenti (portabatteria, buzzer, pulsanti)
  • creare i componenti ATtiny13A, portabatteria, pulsante6)
  • assegnare i footprint corretti agli altri componenti, se possibile (LED e buzzer non lo consentono e bisogna farlo in Ultiboard)

Prima di creare i componenti conviene creare i footprint in Ultiboard usando le informazioni contenute nei datasheet. L'abbinamento componenti-footprint è questo:

  • resistori: RES10
  • LED: LED5R2_5V, da cambiare in Ultiboard
  • ATtiny13A: PDIP-8(P), da indicare quando si crea il componente
  • pulsanti: footprint custom TACT-SPST da creare in Ultiboard
  • portabatteria: footprint custom DS1092-05 da creare in Ultiboard
  • buzzer: footprint custom LD-BZPN-1307 da creare in Ultiboard

Fatte queste considerazioni e creati i componenti ATtiny13A, portabatteria e buzzer si ottiene il circuito finale:

Creare un componente in Multisim

Si usa una procedura guidata:

  • scegliere dal menu Tools|Component Wizard
  • step 1: indicare nome, autore (produttore), funzione svolta e selezionare Layout Only
  • step 2: selezionare un package dal database Master (o uno custom dal database User se lo si è creato), lasciare single section, e indicare il numero dei pin
  • step 3: accettare, copiare o modificare il simbolo del componente (c'è un apposito editor)
  • step 4: indicare il nome dei pin in base a quanto riportato nei datasheet (la tipologia è poco importante)
  • step 5: associare correttamente i pin del simbolo a quelli del footprint
  • step 6: creare una nuova famiglia in una gruppo del database User (o selezionarne una esistente) e cliccare su Finish

Terminata la procedura è possibile piazzare il componente nello schematico. Controllare che la sigla associata (il RefDes) sia corretta7), altrimenti modificarla da Tools|Database|Database manager|scheda Family|Default prefix.

Indicazioni per la creazione del componente ATtiny13A:

  • step 1: ATtiny13A, ATMEL, microcontroller, layout only
  • step 2: selezionare PDIP-8(P) dal database Master, single section, 8 pin
  • step 3: accettare il simbolo proposto
  • step 4: nominare i pin come indicato a pagina 2 del datasheet
  • step 5: associare i pin usando il bottone auto-assign (controllare che la corrispondenza pin del simbolo e pin del footprint sia corretta ed eventualmente correggere)
  • step 6: creare la famiglia ATMEL nel gruppo MCU del database User e cliccare su Finish

Per creare correttamente i componenti portabatteria e pulsante bisogna prima aver creato i rispettivi footprint custom in Ultiboard. Per il pulsante c'è un problema in più: i 4 piedini sono collegati internamente due a due (vedi il datasheet a pag. 4) ma Ultiboard non permette di avere più piedini con lo stesso nome nei footprint. La soluzione più semplice è quella di usare un simbolo con 4 piedini e collegare le coppie di piedini nello schematico (vedi figura sopra).

Indicazioni per la creazione del pulsante TACT-65R-F:

  • step 1: TACT-65R-F, NINIGI, Tactile Switch SPST-NO, layout only
  • step 2: footprint custom TACT-SPST da creare in Ultiboard copiandolo da SKHH1_1 (in Through Hole Technoly Parts|Buttons and Switches|Tact) e aggiustando la piedinatura, single section, 4 pin
  • step 3: copiare da DPST-2NO-DB (Electro mechanical|Supplementary switches) e modificare aggiustando il nome dei pin del simbolo
  • step 4: nominare i pin come indicato nel datasheet
  • step 5: associare i pin usando il bottone auto-assign (controllare che la corrispondenza pin del simbolo e pin del footprint sia corretta ed eventualmente correggere)
  • step 6: creare la famiglia SWITCH nel gruppo Basic del database User e cliccare su Finish

Indicazioni per la creazione del portabatteria DS1092-05:

  • step 1: DS1092-05, Connfly, CR2032 battery holder, layout only
  • step 2: footprint custom DS1092-05 da creare in Ultiboard secondo usando le informazioni contenute nel datasheet
  • step 3: copiare da 1028 (in Connectors|POWER)
  • step 4: accettare la piedinatura
  • step 5: associare i pin controllando la corrispondenza pin del simbolo e pin del footprint come indicata nel datasheet
  • step 6: creare la famiglia Connectors nel gruppo Basic del database User e cliccare su Finish

Layout del PCB

Requisiti per la realizzazione nella sala acidi della scuola:

  • single layer
  • piste da 1 mm
  • testo specchiato col nome dello studente
  • massimo 2 piste sotto l'integrato

Altri requisiti:

  • dimensioni massime 6 x 5 cm
  • pulsanti facilmente raggiungibili
  • minimizzare ingombri

Indicazioni varie:

  • imparare a usare i filtri di selezione!
  • ridimensionare il board outline prima di piazzare i componenti (selezionare il layer Board outline e attivare il filtro Enable selecting other objects per cambiare le dimensioni del rettangolo giallo che delimita il PCB)
  • posizionare e ruotare i componenti per facilitare lo sbroglio
  • disabilitare l'opzione Part Shoving dal menu Desing per poter avvicinare tra loro i componenti
  • impostare l'ampiezza delle tracce dalla spreadsheet view (selezionarle tutte dalla scheda Nete cambiare il campo width)
  • dove è possibile usare piazzole circolari con foro da 0,6mm e diametro 2,6mm
  • per i componenti con i pin troppo vicini tra loro usare piazzole ovali custom o piazzole rettangolari
  • imparare a creare footprint custom

Cominciamo così:

  • la prima volta che si passa da Multisim a Ultiboard si usa Transfer|Transfer to Ultiboard; viene generata una netlist, cioè un file che contiene le indicazioni su quali componenti piazzare nel PCB, quale footprint hanno i componenti e come sono collegati tra loro
  • se dopo aver creato il file Ultiboard si fanno modifiche nello schematico in Multisim bisogna riportarle usando Transfer|Forward Annotate to Ultiboard invece che Transfer|Transfer to Ultiboard; in questo modo non si perde il lavoro fatto ma si prosegue il lavoro con una nuova netlist che tiene conto delle modifiche fatte
  • la prima cosa da fare è guardare il layout di ogni componente per capire se è sbagliato (nel dubbio misurare o guardare il footprint nel database usando il pulsante Show Dimensions); i footprint sbagliati si cambiano dalla Spreadsheet View cliccando sulla casella corrispondente nella colonna Footprint della scheda Parts e selezionandoli dal database; vanno sicuramente sistemati i footprint di LED e buzzer perché non è possibile scegliere quelli giusti in Multisim

Dopo aver ridimensionato il PCB si dovrebbe ottenere qualcosa di simile:

inizio sbroglio

Da qui si procede con lo sbroglio, piazzando i componenti e tracciando le piste. Qualche indicazione:

  • bisogna fare più tentativi, spostando i componenti e ridisegnando le piste, per trovare la soluzione migliore
  • seguire le Ratsnest (linee gialle che indicano quali piedini vanno collegati tra loro) e tracciare le piste usando sempre il layer Copper Bottom (rosso) e la larghezza di 1 mm
  • fare attenzione a non sovrapporre piste/piazzole che non si devono toccare
  • verificare che la clearance (distanza minima da piste e piazzole) sia almeno di 0.5 mm (si può impostare in Options|PCB Options per segnalare automaticamente gli errori col DRC)
  • verificare che il PCB abbia l'aspetto previsto aiutandosi con il render 3D (View|3D Preview)
  • a sbroglio completato verificare che il progetto non contenga errori osservando il risultato nella scheda Results della Spreadsheet View degli strumenti:
    • Desing|Connectivity Check controlla che tutti i collegamenti previsti nello schematico siano stati realizzati nel PCB
    • Desing|DRC and netlist check controlla che non ci siano errori nel modo in cui è stato disegnato il PCB

Il render 3D ha questo aspetto:

render 3D

Creare un footprint

Ultiboard organizza i footprint in più database; quello predefinito si chiama Ultiboard Master e contiene i footprint di migliaia di componenti. Quando un progetto include un componente il cui footprint che non è disponibile in questo database bisogna crearne uno custom e salvarlo nel database User. Si può:

  • creare il footprint da zero e salvarlo nel database User
  • copiare un footprint dal database master per poi modificarlo e salvarlo nel database User
  • importare un footprint da un file Ultiboard dal Database Manager

Il footprint di buzzer e portabatteria va creato da zero, quello dei pulsanti si può fare modificandone uno di Ultiboard.

Per creare un footprint custom:

  • dal menu Tools scegliere Database|Database Manager
  • nella vista ad albero a sinistra selezionare User database (in questa fase, volendo si può creare un gruppo/sottogruppo per catalogare i footprint con Create New Group o importare un footprint da un progetto esistente)
  • cliccare l'icona Create new part (tratteggiata) e selezionare PCB part per creare un footprint (Custom Pad Shape serve a creare una piazzola)
  • l'editor dei footprint mostrerà solo l'etichetta per Value e RefDes del componente8); questi elementi di testo possono essere spostati, resi invisibili o modificati (ad esempio J va bene per un connettore, U per un integrato, ecc.)
  • piazzare i pin con Place|Pins indicando posizione, distanza e disposizione (file/righe), tipo di piazzola
  • utilizzando il layer Silkscreen Top disegnare il layout (contorno) del componente usando gli strumenti del menu Place|Graphics
  • dopo aver controllato attentamente le dimensioni del layout9), la distanza tra i piedini e il posizionamento dei piedini nel layout del componente salvare il footprint nel database User (eventualmente in un gruppo adatto) dandogli un nome significativo

Creare una piazzola custom

I LED e l'ATtiny13A hanno dei pin molto vicini tra loro (100mil = 2,54mm) e non è possibili utilizzare piazzole rotonde delle dimensioni proposte sopra (2,6mm) perché si toccherebbero tra loro. Bisogna usare piazzole rettangolari o - meglio ancora - ovali. Ultiboard permette di creare piazzole ovali in maniera molto semplice (selezionandole e scegliendo round rectangle come forma) ma purtroppo non vengono stampate (è un bug del programma) quindi, se si vogliono piazzole ovali, bisogna creare delle piazzole custom.

Creare la piazzola custom:

  • dal menu Tools scegliere Database|Database Manager
  • nella vista ad albero a sinistra selezionare User database
  • cliccare l'icona Create new part (tratteggiata)
  • selezionare Custom pad shape
  • cliccare l'icona Rounded rectangle e disegnare la piazzola ovale (3 click)
  • aprire la finestra delle proprietà della piazzola e aggiustare larghezza, altezza e raggio così: larghezza 3mm, altezza 1.8 mm, raggio 0.9
  • impostare il centrare la piazzola usando come riferimento la croce bianca col cerchio (si possono usare anche le coordinate X e Y per centrare la piazzola impostandole a metà del valore della larghezza e altezza)
  • salvare la piazzola nello indicando un nome

Per utilizzare la piazzola custom dal layout aprire la finestra delle proprietà di una piazzola e selezionare il pulsante accanto alla scritta Custom. Poi scegliere la piazzola creata. Se la piazzola è orientata male (per esempio orizzontale invece che verticale) si può ruotarla selezionandola e impostando 90° nel campo Rotation della scheda General.

Modificare una piazzola custom:

  • dal menu Tools scegliere Database|Database Manager
  • nella vista ad albero a sinistra selezionare User database
  • selezionare la piazzola e cliccando col tasto destro scegliere Edit
  • modificare la piazzola e salvare
  • se la piazzola non è centrata o è spostata rispetto al foro modificare la posizione del reference point da Desing|Set reference point
  • le modifiche non vengono applicate alle piazzole custom già inserite nel layout, bisogna selezionarle nuovamente e scegliere di nuovo la piazzola custom aggiornata

E' possibile importare una piazzola custom nel database User da un file Ultiboard selezionando la piazzola e scegliendo Tools|Database|Add selection to Database. In questo caso può darsi che il reference point sia nella posizione sbagliata. In questo caso modificare la piazzola importata riposizionando il reference point come indicato sopra.

Software

FIXME spiegazione del codice

/*
 * Copyright (c) 2016 Divadlo fyziky UDiF (www.udif.cz)
 * 
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
 
#include <avr/sleep.h>
#include <util/delay_basic.h>
#include <avr/eeprom.h>
 
const uint8_t buttons[4] = {
  0b00001010, 0b00000110, 0b00000011, 0b00010010
};
const uint8_t tones[4] = {
  239, 179, 143, 119
};
uint8_t lastKey;
uint8_t lvl = 0;
uint8_t maxLvl;
// uint32_t ctx; // too big
uint16_t ctx;
uint16_t seed;
volatile uint8_t nrot = 8;
volatile uint16_t time;
 
void sleepNow() {
  PORTB = 0b00000000; // disable all pull-up resistors
  cli(); // disable all interrupts
  WDTCR = 0; // turn off the Watchdog timer
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();
  sleep_cpu();
}
 
void play(uint8_t i, uint16_t t = 45000) {
  PORTB = 0b00000000;  // set all button pins low or disable pull-up resistors
  DDRB = buttons[i]; // set speaker and #i button pin as output
  OCR0A = tones[i];
  OCR0B = tones[i] >> 1;
  TCCR0B = (1 << WGM02) | (1 << CS01); // prescaler /8
  _delay_loop_2(t);
  TCCR0B = 0b00000000; // no clock source (Timer0 stopped)
  DDRB = 0b00000000;
  PORTB = 0b00011101;
}
 
void gameOver() {
  for (uint8_t i = 0; i < 4; i++) {
    play(3 - i, 25000);
  }
  if (lvl > maxLvl) {
    eeprom_write_byte((uint8_t*) 0, ~lvl); // write best score
    eeprom_write_byte((uint8_t*) 1, (seed >> 8)); // write high byte of seed
    eeprom_write_byte((uint8_t*) 2, (seed & 0b11111111)); // write low byte of seed
    //eeprom_write_word((uint16_t*) 1, seed); // write seed
    for (uint8_t i = 0; i < 3; i++) { // play best score melody
      levelUp();
    }
  }
  sleepNow();
}
 
void levelUp() {
  for (uint8_t i = 0; i < 4; i++) {
    play(i, 25000);
  }
}
 
uint8_t simple_random4() {
  // ctx = ctx * 1103515245 + 12345; // too big for ATtiny13
  ctx = 2053 * ctx + 13849;
  uint8_t temp = ctx ^ (ctx >> 8); // XOR two bytes
  temp ^= (temp >> 4); // XOR two nibbles
  return (temp ^ (temp >> 2)) & 0b00000011; // XOR two pairs of bits and return remainder after division by 4
}
 
ISR(WDT_vect) {
  time++; // increase each 16 ms
  if (nrot) { // random seed generation
    nrot--;
    seed = (seed << 1) ^ TCNT0;
  }
}
 
void resetCtx() {
  ctx = seed;
}
 
int main(void) {
  PORTB = 0b00011101; // enable pull-up resistors on 4 game buttons
 
  ADCSRA |= (1 << ADEN); // enable ADC
  ADCSRA |= (1 << ADSC); // start the conversion on unconnected ADC0 (ADMUX = 0b00000000 by default)
  // ADCSRA = (1 << ADEN) | (1 << ADSC); // enable ADC and start the conversion on unconnected ADC0 (ADMUX = 0b00000000 by default)
  while (ADCSRA & (1 << ADSC)); // ADSC is cleared when the conversion finishes
  seed = ADCL; // set seed to lower ADC byte
  ADCSRA = 0b00000000; // turn off ADC
 
  WDTCR = (1 << WDTIE); // start watchdog timer with 16ms prescaller (interrupt mode)
  sei(); // global interrupt enable
  TCCR0B = (1 << CS00); // Timer0 in normal mode (no prescaler)
 
  while (nrot); // repeat for fist 8 WDT interrupts to shuffle the seed
 
  TCCR0A = (1 << COM0B1) | (0 << COM0B0) | (0 << WGM01)  | (1 << WGM00); // set Timer0 to phase correct PWM
 
  maxLvl = ~eeprom_read_byte((uint8_t*) 0); // read best score from eeprom
 
  switch (PINB & 0b00011101) {
    case 0b00010101: // red button is pressed during reset
      eeprom_write_byte((uint8_t*) 0, 255); // reset best score
      maxLvl = 0;
      break;
    case 0b00001101: // green button is pressed during reset
      lvl = 255; // play random tones in an infinite loop
      break;
    case 0b00011001: // orange button is pressed during reset
      lvl = maxLvl; // start from max level and load seed from eeprom (no break here)
    case 0b00011100: // yellow button is pressed during reset
      seed = (((uint16_t) eeprom_read_byte((uint8_t*) 1)) << 8) | eeprom_read_byte((uint8_t*) 2);  // load seed from eeprom but start from first level
      break;
  }
 
  while (1) { // main loop
    resetCtx();
    for (uint8_t cnt = 0; cnt <= lvl; cnt++) { // never ends if lvl == 255
      _delay_loop_2(4400 + 489088 / (8 + lvl));
      play(simple_random4());
    }
    time = 0;
    lastKey = 5;
    resetCtx();
    for (uint8_t cnt = 0; cnt <= lvl; cnt++) {
      bool pressed = false;
      while (!pressed) {
        for (uint8_t i = 0; i < 4; i++) {
          if (!(PINB & buttons[i] & 0b00011101)) {
            if (time > 1 || i != lastKey) {
              play(i);
              pressed = true;
              uint8_t correct = simple_random4();
              if (i != correct) {
                for (uint8_t j = 0; j < 3; j++) {
                  _delay_loop_2(10000);
                  play(correct, 20000);
                }
                _delay_loop_2(65536);
                gameOver();
              }
              time = 0;
              lastKey = i;
              break;
            }
            time = 0;
          }
        }
        if (time > 4000) {
          sleepNow();
        }
      }
    }
    _delay_loop_2(65536);
    if (lvl < 254) {
      lvl++;
      levelUp(); // animation for completed level
      _delay_loop_2(45000);
    }
    else { // special animation for highest allowable (255th) level
      levelUp();
      gameOver(); // then turn off
    }
  }
}

Note

Il programma non usa nessuna delle funzioni di Arduino. Questo permette di ridurre la dimensione del programma compilato e migliora nettamente le prestazioni ma il programma è più complicato da scrivere ed è specifico per un determinato tipo di microcontrollore.

Programmazione del microcontrollore

Per programmare il micro ATtiny13A useremo una scheda Arduino Uno come programmatore come descritto in questo tutorial.

La soluzione più semplice è quella di usare una breadboard e sei cavi rigidi collegati come nella figura seguente10):

come collegare Arduino e ATtiny13 per programmarlo

Una soluzione più robusta e senza cavi volanti è quella di produrre uno shield11) con zoccolo ZIF dedicata:

shield per programmare gli ATtiny13A

Per utilizzare una scheda Arduino e il suo ambiente di sviluppo per programmare gli ATtiny13 bisogna prima di tutto:

  • caricare sulla scheda lo sketch ArduinoISP (da File → Esempi → 11. ArduinoISP)
  • inserire l'URL https://mcudude.github.io/MicroCore/package_MCUdude_MicroCore_index.json nel campo URL aggiuntive per il gestore schede delle impostazioni
  • installare il pacchetto MicroCore che serve per utilizzare gli ATtiny13A nell'ambiente di sviluppo Arduino da Gestore schede… nel menu Strumenti → Scheda

Fatto questo si inserisce il microcontrollore nello zoccolo ZIF (o nella breadboard con i collegamenti visti sopra) quindi si apre il programma che andrà caricato sull'ATtiny13A. Prima del caricamento bisogna modificare le impostazioni di default della scheda (che andranno ripristinate per tornare a utilizzare una scheda Arduino) scegliendo, dal menu Strumenti:

  • Scheda: ATtiny13
  • BOD: BOD disabled
  • Compiler LTO: LTO enabled
  • Clock: 1.2 MHz internal osc.
  • Porta: quella della scheda Arduino rilevata sopra
  • Programmatore: Arduino as ISP

A questo punto è possibile caricare il programma sull'ATtiny13A scegliendo Carica tramite un programmatore dal menu Sketch (NB non con il pulsante Carica che useremmo per programmare la scheda Arduino!).

Terminato il caricamento si può montare il microcontrollore sulla scheda Simon.

Volendo è possibile caricare un bootloader sugli ATtiny13A per utilizzarli al posto di una scheda Uno - ma ancora più limitata. Per farlo si usa la voce Scrivi bootloader dal menu Strumenti. Nel nostro caso non è necessario perché il programma non fa uso delle librerie Arduino e ci interessa solo compilare e “flashare” il firmware sul microcontrollore.

Assemblaggio

FIXME indicazioni sul montaggio

  • spazzolare la scheda per togliere il photoresist e facilitare la saldatura
  • come forare (punta da 0.8!)
  • come saldare (la punta! scaldare → 2mm di stagno → via stagno → via saldatore quando lo stagno si ha coperto la piazzola e abbracciato il reoforo (cono ok, palla NO!)
  • verso dei LED!!!
  • verso zoccolo!
  • verso portabatteria
  • il micro e la batteria si installano dopo (occhio al lato giusto per la batteria!)

La scheda assemblata avrà più o meno questo aspetto:

scheda simon assemblata

Risorse

Torna all'indice.

1)
anche il progetto finale di STA del 2012 era un clone del gioco ma realizzato su breadboard con Arduino
2)
vedere qui per una panoramica sulle batterie
3)
tensione diretta quando conducono
4)
quindi i LED blu non vanno bene
5)
la Vf dei quattro LED è diversa (dipende dal colore e dal materiale con cui è realizzato il LED) ma così scegliamo quattro resistori uguali e minimizziamo gli errori in fase di montaggio; la corrente è più bassa dei 20 mA standard per ridurre il consumo
6)
nessuno dei pulsanti disponibili in Multisim corrisponde a quelli in commercio
7)
J per il portabatteria, U per il microcontrollore, S per il pulsante
8)
il punto interrogativo indica dove comparirà un numero progressivo o un valore
9)
le misure si possono fare cliccando in un punto e osservando in basso a destra il valore delle coordinate e delle distanze dX dY e L
10)
LED e resistori non servono ma permettono di testare velocemente se la programmazione funziona caricando sul micro uno sketch che fa lampeggiare il led
This website uses cookies for visitor traffic analysis. By using the website, you agree with storing the cookies on your computer.More information
simon.txt · Ultima modifica: 2019/11/13 14:28 da admin