Scoreboard (Parte 1: il segnale VGA da un ATTINY45)
Questo progetto mira a mostrare un quadro di valutazione in un normale monitor VGA, controllato a distanza con un dispositivo Android (cellulare, tablet) via Bluetooth.
Una delle sfide stava cercando di usare componenti economici (fatta eccezione per il monitor) e Atmel ATTINY45 suoni ottimi per questo scopo. Può funzionare a 20 MHz con un oscillatore esterno, il lato negativo è che il numero di pin I / O a disposizione è molto limitato. L'oscillatore esterno avrà PB2 e PB3, utilizzando quindi un clock esterno (un cristallo con alcuni circuiti che genera TTL) ho potuto risparmiare PB2!, Purtroppo non ho uno, e non è facile da trovare qui.
Ci sono ancora disponibili, 4 sugli PB0 e PB1 saranno utilizzati per il HSYNC VGA e VSYNC rispettivamente, PB2 per generare il RGB (solo un colore!). PB5 per ottenere le informazioni di input che voglio visualizzare, speriamo che questo verrà da un modulo bluetooth appositamente messo a punto per questo, o da un altro ATTINY45 nel peggiore dei casi.
Generazione del segnale VGA
Sapevo che 20MHz sarebbe sufficiente per generare un output VGA accettabile a causa della Craft Linus Akesson del progetto. In questo caso si utilizza un ATmega88 con più porte I / O.. Come potete leggere nella sua pagina, questa è tutta una questione di tempi VGA. Inviare gli impulsi di sincronismo orizzontale e verticale al momento giusto è fondamentale, quindi la lingua più ovvia per avere il controllo di ogni ciclo usato era assembler (usando il compilatore gnu in questo caso).
Potete leggere di più su tempi VGA in Wikipedia e qui . Fondamentalmente mando un impulso HSYNC durante la cosiddetta "soppressione orizzontale" periodo appena prima della verniciatura ciascuna delle 480 linee. Dopo il 480, ho bisogno di inviare altri 45 righe per rendere il periodo di blanking verticale (non RGB viene inviata). Durante il periodo di interdizione ho anche bisogno di inviare l'impulso VSYNC, segnalando che il dipinto telaio sta per iniziare (a parlare in 'linee' il polso VSYNC sarà compreso tra la linea 10 e 12 del blanking verticale).
Il blanking orizzontale può essere diviso in tre parti: la 0.94μs portico, la sincronizzazione e il polso 3.77μs 1.89μs veranda sul retro. Approfitto di questi cicli per determinare quali informazioni debbano essere 'disegnate' in base al numero di riga. Dal momento che sto cercando di dipingere 4 numeri per visualizzare il punteggio, ho definito che ogni personaggio è 8 × 10 in modo che possa essere rappresentato in soli 10 byte. Quindi devo conservare la linea che ho bisogno di dipingere per ogni carattere in 4 diversi registri. Inoltre ho bisogno di ripetere la linea verticale di dare una certa altezza proporzionale ai personaggi è fatto questo mappando numero di riga a linee dei font in una tabella fissa. Ciò si tradurrà in caratteri molto brutte e grandi, ma va bene per l'ambito di questo progetto 
.
Schematico
No Aquila per ora, ma qui è uno schema ASCII del circuito.
ATTINY45
+ ----------------- +
| |
IN ---- | 1 (PB5) (VCC) 8 | ---- +5 V
22pF | |
+ - | | ---- + ------ | 2 (PB3) (PB2) 7 | ---- RGB
| [] XTAL | |
+ - | | ---- + ------ | 3 (PB4) (PB1) 6 | ---- VSYNC
| 22pF | |
--------------- + | 4 (GND) (PB0) 5 | ---- HSYNC
| | |
GND + ----------------- +
Nota: ho usato una sorgente esterna di alimentazione 12v con un 78L05 regolatore di tensione 5V. Nel mio caso è stato molto importante mettere due condensatori di filtro in ingresso e uscita del regolatore, senza di loro il rumore generato dal alimentazione non farà si che il monitor di sincronizzare correttamente.
Po 'di codice
Vediamo alcune parti interessanti.
Carattere definizione. Come ho detto i personaggi hanno una dimensione fissa di 8 × 10, nel codice che simile al seguente:
number0: . Byte 0b00000000 . Byte 0b00111000 . Byte 0b01000100 . Byte 0b01000100 . Byte 0b01000100 . Byte 0b01000100 . Byte 0b01000100 . Byte 0b00111000 . Byte 0b00000000 . Byte 0b00000000
La mappatura tra le righe dello schermo e le linee di carattere assomiglia a questo:
maplines1: ; Linee di mappa (da 50 a 205) . 0x00 byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 . 0x00 byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 . 0x00 byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 . 0x00 byte, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 . Byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 . Byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 . Byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 ...
Quindi le linee 50 e 88 saranno indirizzate verso la linea primo carattere (tengo 50 linee di margine in alto e 50 in basso, così ho effettivamente utilizzare le linee 380, divisi da dieci si tradurrà in 38 linee VGA per ogni linea di font).
Infine, per ottenere i dati di linea carattere determinato il numero di riga font (in r17), userò le istruzioni lpm in questo modo:
linefor0: LDI ZL, lo8 (number0) LDI ZH, Hi8 (number0) aggiungere ZL, R17 adc ZH, R22 lpm macerare
Il codice non sembrare complicato affatto. La parte complicata forse voleva essere sicuro di ottenere i tempi giusti, che saranno i cicli di misura utilizzati tra ogni parte del codice. Ho scoperto che AVR Studio è un grande strumento per il debug, tuttavia ciclo di misura tra le due istruzioni nel codice è qualcosa che può richiedere un certo tempo, ho trovato could't breakpoint condizionali, e facendo clic 480 volte il tasto "continua" per testare i limiti può essere un po 'fastidioso. Così, ho fatto un piccolo tool in Python / PySide di aiutarmi con questa misura. E 'come un emulatore assembler con solo poche istruzioni implementate e, naturalmente, il calcolo del ciclo.
Tutto, compreso il debugger AVR è disponibile per il download qui. Potete fare quello che vuoi con esso a proprio rischio, e nel caso in cui si sente più a suo agio con una licenza: BSD
Cose da fare per le parti successive:
- Una volta che il mio modulo Bluetooth a basso costo arriva dalla Cina, cercherò di sfruttarla. Se non riesco a modificare il suo firmware a tutti, io probabilmente finire con un secondo ATtiny facendo la comunicazione tra la mia tavola ATtiny VGA e il modulo.
- Eseguire il programma di Android per comunicare con il modulo Bluetooth (credo proprio un sacco di esempi in Internet)
- Ultima cosa, sarebbe cercare di migliorare i personaggi sullo schermo. Non ho troppa memoria nel ATtiny, e la capacità di elaborazione di certo non molto tra ogni pixel, ma credo che posso provare a emulare alcuni pixel squadrati, forse in questo modo:
Potrei evento cercare di ottenere il colore giallastro mettendo alcuni diodi nei cavi RGB corretti, ma questo è per il capitolo successivo.
Buon divertimento!
