ultimo aggiornamento: 30 Novembre 2014
English version

Un programmatore USB open source per PIC, ATMEL AVR, memorie EEPROM I2C-SPI-MicroWire-OneWire-UNIO, dispositivi I2C e SPI, e (in futuro) altri dispositivi

In breve
Un altro programmatore?
Firmware USB e HID
Programmi di controllo
Come fare per ...
Supporto
Protocollo di comunicazione
Schema elettrico
Regolatore switching
Come contribuire
Scarica
Cronologia
Risorse in rete
Contatti

In breve

• Completamente gratuito e Open Source (GPL2, anche il firmware)
• Programma PIC10-12-16-18-24, dsPIC30-33, ATMEL AVR (serial e HV serial programming), EEPROM seriali tipo 24xxxx (I2C), 25xxx (SPI), 93xx6 (MicroWire), DS24xx (OneWire), 11xxx (UNIO); comunica con dispositivi I2C e SPI (vedi supporto)
• Può funzionare da debugger ICD
• Interfaccia USB 2.0 Full Speed, classe HID (come tastiere, mouse ecc.)
• Auto alimentato
• Non ha bisogno di driver
• Componenti di facile reperibilità (costo stimato ~10€)
• Temporizzazioni gestite in hardware quindi veloce e affidabile (scrive un 18F2550 in 15s)
• Non occupa la CPU e non risente di altri programmi in esecuzione
• Programmi di controllo open source per Linux e Windows
• Non è un clone PicKit

Una foto del prototipo:

Un altro programmatore?

In questi ultimi anni, con la sparizione delle comodissime interfacce seriale e parallela, gli appassionati di elettronica si trovano sempre più in difficoltà nel programmare i microcontrollori; i classici programmatori non funzionano più e di solito si ricorre a convertitori USB-seriale (che però non si possono comandare direttamente ma solo via API, quindi lentamente) o a integrati di interfaccia da aggiungere al programmatore, tipo gli FTDIxxxx, che sostanzialmente appaiono come periferiche seriali o richiedono driver ad hoc. Ma perché non usare i PIC stessi, che hanno l'USB nativo?
Cercando in lungo e in largo non sono riuscito a trovare un programmatore USB che fosse funzionale, gratuito, open source, e così ho deciso di costruirmelo. La filosofia open source consiste nel fornire tutti gli schemi, sorgenti, informazioni utili a costruire e modificare questo programmatore.

Firmware USB e HID (v0.9.0)

Per usare l'interfaccia USB sui PIC è necessario un firmware che implementi una delle classi definite dal consorzio USB o una nuova; io ho scelto la classe HID perché è supportata in modo nativo da tutti i sistemi operativi e quindi non necessita di alcun driver. La velocità è più che sufficiente: in teoria si raggiungerebbero i 64KB/s, ma io ho misurato qualcosa come 20-40 KB/s, comunque sicuramente abbastanza per programmare dispositivi di 1-100KB di memoria.
Come ogni periferica USB anche questa ha un identificativo vid e pid, da ottenere ovviamente a pagamento; siccome io non ho un soldo da sprecare né ho da vendere il progetto, ho usato il vid della Microchip e un pid a caso: 0x4D8&0x100; sono entrambi configurabili a piacere (previa compilazione), quindi lascio all'utente la scelta.
Il programmatore appare al sistema come una periferica HID che comunica tramite pacchetti di 64 byte scambiati con cadenza di 1ms.
L'implementazione del firmware USB viene da un progetto open source poco noto, scritto da Alexander Enzmann, che io ho modificato e adattato al compilatore C18.
Ho anche scritto una breve guida su come usarlo; per quanto ne so io questo è l'unico firmware open source con supporto HID.
Il programmatore in se è semplicemente un interprete di comandi che pilota direttamente le uscite del micro seguendo un apposito insieme di istruzioni.
Il ciclo di controllo principale aspetta che venga ricevuto un pacchetto via USB, poi comincia a eseguire i comandi specificati occupandosi tra l'uno e l'altro della comunicazione col pc; allo stesso tempo gira la funzione di controllo del regolatore di tensione DCDC, chiamata a intervalli regolari tramite un timer (e un interrupt).
Compilare il tutto richiede solo strumenti gratuti: MPLAB e MCC18 versione studenti, disponibili sfortunatamente solo per il sistema (in)operativo a finestre.
Compilare con SDCC è sicuramente possibile ma richiede qualche modifica al sorgente.
Rilascio il tutto con licenza GPL2.
Qui si trova il progetto MPLAB completo in formato compresso; qui il firmware compilato in formato hex.
Qui il firmware (0.8.0) compilato per 18F2450 (con funzionalità ridotta, vedi schema elettrico).

Programmi di controllo

La mia idea iniziale era di modificare un software già esistente, ad esempio winpic o picprog, ma mi sono accorto che visto il tipo di comunicazione necessario, basato su pacchetti anziché seriale, non avrei potuto adattarli facilmente, quindi ho dovuto scriverne uno (due) da zero.
Purtroppo, o per fortuna, non essendo un informatico ho tagliato quasi tutto il superfluo: l'interfaccia utente è davvero minima, ci sono sicuramente dei bachi che mi impegno a eliminare, e mancano delle funzionalità come la modifica del codice a posteriori.
Però sono programmi molto snelli, piuttosto veloci, e non occupano la CPU per niente.
Quando possibile la scrittura viene verificata durante la programmazione, altrimenti immediatamente dopo.
Idealmente la versione del programma e del firmware dovrebbe essere la stessa, a parte l'ultimo numero che indica piccoli cambiamenti e correzioni; in generale però ho cercato di non stravolgere il protocollo con le nuove versioni, per cui a parte le novità introdotte in ogni rilascio è quasi sempre possibile usare un programma nuovo con un firmware vecchio e vice versa.
A quanti si chiedono come mai non sia possibile programmare direttamente da MPLAB rispondo che non ci sono difficoltà tecniche, ma la Microchip non rilascia informazioni di pubblico dominio su come farlo; per averle bisogna essere dei produttori commerciali e firmare un contratto di non diffusione, cosa evidentemente impossibile per un progetto open source GPL2.
Vice versa l'integrazione con Piklab è possibile e spero si farà presto; attualmente l'interfaccia per programmatori custom è carente di alcuni parametri indispensabili, ma chi avesse tempo e voglia può certamente modificare il codice e far funzionare il tutto.

Interfaccia grafica GTK, per Linux e Windows (v0.9.1)

OPGUI sfrutta le librerie GTK, per cui su Windows è necessario installare anche il Runtime Environment GTK.
La schermata principale del programma:

In breve: i pulsanti sulla barra di comando permettono di leggere, scrivere, caricare e salvare file.
La scheda "Dati" presenta le informazioni su cosa fa il programmatore.
Sulla scheda "Dispositivo" si sceglie il dispositivo da scrivere o leggere e si possono modificare alcune opzioni di programmazione, per esempio la scrittura delle locazioni ID, di calibrazione, l'uso della eeprom ecc.; solo le impostazioni compatibili col dispositivo selezionato vengono prese in considerazione.
Tra le "Opzioni" ci sono: connessione col programmatore, errori ammessi in scrittura, salvataggio dei pacchetti dati trasferiti, uso delle schede di espansione; con la funzione "Test Hardware" e un multimetro è possibile verificare che il circuito stia effettivamente funzionando.
La scheda "I2C/SPI" permette di comunicare con dispositivi generici I2C e SPI; se si utilizza il protocollo I2C bisogna sempre specificare il byte di controllo (e l'indirizzo se diverso da 0); il bit RW viene gestito automaticamente.
Ad esempio per scrivere manualmente 3 byte su una 24xx16 all'indirizzo 64 si scrive: A0 40 1 2 3
Dalla versione 0.7.10 è incluso un debugger ICD, che funziona più o meno come pdb, ma con supporto per file coff.
Su "I/O" si possono controllare manualmente le linee di I/O e le alimentazioni.
Con "Utility" si può convertire le singola linea di un file HEX in dati e vice-versa.
Non è previsto alcun programma di installazione; è sufficiente scaricare l'eseguibile e avviarlo.
Il programma scrive e legge file hex8 e hex32, e anche file binari per le memorie seriali.
Le lingue supportate sono Italiano e Inglese; per introdurre altre lingue bisogna generare il file languages.rc (opzione -langfile) e modificarlo a piacimento; il codice della lingua è prima delle rispettive stringhe, tra parentesi quadre [].
All'avvio il programma sceglie la lingua in base a quella del sistema operativo (si può anche forzare tramite l'opzione -lang).
Per abilitare l'accesso al programmatore su Linux vedere il capitolo Interfaccia da linea di comando.
Per maggiori informazioni scarica la guida all'uso di OpenProg e Opgui
Compilazione (opzionale): bisogna avere installato le librerie GTK, GCC e i vari maketools (MinGW/MSYS su Windows) e digitare:
> make
Successivamente per installare (su Linux, ma non è obbligatorio):
> make install
Scarica il programma ... o i sorgenti

Interfaccia grafica per Windows (v0.9.1)

OpenProg è scritto in VisualC++ 6.0 usando MFC.
La schermata principale del programma:

Sono implementate solo le funzioni base di programmazione; è stata la prima interfaccia grafica del progetto, ma ora lo sviluppo procede su OPGUI, quindi potrebbe essere dismessa in futuro.
Ha il vantaggio di funzionare senza alcuna libreria aggiuntiva.
L'utilizzo è identico a OPGUI; funziona con XP, sVista, 7, 8.
Le opzioni da linea di comando sono:
-d <dispositivo> , seleziona un dispositivo
-r <nome file> , legge dal dispositivo e scrive sul file
-w <nome file> , legge il file e scrive sul dispositivo
-gui , apre la GUI dopo la scrittura o la lettura (solo se specificati -w o -r)
Per maggiori informazioni scarica la guida all'uso di OpenProg e Opgui
Potrà risultare interessante il fatto che per la compilazione non è necessario usare il DDK (driver development kit); nel codice c'è il link esplicito alla libreria di sistema hid.dll, e le funzioni che servono vengono caricate a mano.
Scarica il programma ... o i sorgenti (progetto Visual Studio 6)

Interfaccia per linea di comando (Linux e Windows, v0.9.1)

OP è un eseguibile da linea di comando; la versione Windows non ha bisogno di installazione.
Su Linux il programma si interfaccia col dispositivo /dev/usb/hiddevX (o quello che si specifica) e ha bisogno dei diritti di lettura su hiddevX.
es. >sudo chmod a+r /dev/usb/hiddev0
Per abilitare permanentemente un utente alla lettura si può procedere come segue (su Ubuntu e altre distribuzioni basate su Debian, verificare per le altre):
autenticarsi come root; creare un file /etc/udev/rules.d/10-openprogrammer.rules
nel caso si voglia abilitare un gruppo di utenti scrivervi:
   KERNEL=="hiddev[0-9]", ATTRS{idProduct}=="0100", ATTRS{idVendor}=="04d8", GROUP="<gruppo>", SYMLINK+="openprogrammer"
in cui <gruppo> è uno dei gruppi a cui appartiene l'utente (per un elenco digitare "groups", utilizzare un gruppo adeguato e se necessario aggiungere l'utente al gruppo scelto ("addgroup <utente> <gruppo>").
oppure, nel caso si vogliano abilitare tutti gli utenti, cambiare solo i permessi di lettura:
   KERNEL=="hiddev[0-9]", ATTRS{idProduct}=="0100", ATTRS{idVendor}=="04d8", MODE="0664", SYMLINK+="openprogrammer"
riavviare udev per applicare le modifiche:
> udevadm control --reload-rules
> udevadm trigger
Ora, ogni volta che il sistema vede il programmatore, il corrispondente /dev/usb/hiddevX ha i permessi giusti e viene creato anche un link /dev/openprogrammer

Se collegando il programmatore non appare la periferica /dev/usb/hiddevX (e il LED non lampeggia a 1 Hz) è sufficiente eseguire alcune volte lsusb per forzare l'enumerazione da parte del sistema, eventualmente staccando e riattaccando il cavo.

OP si aspetta una periferica USB con vid&pid=0x4d8:0x100, se non specificato altrimenti.
Scrive e legge file hex8 e hex32 e anche binari per le memorie seriali.
Con l'opzione --HWtest e un multimetro è possibile verificare che il circuito stia effettivamente funzionando.
E' possibile comunicare via I2C e SPI con dispositivi generici diversi dalle memorie; nel caso I2C bisogna specificare byte di controllo e indirizzo (o indirizzi) anche per una lettura; il bit RW viene gestito automaticamente.
Nel caso di problemi o per pura curiosità si possono salvare tutti i dati scambiati col programmatore, tramite l'opzione -l; per qualche strano motivo per specificarne il parametro opzionale bisogna usare -l=<file> (chissà perché, sarà un baco di getopt?)
Il supporto multilingue comprende Italiano e Inglese; si può ampliare generando e modificando il file languages.rc.

Un errore frequente è specificare il nome del dispositivo con lettere minuscole invece che maiuscole:
si scrive 16F628, non 16f628

Compilazione (opzionale): è presente un makefile, quindi per compilare bisogna avere installato GCC e i vari maketools (MinGW/MSYS su Windows) e digitare:
> make
Successivamente per installare (su Linux, ma non è obbligatorio):
> make install

Ho incluso anche l'utility Hid_test, che spedisce e riceve un pacchetto (64 byte) alla volta; può essere utile per fare qualche esperimento; in teoria ci si potrebbe addirittura scrivere uno script di programmazione.

Scarica i sorgenti

Come fare per ...

Cancellare un dispositivo: ogni dispositivo viene cancellato prima della programmazione; se comunque si volesse cancellarlo basterebbe scrivere un file hex con dati validi (<0xFF) oltre lo spazio di memoria.
Per esempio, per i PIC12-16:
:020000040000FA
:0144010000BA
:00000001FF
E per i PIC18:
:020000040002F8
:020000000000FE
:00000001FF

Cambiare Configuration Word dei PIC: Le Config Word sono di norma specificate nel file hex, ma si possono forzare per i PIC 10-12-16-18 tramite le opzioni del dispositivo (o da linea di comando).
In alternativa si può cambiare il sorgente e ricompilare; oppure bisogna modificare il file hex; per i PIC16 i dati si trovano all'indirizzo 0x2007, che nel file corrisponde a 0x400E; l'ultimo byte della riga in questione è il checksum, calcolato come complemento a 2 della somma dei byte della riga.
Per esempio:
:02400E00xxxxCC con xxxx nuovo valore e CC checksum

Cambiare la configurazione degli Atmel AVR: contrariamente ai PIC, che mappano la configurazione nella memoria programma e quindi nel file hex, gli Atmel AVR devono essere configurati a mano, scrivendo il valore desiderato dei byte di Fuse/Lock tra le opzioni del dispositivo; non è detto che sia necessario cambiare la configurazione di fabbrica di tutti i byte, dipende dall'applicazione.

Risolvere l' "errore di sincronizzazione" con gli AVR: Una possibile causa è la velocità troppo elevata della SPI in relazione a quella della CPU; la frequenza interna deve infatti essere > 4 x frequenza SPI
Le innumerevoli impostazioni dei dispositivi potrebbero comportare che la CPU veda un clock anche molto basso; il (nuovo) algoritmo di comunicazione varia automaticamente la velocità SPI in modo da entrare comunque in Program Mode.
Naturalmente più è bassa la velocità più si allungherà il tempo di lettura/scrittura; per velocizzare le operazioni si potrebbe scrivere un file vuoto insieme con una configurazione ad alta velocità, e successivamente scrivere (velocemente) il vero file con le impostazioni finali.
In alcuni dispositivi è possibile impostare frequenze estremamente basse (16 kHz), fuori dalla portata dell'algoritmo normale; in questo caso l'opzione "scrivi Fuse Low @3 kHz" riesce a scrivere il byte Fuse Low; basta quindi specificare un valore che riporti la frequenza a valori accettabili, e successivamente scrivere nel modo normale.
La seconda possibile causa è che la programmazione seriale è stata disabilitata: questo può essere fatto solo usando un programmatore parallelo, e lo stesso è necessario per riabilitarla.
La terza causa è che in configurazione con risuonatore esterno il piedino X2 non è libero di muoversi; nel caso si usi l'espansione AVR assicurarsi che X2 non sia a massa.

Verificare che un dispositivo sia vuoto: basta leggerlo ed esaminare i dati; vengono mostrate solo le righe con dati <0xFF, quindi se non sono visualizzati dati il dispositivo è vuoto.

Verificare la corretta scrittura su un dispositivo: tutti gli algoritmi di scrittura eseguono una verifica dei dati, alcuni durante la scrittura stessa, altri dopo; se il programma riporta 0 errori significa che effettivamente non ci sono stati errori.
Se comunque si volesse fare una ulteriore verifica basterebbe rileggere dal dispositivo e confrontare i dati, tenendo presente che non tutti i bit sono sempre implementati; per esempio i PIC16 vengono organizzati in word di 14 bit, quindi anche se nel sorgente viene indicato 0xFFFF questo viene scritto come 0x3FFF; inoltre le Config Word hanno spesso dei bit fissi a 0 (che quindi non sono verificati).

Leggere l'area riservata: quasi tutti i PIC hanno un'area di memoria oltre le Config Word che è riservata per test di produzione o calibrazione; per esaminarla basta abilitare la relativa opzione prima della lettura; nei PIC24-30-33 viene letta anche l'area di memoria executive.

Usare correttamente i valori di calibrazione e OscCal: in alcuni dispositivi (es. i 12F5xx) il valore di calibrazione dell'oscillatore interno è scritto (in fabbrica) all'ultimo indirizzo della memoria programma e anche in una locazione di riserva oltre l'area ID; dopo una cancellazione i programmi ripristinano il primo col valore di riserva a meno che non venga specificato altrimenti; le altre opzioni sono: usare il valore salvato prima della cancellazione (che di norma coincide con quello di riserva, a meno che uno dei due non sia stato cambiato prima), usare il valore indicato nel file .hex.
E' inoltre possibile sovrascrivere il valore di riserva con quanto specificato nel file .hex, abilitando l'opzione "programma ID e BKosccal"; in questo caso verranno scritte anche le locazioni ID, se specificate nel file.
Invece per sovrascrivere le locazioni di calibrazione bisogna usare l'opzione "programma Calib1 e 2"

Supporto

Il programmatore è stato provato su un numero ristretto di dispositivi (quelli che posseggo e altri provati da alcuni utenti) indicati in neretto; gli altri sono supportati ma non collaudati; comunque, considerando che per ogni famiglia di dispositivi almeno uno è stato verificato, dovrebbero funzionare tutti senza problemi.
Chi avesse la possibilità di verificarne la funzionalità è pregato di farmelo sapere.
Ugualmente chi avesse bisogno di ampliare il supporto o scrivesse altri algoritmi può contattarmi.
Nota bene:
I PIC serie LF sono usati come quelli F;
gli Atmel AVR con vari suffissi sono raggruppati se usano lo stesso algoritmo, es. ATmega8 e ATmega8A;
le memorie EEPROM comprendono tutte le versioni con VDDmax=5V, es. 242LC56, 24AA256, ecc.;
le EEPROM 93xx richiedono 2 algoritmi diversi, per la serie 93S e per le altre, indicate come 93x (le 93xA hanno organizzazione a 8 bit).

supporto in lettura e scrittura:
10F200, 10F202, 10F204, 10F206, 10F220, 10F222, 10F320, 10F322,
12C508, 12C508A,12C509, 12C509A, 12F508, 12F509, 12F510, 12F519,
12F609, 12F615, 12F617, 12F629, 12F635, 12F675, 12F683,
12F752, 12F529T39, 12F529T48,
12F1501, 12F1571, 12F1572, 12F1612, 12F1822, 12F1840,
16F505, 16F506, 16F526, 16F527, 16F54, 16F57, 16F570, 16F59,
16F610, 16F616, 16F627, 16F627A, 16F628, 16F628A, 16F630, 16F631, 16F636, 16F639, 16F648A, 16F676, 16F677, 16F684, 16F685, 16F687, 16F688, 16F689, 16F690,
16F707, 16F716, 16F72, 16F720, 16F721, 16F722, 16F722A, 16F723, 16F723A, 16F724, 16F726, 16F727, 16F73, 16F737, 16F74, 16F747, 16F753, 16F76, 16F767, 16F77, 16F777, 16F785,
16F818, 16F819, 16C83, 16F83, 16F83A, 16C84, 16F84, 16F84A, 16F87, 16F870, 16F871, 16F872, 16F873, 16F873A, 16F874, 16F874A, 16F876, 16F876A, 16F877, 16F877A, 16F88, 16F882, 16F883, 16F884, 16F886, 16F887,
16F913, 16F914, 16F916, 16F917, 16F946,
16F1454, 16F1455, 16F1459, 16F1503, 16F1507, 16F1508, 16F1509, 16F1512, 16F1513, 16F1516, 16F1517, 16F1518, 16F1519, 16F1526, 16F1527, 16LF1554, 16LF1559, 16F1574, 16F1575, 16F1578, 16F1579, 16F1613, 16F1614, 16F1615, 16F1618, 16F1619, 16F1703, 16F1704, 16F1705, 16F1707, 16F1708, 16F1709, 16F1713, 16F1716, 16F1717, 16F1718, 16F1719, 16F1782, 16F1783, 16F1784, 16F1786, 16F1787, 16F1788, 16F1789, 16F1823, 16F1824, 16F1825, 16F1826, 16F1827, 16F1828, 16F1829, 16F1847, 16LF1902, 16LF1903, 16LF1904, 16LF1906, 16LF1907, 16F1933, 16F1934, 16F1936, 16F1937, 16F1938, 16F1939, 16F1946, 16F1947,
18F242, 18F248, 18F252, 18F258, 18F442, 18F448, 18F452, 18F458, 18F1220, 18F1230, 18F1320, 18F1330, 18F13K22, 18F13K50, 18F14K22, 18F14K50, 18F2220, 18F2221, 18F2320, 18F23K20, 18F23K22, 18F2321, 18F2331, 18F2410, 18F24J10, 18F24J11, 18F2420, 18F24K20, 18F24K22, 18F2423, 18F2431, 18F2439, 18F2450, 18F24J50, 18F24K50, 18F2455, 18F2458, 18F2480, 18F2510, 18F25J10, 18F25J11, 18F2515, 18F2520, 18F25K20, 18F25K22, 18F2523, 18F2525, 18F2539, 18F2550, 18F25J50, 18F25K50, 18F2553, 18F2580, 18F25K80, 18F2585, 18F2610, 18F26J11, 18F26J13, 18F2620, 18F26K20, 18F26K22, 18F26J50, 18F26K50, 18F26J53, 18F2680, 18F26K80, 18F2682, 18F2685, 18F27J13, 18F27J53, 18F4220, 18F4221, 18F4320, 18F43K20, 18F43K22, 18F4321, 18F4331, 18F4410, 18F44J10, 18F44J11, 18F4420, 18F44K20, 18F44K22, 18F4423, 18F4431, 18F4439, 18F4450, 18F44J50, 18F4455, 18F4458, 18F4480, 18F4510, 18F45J10, 18F45J11, 18F4515, 18F4520, 18F45K20, 18F45K22, 18F4523, 18F4525, 18F4539, 18F4550, 18F45J50, 18F45K50, 18F4553, 18F4580, 18F45K80, 18F4585, 18F4610, 18F46J11, 18F46J13, 18F4620, 18F46K20, 18F46K22, 18F46J50, 18F46K50, 18F46J53, 18F4680, 18F46K80, 18F4682, 18F4685, 18F47J13, 18F47J53, 18F63J11, 18F63J90, 18F64J11, 18F64J90, 18F65J10, 18F65J11, 18F65J15, 18F65J50, 18F65J90, 18F65K80, 18F66J10, 18F66J11, 18F66J15, 18F66J16, 18F66J50, 18F66J55, 18F66J60, 18F66J65, 18F66J90, 18F66J93, 18F67J10, 18F67J11, 18F67J50, 18F67J60, 18F66K80, 18F67J90, 18F67J93, 18F83J11, 18F83J90, 18F84J11, 18F84J90, 18F85J10, 18F85J11, 18F85J15, 18F85J50, 18F85J90, 18F8520, 18F86J10, 18F86J11, 18F86J15, 18F86J16, 18F86J50, 18F86J55, 18F86J60, 18F86J65, 18F86J72, 18F86J90, 18F86J93, 18F8722, 18F87J10, 18F87J11, 18F87J50, 18F87J60, 18F87J72, 18F87J90, 18F87J93, 18F96J60, 18F96J65, 18F97J60,
24F04KA200, 24F04KA201, 24F08KA101, 24F08KA102, 24F16KA101, 24F16KA102, 24FJ16GA002, 24FJ16GA004, 24FJ32GA002, 24FJ32GA004, 24FJ32GA102, 24FJ32GA104, 24FJ32GB002, 24FJ32GB004, 24FJ48GA002, 24FJ48GA004, 24FJ64GA002, 24FJ64GA004, 24FJ64GA006, 24FJ64GA008, 24FJ64GA010, 24FJ64GA102, 24FJ64GA104, 24FJ64GA306, 24FJ64GA308, 24FJ64GA310, 24FJ64GB002, 24FJ64GB004, 24FJ64GB106, 24FJ64GB108, 24FJ64GB110, 24FJ64GC006, 24FJ64GC008, 24FJ64GC010, 24FJ96GA006, 24FJ96GA008, 24FJ96GA010, 24FJ128GA006, 24FJ128GA008, 24FJ128GA010, 24FJ128GA106, 24FJ128GA108, 24FJ128GA110, 24FJ128GA306, 24FJ128GA308, 24FJ128GA310, 24FJ128GB106, 24FJ128GB108, 24FJ128GB110, 24FJ128GB206, 24FJ128GB210, 24FJ128GC006, 24FJ128GC008, 24FJ128GC010, 24FJ128DA106, 24FJ128DA110, 24FJ128DA206, 24FJ128DA210, 24FJ192GA106, 24FJ192GA108, 24FJ192GA110, 24FJ192GB106, 24FJ192GB108, 24FJ192GB110, 24FJ256GA106, 24FJ256GA108, 24FJ256GA110, 24FJ256GB106, 24FJ256GB108, 24FJ256GB110, 24FJ256GB206, 24FJ256GB210, 24FJ256DA106, 24FJ256DA110, 24FJ256DA206, 24FJ256DA210,
24EP32GP202, 24EP32GP203, 24EP32GP204, 24EP32MC202, 24EP32MC203, 24EP32MC204, 24EP64GP202, 24EP64GP203, 24EP64GP204, 24EP64GP206, 24EP64MC202, 24EP64MC203, 24EP64MC204, 24EP64MC206, 24EP128GP202, 24EP128GP204, 24EP128GP206, 24EP128MC202, 24EP128MC204, 24EP128MC206, 24EP256GP202, 24EP256GP204, 24EP256GP206, 24EP256MC202, 24EP256MC204, 24EP256MC206, 24EP512GP202, 24EP512GP204, 24EP512GP206, 24EP512MC202, 24EP512MC204, 24EP512MC206,
24HJ12GP201, 24HJ12GP202, 24HJ16GP304, 24HJ32GP202, 24HJ32GP204, 24HJ32GP302, 24HJ32GP304, 24HJ64GP202, 24HJ64GP204, 24HJ64GP206, 24HJ64GP210, 24HJ64GP502, 24HJ64GP504, 24HJ64GP506, 24HJ64GP510, 24HJ128GP202, 24HJ128GP204, 24HJ128GP206, 24HJ128GP210, 24HJ128GP306, 24HJ128GP310, 24HJ128GP502, 24HJ128GP504, 24HJ128GP506, 24HJ128GP510, 24HJ256GP206, 24HJ256GP210, 24HJ256GP610,
30F1010, 30F2010, 30F2011, 30F2012, 30F2020, 30F2023, 30F3010, 30F3011, 30F3012, 30F3013, 30F3014, 30F4011, 30F4012, 30F4013, 30F5011, 30F5013, 30F5015, 30F5016, 30F6010, 30F6011, 30F6012, 30F6013, 30F6014, 30F6015,
33FJ06GS101, 33FJ06GS102, 33FJ06GS202, 33FJ12GP201, 33FJ12GP202, 33FJ12MC201, 33FJ12MC202, 33FJ16GP304, 33FJ16GS402, 33FJ16GS404, 33FJ16GS502, 33FJ16GS504, 33FJ16MC304, 33FJ32GP202, 33FJ32GP204, 33FJ32GP302, 33FJ32GP304, 33FJ32GS406, 33FJ32GS606, 33FJ32GS608, 33FJ32GS610, 33FJ32MC202, 33FJ32MC204, 33FJ32MC302, 33FJ32MC304, 33FJ64GP202, 33FJ64GP204, 33FJ64GP206, 33FJ64GP306, 33FJ64GP310, 33FJ64GP706, 33FJ64GP708, 33FJ64GP710, 33FJ64GP802, 33FJ64GP804, 33FJ64GS406, 33FJ64GS606, 33FJ64GS608, 33FJ64GS610, 33FJ64MC202, 33FJ64MC204, 33FJ64MC506, 33FJ64MC508, 33FJ64MC510, 33FJ64MC706, 33FJ64MC710, 33FJ64MC802, 33FJ64MC804, 33FJ128GP202, 33FJ128GP204, 33FJ128GP206, 33FJ128GP306, 33FJ128GP310, 33FJ128GP706, 33FJ128GP708, 33FJ128GP710, 33FJ128GP802, 33FJ128GP804, 33FJ128MC202, 33FJ128MC204, 33FJ128MC506, 33FJ128MC510, 33FJ128MC706, 33FJ128MC708, 33FJ128MC710, 33FJ128MC802, 33FJ128MC804, 33FJ256GP506, 33FJ256GP510, 33FJ256GP710, 33FJ256MC510, 33FJ256MC710,
33EP32GP502, 33EP32GP503, 33EP32GP504, 33EP32MC202, 33EP32MC203, 33EP32MC204, 33EP32MC502, 33EP32MC503, 33EP32MC504, 33EP64GP502, 33EP64GP503, 33EP64GP504, 33EP64GP506, 33EP64MC202, 33EP64MC203, 33EP64MC204, 33EP64MC206, 33EP64MC502, 33EP64MC503, 33EP64MC504, 33EP64MC506, 33EP128GP502, 33EP128GP504, 33EP128GP506, 33EP128MC202, 33EP128MC204, 33EP128MC206, 33EP128MC502, 33EP128MC504, 33EP128MC506, 33EP256GP502, 33EP256GP504, 33EP256GP506, 33EP256MC202, 33EP256MC204, 33EP256MC206, 33EP256MC502, 33EP256MC504, 33EP256MC506, 33EP512GP502, 33EP512GP504, 33EP512GP506, 33EP512MC202, 33EP512MC204, 33EP512MC206, 33EP512MC502, 33EP512MC504, 33EP512MC506,
AT90S1200, AT90S2313, AT90S8515, AT90S8535, ATmega48, ATmega8, ATmega88, ATmega8515, ATmega8535, ATmega16, ATmega164, ATmega168, ATmega32, ATmega324, ATmega328, ATmega64, ATmega644, ATmega1284,
ATtiny11, ATtiny12, ATtiny13, ATtiny2313, ATtiny24, ATtiny25, ATtiny26, ATtiny261, ATtiny4313, ATtiny44, ATtiny45, ATtiny461, ATtiny48, ATtiny84, ATtiny85, ATtiny88, ATtiny861,
2400, 2401, 2402, 2404, 2408, 2416, 2432, 2464, 24128, 24256, 24512, 241024, 241025,
25010, 25020, 25040, 25080, 25160, 25320, 25640, 25128, 25256, 25512, 251024,
95010, 95020, 95040, 95080, 95160, 95320, 95640, 95128, 95256, 95512, 95M01, 95M02,
251005, 252005, 254005, 258005, 251605, 25X05, 25X10, 25X20, 25X40, 25X80, 25X16, 25X32, 25X64, 25X128, 25Q40,
93S46, 93x46, 93x46A, 93S56, 93x56, 93x56A, 93S66, 93x66, 93x66A, 93x76, 93x76A, 93x86, 93x86A,
DS2430, DS2431, DS2433, DS28EC20, DS1820,
11010, 11020, 11040, 11080, 11160

supporto in sola lettura:
12C671, 12C672, 12CE673, 12CE674

Importante!! I dispositivi a 3,3V non devono essere usati senza le espansioni a 3,3V, pena danni irreparabili; il programma verifica la presenza di questi adattatori prima di iniziare a programmare, ma ovviamente bisogna fare attenzione a selezionare il dispositivo giusto; i dispositivi a 3,3V sono:
12F1xxx,16F1xxx,18FxxJxx,18FxxKxx,24Fxxx,24Hxxx,33Fxxx.
Alcuni di questi hanno varianti che funzionano anche a 5V; se è necessario programmarli a 5V bisogna usare l'opzione "Non richiedere espansioni LV".
Un altro errore da evitare è inserire i 24F-33F nello zoccolo per 30F, che funziona a 5V.

Protocollo di comunicazione

Nella scelta del protocollo di comunicazione bisogna tenere conto di varie esigenze fra loro spesso contrastanti:
velocità ed efficienza di trasferimento, dimensione del codice, universalità ed espandibilità.
Rispetto a un collegamento seriale quello USB ha la peculiarità di essere basato su pacchetti dati; si considera che i dati in un pacchetto arrivino contemporaneamente al dispositivo.
Nel caso di periferiche HID non se ne possono spedire più di uno ogni ms, quindi non è possibile gestire le temporizzazioni in maniera diretta come con una seriale, e si devono introdurre dei comandi che, opportunamente espansi dal microcontrollore, ricreano le forme d'onda desiderate.
D'altronde uno degli obiettivi di un programmatore affidabile è quello di essere indipendente dalla velocità del PC e dal suo carico di lavoro, per cui il compito di generare le forme d'onda precise deve ricadere comunque sul microcontrollore.
Dunque esistono a un estremo i programmatori seriali semplici, che ricevono solo comandi per forzare i livelli di tensione: il software sul PC controlla sia le temporizzazioni che l'algoritmo di programmazione, occupando però completamente la CPU e risentendo pesantemente degli altri programmi in esecuzione.
All'opposto i programmatori "intelligenti" generano le temporizzazioni e gestiscono gli algoritmi, ma devono essere aggiornati per supportare nuovi dispositivi; inoltre visto il numero di algoritmi esistenti l'occupazione di memoria sarà alta.
Qui la scelta è caduta su un sistema ibrido: nel firmware sono stati implementati i comandi elementari ICSP (In Circuit Serial Programming), ma gli algoritmi sono gestiti dal software.
Per aumentare la velocità e l'efficienza di trasferimento ci sono alcune istruzioni che corrispondono a comandi ripetuti molto spesso, ad esempio le letture sequenziali, o a combinazioni di istruzioni.
Il vantaggio di questo approccio è che le temporizzazioni sono molto precise perchè gestite dal microcontrollore, ma allo stesso tempo la grande varietà di algoritmi viene implementata nel software e non aumenta la dimensione del codice firmware.
Un ulteriore vantaggio è che una volta verificati i comandi base del firmware tutto lo sviluppo degli algoritmi si può fare su PC, in maniera certamente più veloce e senza dover aggiornare continuamente il firmware.
Per esempio per entrare in program mode col 16F628 e leggere DevID la sequenza sarebbe:

Oltre ai comandi ICSP ci sono istruzioni che permettono di gestire il programmatore, le tensioni di programmazione, imporre ritardi precisi, comunicare via I2C e SPI.
Ogni istruzione dura almeno 40us, dovuti al ciclo di esecuzione dell'interprete; i comandi ICSP sono temporizzati in base ai parametri T1-T2 o a quanto scritto nei documenti Microchip; tutte fanno almeno un eco sul pacchetto di ritorno, eccetto FLUSH che svuota la coda di uscita e la spedisce subito in un pacchetto di 64 byte.
Nel caso non ci siano abbastanza parametri viene restituito 0xFE e termina l'esecuzione.
Lo stato della comunicazione USB è segnalato dal LED2: lampeggia a 4 Hz durante l'enumerazione, a 1 Hz quando la comunicazione è normale.
Il LED1 invece segnala quando ci sono istruzioni in esecuzione.
L'elenco completo delle istruzioni:

Comando	Valore	Parametri	Risposta	Note
NOP	0x00	no	eco	non fa nulla
PROG_RST	0x01	no	eco + 10B	reset del programmatore; spedisce versione fw. (3B), ID(3B), la stringa " RST"
PROG_ID	0x02	no	eco + 6B	spedisce versione fw. (3B), ID (3B)
CHECK_INS	0x03	1B	eco + 1B	se l'istruzione specificata nel parametro esiste ne rispedisce il codice, altrimenti invia errore (0xFE)
FLUSH	0x04	no	nessuno	svuota la coda di uscita (invia 64B) e ferma l'interprete comandi per il pacchetto corrente
VREG_EN	0x05	no	eco	accende il regolatore di tensione
VREG_DIS	0x06	no	eco	spegne il regolatore di tensione
SET_PARAMETER	0x07	1B	eco	imposta parametri interni (di ritardo o altro); byte1 parametro da cambiare, byte 2-3 valore: SET_T1T2 (=0):      T1 e T2 SET_T3  (=1):           T3(H,L) SET_timeout (=2):    timeout(H,L) SET_MN  (=3):         M,N
WAIT_T1	0x08	no	eco	ritardo di T1 us (=1us all'avvio)
WAIT_T2	0x09	no	eco	ritardo di T2 us (=100us all'avvio)
WAIT_T3	0x0A	no	eco	ritardo di T3 us (=2ms all'avvio)
WAIT_US	0x0B	1B	eco	ritardo variabile di N us
READ_ADC	0x0C	no	eco +2B	legge la tensione del regolatore (10bit efficaci,MSB-LSB); considerato il partitore in ingresso la tensione in Volt si ricava come <valore>/1024*5*34/12
SET_VPP	0x0D	1B	eco +1B	imposta la tensione del regolatore a <parametro>/10; se entro 15ms l'errore di tensione è < 200mV rispedisce <parametro>, altrimenti errore (0xFE)
EN_VPP_VCC	0x0E	1B	eco	controlla Vpp e Vcc del dispositivo da programmare; 1 bit controlla il livello (0-1), 1bit l'impedenza (lasciare a 0) bit 0-1: Vcc, bit 2-3: Vpp
SET_CK_D	0x0F	1B	eco	controlla le linee CK, D, PGM del dispositivo da programmare; 1 bit controlla il livello (0-1), 1bit l'impedenza (bassa-alta); bit 0-1: D, bit 2-3: CK, bit 4-5: PGM
READ_PINS	0x10	no	eco +1B	legge lo stato delle linee di controllo e comunicazione, 1 bit livello (0-1), 1bit impedenza (bassa-alta); bit 0-1: D, bit 2-3: CK, bit 4-5: PGM
LOAD_CONF	0x11	2B	eco	Comando ICSP: Load configuration (000000), T1 us tra comando e dati; 14 bit dati (allineati a destra, MSB-LSB)
LOAD_DATA_PROG	0x12	2B	eco	Comando ICSP: Load Data in Program Memory (000010), T1 us tra comando e dati; 14 bit dati (allineati a destra, MSB-LSB)
LOAD_DATA_DATA	0x13	1B	eco	Comando ICSP: Load Data in Data Memory (000011), T1 us tra comando e dati; 8 bit dati
READ_DATA_PROG	0x14	no	eco +2B	Comando ICSP: Read Data from Program Memory (000100), T1 us tra comando e dati; 14 bit dati (allineati a destra, MSB-LSB)
READ_DATA_DATA	0x15	no	eco +1B	Comando ICSP: Read Data from Data Memory (000101), T1 us tra comando e dati; 8 bit dati
INC_ADDR	0x16	no	eco	Comando ICSP: Increment Address (000110), ritardo di T1 us alla fine
INC_ADDR_N	0x17	1B	eco	Comando ICSP: Increment Address (000110), ritardo di T1 us alla fine; ripetuto N volte
BEGIN_PROG	0x18	no	eco	Comando ICSP: Begin Programming (001000)
BULK_ERASE_PROG	0x19	no	eco	Comando ICSP: Bulk Erase Program Memory (001001)
END_PROG	0x1A	no	eco	Comando ICSP: End Programming (001010)
BULK_ERASE_DATA	0x1B	no	eco	Comando ICSP: Bulk Erase Data Memory (001011)
END_PROG2	0x1C	no	eco	Comando ICSP: End Programming (001110)
ROW_ERASE_PROG	0x1D	no	eco	Comando ICSP: Row Erase Program Memory (010001)
BEGIN_PROG2	0x1E	no	eco	Comando ICSP: Begin Programming (0011000)
CUST_CMD	0x1F	1B	eco	Comando ICSP specificato nel parametro
PROG_C	0x20	2B	eco +1B	Programma word seguendo l'algoritmo per 12Cxxx: 000010, 001000, 001110, M pulses & N overpulses
CORE_INS	0x21	2B	eco	Comando ICSP PIC18: Core instruction (0000); 16 bit dati (MSB-LSB)
SHIFT_TABLAT	0x22	no	eco +1B	Comando ICSP PIC18: Shift TABLAT (0010); 8 bit dati
TABLE_READ	0x23	no	eco +1B	Comando ICSP PIC18:  Table read (1000); 8 bit dati
TBLR_INC_N	0x24	1B	eco+N+NB	Comando ICSP PIC18: Table read post-inc (1001); 8 bit dati; ripete N volte; rispedice N e NB dati
TABLE_WRITE	0x25	2B	eco	Comando ICSP PIC18: Table write (1100); 16 bit dati (MSB-LSB)
TBLW_INC_N	0x26	(2N+1)B	eco	Comando ICSP PIC18:  Table write post-inc (1101); 16 bit dati (MSB-LSB); ripete N volte (N è il primo parametro)
TBLW_PROG	0x27	4B	eco	Comando ICSP PIC18: Table write and program (1111); 16 bit dati (MSB-LSB); di seguito esegue un NOP con ritardo di scrittura specificato dal parametro 3-4 (in us)
TBLW_PROG_INC	0x28	4B	eco	Comando ICSP PIC18: Table write and program post-inc (1110); 16 bit dati (MSB-LSB); di seguito esegue un NOP con ritardo di scrittura specificato dal parametro 3-4 (in us)
SEND_DATA	0x29	3B	eco	Comando ICSP PIC18 specificato nel byte 1; scrive 16 bit dati (MSB-LSB)
READ_DATA	0x2A	1B	eco+1B	Comando ICSP PIC18 specificato nel byte 1; legge 8 bit dati
I2C_INIT	0x2B	1B	eco	Inizializza la periferica I2C: 0xFF disabilita I2C; bit 6: controllo slew per velocità > 100kbps; bit 5:3 velocità: 0=100k, 1=200k, 2=400k, 3=800k, 4=1M; attenzione: usare resistenze di pull-up adatte alla velocità scelta; bit 2:0: livello logico delle linee A2-A1-A0 del dispositivo
I2C_READ	0x2C	3B	eco+1+NB	Legge <parametro 1> byte dal bus I2C usando il byte di controllo <parametro 2> e l'indirizzo <parametro 3>; forza automaticamente il bit RW del byte di controllo. Risponde con <parametro 1> + Dati o ACK_ERR (0xFD) in caso di errore di acknowledge (ad es. se non ci sono dispositivi connessi)
I2C_WRITE	0x2D	3B+NB	eco	Scrive <parametro 1> byte sul bus I2C usando il byte di controllo <parametro 2> e l'indirizzo <parametro 3>; forza automaticamente il bit RW del byte di controllo. Risponde (0xFD) in caso di errore di acknowledge (ad es. se non ci sono dispositivi connessi). In caso di indirizzi a 2 byte è sufficiente usare il secondo byte di indirizzo come primo dei dati.
I2C_READ2	0x2E	4B	eco+1+NB	Legge dal bus I2C; come I2C_READ, ma usa 2 byte per gli indirizzi
SPI_INIT	0x2F	1B	eco	Inizializza la periferica SPI: 0xFF disabilita SPI; bit 1:0 velocità: 0=100kbps, 1=200kbps, 2=300kbps, 3=500kbps; bit 2:3 modo SPI
SPI_READ	0x30	1B	eco+1+NB	Legge <parametro 1> byte dal bus SPI. Risponde con <parametro 1> + Dati Se <parametro 1>=0 risponde col byte ricevuto durante l'ultimo trasferimento (lettura o scrittura)
SPI_WRITE	0x31	1B+NB	eco+1B	Scrive <parametro 1> byte sul bus SPI.
EXT_PORT	0x32	2B	eco	Forza i livelli delle porte di comunicazione: <parametro 1> = <RB7:RB0> <parametro 2> = <RC7,RC6,RA5:RA3> Non modifica la direzione dei segnali.
AT_READ_DATA	0x33	3B	eco+1+2NB	Comando ATMEL: read program memory (0010H000); legge <parametro 1> word all'indirizzo <parametro 2> : <parametro 3> via SPI. Risponde con <parametro 1> + Dati
AT_LOAD_DATA	0x34	3B+2N	eco+1B	Comando ATMEL: load program memory page (0100H000); carica <parametro 1> word all'indirizzo <parametro 2> : <parametro 3> via SPI. Risponde con <parametro 1>
CLOCK_GEN	0x35	1B	eco	Genera un clock su RB3 (tramite CCP1-2 e TIMER1) bit 2:0 frequenza: 0=100kHz, 1=200kHz, 2=500kHz, 3=1MHz, 4=2MHz, 5=3MHz, 6=6MHz; Disabilita l'uscita PWM1 (regolatore DCDC).
SIX	0x36	3B	eco	Comando ICSP PIC24: Core instruction (0000); 24 bit dati (MSB-LSB)
SIX_LONG	0x3E	3B	eco	Comando ICSP PIC24: Core instruction (0000); 24 bit dati (MSB-LSB); aggiunge 2 ICSP_NOP alla fine
SIX_LONG5	0x49	3B	eco	Comando ICSP PIC24: Core instruction (0000); 24 bit dati (MSB-LSB); aggiunge 5 ICSP_NOP alla fine
SIX_N	0x3F	1B+3NB	eco	Comando ICSP PIC24: Core instruction (0000); N * 24 bit dati (MSB-LSB); invia N istruzioni e aggiunge M ICSP_NOP dopo ognuna; N=<parametro1>&0x3F, M=<parametro1> >> 6
REGOUT	0x37	no	eco +2B	Comando ICSP PIC24: Shift out VISI register (0001); 16 bit dati (MSB-LSB))
ICSP_NOP	0x38	no	eco	Comando ICSP PIC24: esegue NOP (0000)
TX16	0x39	1B+2NB	eco+1B	Trasmette N*16 bit via ICSP (MSB-LSB); periodo di clock: 2*(T1-1)+1 us
RX16	0x3A	1B	eco+1+2NB	Riceve N*16 bit via ICSP (MSB-LSB); periodo di clock: 2*(T1-1)+1 us
uW_INIT	0x3B	no	eco	Inizializza la comunicazione MicroWire
uW_TX	0x3C	1B+NB	eco	Scrive <parametro 1> bit sul bus MicroWire
uW_RX	0x3D	1B	eco+1+NB	Legge <parametro 1> bit dal bus MicroWire
OW_RESET	0x40	no	eco+1B	Reset del bus OneWire; rileva impulso di presenza: 1=presente 0=assente
OW_WRITE	0x41	1B+NB	eco	Scrive <parametro 1> byte sul bus OneWire
OW_READ	0x42	1B	eco+1+NB	Legge <parametro 1> byte dal bus OneWire
UNIO_STBY	0x43	no	eco	Genera un impulso di standby UNIO
UNIO_COM	0x44	1B+1B+NB	eco+1+NB	Esegue una comunicazione UNIO: scrive <parametro 1> byte e legge <parametro 2> byte; genera un byte di sincronizzazione se ci sono byte da scrivere
SET_PORT_DIR	0x45	2B	eco	Forza la direzione delle porte di comunicazione (0=out, 1=in): <parametro 1> = <RB7:RB0> <parametro 2> = <RC7,RC6,RA5:RA3>
READ_B	0x46	no	eco+1B	Legge lo stato della porta B
READ_AC	0x47	no	eco+1B	Legge lo stato delle porte A e C: <RC7,RC6,RA5:RA3>
AT_HV_RTX	0x48	1B+2NB	eco+1B	Trasmette 2N*8 bit su RB0/RC7 (PB1/PB0), CLK su RC6 (PB3) byte N=PB1, byte N+1=PB0 Riceve 8 bit da RB1 (PB2) (solo l'ultimo byte)
READ_RAM	0xF0	2B	eco+3B	Legge dalla memoria del micro di controllo; indirizzo a 16 bit, dato 8 bit; fa eco dell'indirizzo
WRITE_RAM	0xF1	3B	eco+3B	Scrive sulla memoria del micro di controllo; indirizzo a 16 bit, dato 8 bit; fa eco dell'indirizzo e del dato
LOOP	0xF2	no	no	Riporta il puntatore istruzioni a 0 ed riesegue tutte le istruzioni ricevute. Il micro non accetta più altri comandi. Solo per esigenze di test.

Schema elettrico (v1.7)

Per implementare una periferica USB con i PIC ci vogliono veramente pochi componenti: il micro principale, il quarzo, qualche condensatore, qualche resistenza e il connettore USB tipo B, tutto come da Application Note della Microchip.
Il progetto è basato sul PIC18F2550, a 28 piedini, di cui sono usate circa 8,5 KWord della memoria programma, quindi è possibile usare anche il più piccolo 2455.
I 2458 e 2553 differiscono solo per l'ADC a 12 bit e necessitano solo di ricompilazione.
Fino alla versione 0.8.0 era possibile adattare il tutto anche al 2450; questo modello non ha il modulo MSSP, quindi le funzionalità I2C e SPI vengono emulate via software; non ha neanche il secondo canale PWM, quindi non può generare il clock per i micro Atmel che lo richiedono (cioè quelli configurati per il clock esterno); in questo caso il piedino RB3 ha la funzione di accendere un eventuale oscillatore esterno, da inserire opportunamente nella scheda di espansione Atmel.
Per poter usare i dispositivi a 40p corrispondenti (4450,4455,4458,4550,4553) bisogna modificare lo stampato.
Oltre a connettere il micro via USB bisogna generare le tensioni per la programmazione vera e propria; nel caso PIC-ICSP quindi servono tre transistor (per controllare VDD e VPP) e due linee dati (per dati e clock).
La tensione Vpp viene da un regolatore switching formato da Q4, L1, D3 e descritto di seguito.

Schema elettrico del modulo base:


Circuito stampato del modulo base:


Molti componenti sono opzionali, servono solo per programmare alcuni tipi dispositivi o per applicazioni future: i connettori di espansione CONN2-3, le resistenze di protezione R11:23 (visto il costo perché non metterle?), le resistenze di pull-up I2C R26-27, il pulsante S1 (per ora non è utilizzato dal software), lo zoccolo per memorie I2C, il connettore ICSP-IN CONN4 (che serve a programmare il micro principale senza estrarlo, almeno fino a che non implementerò un auto-aggiornamento via USB).
Il circuito stampato è stato ottimizzato per usare una sola faccia, ma sono necessari anche alcuni ponticelli sul lato componenti; chi volesse può farne a meno usando un pcb a doppia faccia.
Nel montaggio bisogna fare attenzione all'orientamento dei transistor: Q1 ha l'emettitore a sinistra, Q2 in alto, Q3 e Q4 a destra.
Un circuito funzionante, una volta connesso al PC, fa lampeggiare il led D2 a 4Hz fino a quando non termina l'enumerazione, e successivamente a 1Hz.
Per verificare che tutto funzioni bene bisogna quindi eseguire la funzione "test hardware" nei programmi di controllo: in questa modalità, da eseguire senza dispositivi da programmare, vengono attivate in varie combinazioni le uscite (CK, D, PGM, VDDU, VPPU, presenti sui piedini 14-15-12-1-4 di U3, rispetto a GND, piedino 5); se la tensione misurata corrisponde a quanto dice il programma vuol dire che il circuito è funzionante.
La tensione VPP può non corrispondere esattamente a quella impostata, e avere errori anche di +-1V; questo è dovuto al fatto che il riferimento di tensione del convertitore DCDC è la VCC stessa, che viene fornita dal cavo USB e può variare da 4.75V a 5.25V; inoltre il partitore R1-R2 può introdurre un ulteriore errore del 5%.
Tra le cause più frequenti di malfunzionamento (vero o presunto) ci sono:
orientamento scorretto dei transistor,
induttanza di valore errato,
difetti nel pcb come corti tra piste o piste aperte,
condensatori staccati,
microcontrollore principale non programmato o programmato male (con opzione LVP).


Elenco componenti:

U1 quarzo 12Mhz (anche 4, 8, 16, 20; bisogna riconfigurare il divisore nel micro)
U2 18F2550 (anche 2450,2455,2458,2553,4450,4455,4458,4550,4553)
U3 zoccolo 20p.
U4 zoccolo 8p.
Q1-2 BC557 (o qualsiasi PNP, attenzione al montaggio)
Q3-4 BC547 (o qualsiasi NPN, attenzione al montaggio)
D1-2 LED a piacere
D3 1N4148 (o qualsiasi diodo, meglio se Shottky)
L1 100uH tipo resistenza o altro
R1 22K
R2 12K
R3 100K
R4:6 10K
R7 1M
R8-9 2.2K
R10 10K
R11:23 100
R24-25 330K
R26-27 10K
C1 22-100uF 25V
C2-3 22pF
C4 >= 220nF
C5 100nF
C6 10uF
C7-8 100nF
CONN1 USB tipo B
CONN2-3 connettori a pettine femmina 10 poli
CONN4 connettore a pettine maschio 5 poli

Come si usa

La scheda base può ospitare i PIC a 8,14,16,18,20 piedini (eccetto i 10Fxxx) che vanno inseriti in U3 allineati al piedino 1:





In U4 vengono ospitate le memorie EEPROM I2C e UNIO.
Anche i dispositivi OneWire (TO92) si connettono su U4: il terminale GND su RB1 (piedino 6), IO su RB0 (piedino 5).
Per i 10Fxxx a 6 o 8 piedini aggiungerò in futuro un adattatore; nel frattempo ci si può arrangiare con collegamenti volanti.
Tramite i due connettori di espansione si possono poi collegare vari adattatori per altri dispositivi.

• PIC a 28-40 piedini + connettore ICSP
• PIC 8-20p. (come sulla scheda base, ma c'è più spazio per uno zoccolo ZIF) + conn. ICSP
• PIC16-18 a 3.3V + conn. ICSP (questo adattatore ha anche un regolatore a 3.3V)
• PIC24-30-33 + conn. ICSP (questo adattatore ha anche un regolatore a 3.3V)
• Memorie I2C, SPI, MicroWire e conn. I2C-SPI
• ATMEL 8-14-20-28-40p. e conn. I2C-SPI
• ST72 (in futuro)

I componenti per le schede di espansione sono indicati nello schema elettrico; i diodi possono essere di qualunque tipo; le resistenze TBD non vanno montate.
Sui circuiti adattatori consiglio di inserire i pettini di espansione dal lato componenti e di lasciare il distanziatore plastico da quel lato; questo aumenta molto la resistenza meccanica, soprattutto in fase di estrazione.
Nel caso di dispositivi a 3,3V il software verifica la presenza di un adattatore a 3,3V (che ha RB1 in corto con RB0) per evitare danni irreversibili.
I 16F1xxx potrebbero anche essere programmati senza l'adattatore a 3,3V (solo i 16LF1xxx lo richiedono), ma il controllo è presente per entrambi per non fare confusione.
Vista l'impossibilità di cancellare alcuni registri dei dsPIC30 a 3.3V, questi sono ora alimentati a 5V; chi avesse già costruito l'adattatore (prima della v. 1.7) può facilmente modificarlo.
Le immagini seguenti mostrano come inserire i dispositivi sulle schede di espansione:

I dispositivi più piccoli devono essere allineati al piedino 1 del rispettivo zoccolo, ad esempio i PIC a 8p. nello zoccolo a 20p., o gli ATTiny2313 nello zoccolo a 28p.
E' anche possibile eseguire la programmazione "in circuit" collegando i segnali ICSP (VPPU,VDDU,ICD,ICK,GND) alla scheda applicativa; questi segnali sono presenti nei connettori di espansione del modulo base o più comodamente in alcune schede di espansione tramite apposito connettore.
I dispositivi a 3,3V richiedono una interfaccia ICSP anch'essa a bassa tensione, presente sulle schede di espansione a 3,3V.
Per utilizzare le memorie Flash SPI è necessario modificare l'adattatore EEPROM in modo da abbassare la tensione di alimentazione a 3,3V; lo schema elettrico è mostrato qui sotto:

Il connettore ICSP-IN serve invece per programmare il micro principale senza toglierlo, mediante un altro programmatore

ATTENZIONE: il modulo ATMEL AVR ha attualmente un baco che impedisce l'entrata in program mode sui dispositivi a 28 piedini (es. ATMega8) che non sono configurati con l'oscillatore interno.
Per poter condividere lo zoccolo con i dispositivi a 20 piedini (es. ATTiny2313) il piedino 10 è collegato a VSS; però questo corrisponde a X2 nei dispositivi più grandi, e deve essere flottante se l'oscillatore è esterno.
Per risolvere tutto basta lasciare flottante X2, in uno dei seguenti modi:
a) svasare leggermente il piedino 10 del dispositivo in modo che rimanga fuori dallo zoccolo.
b) tagliare la pista tra piedino 10 e VSS, ma ricollegarla nel caso di dispositivi a 20 piedini.

Prossimamente l'adattatore verrà modificato includendo un ponticello per chiudere il piedino 10 a VSS.

Piedinatura dei connettori presenti sulla scheda base e sulle espansioni:


Mappatura delle risorse del micro principale:

Pin	Funzioni varie	ICSP	I2C-EEPROM	SPI-EEPROM	SPI-ATMEL	uW-EEPROM	OneWire/UNIO
RB7		PGM
RB6		ICSP clock
RB5		ICSP data	A2			W (6)
RB4			A1	HLD		S (1)
RB3			A0	CS	Device clock	PRE (7)
RB2	espansione
RB1			Clock	Clock	SPI Clock	Clock
RB0			Data	Data out (MISO)	Data out (MISO)	Data out	Data IO
RC7				Data in (MOSI)	Data in (MOSI)	Data in
RC6			WP	WP	RESET
RC5	USB D+
RC4	USB D-
RC2	DCDC PWM
RC1	controlla VDD
RC0	controlla VPP
RA5	espansione
RA4	espansione
RA3	espansione
RA2	LED 2
RA1	LED 1
RA0	ADC per regolatore
RE3	Pulsante S1

Lo schema elettrico è stato disegnato con Gschem, un programma open source che fa parte della suite gEDA. Sebbene non venga quasi menzionato nel loro sito (giacchè usano tutti linux) è disponibile anche per windows, previa installazione di cygwin e compilazione degli ultimi sorgenti.
Stesso discorso per gli stampati, disegnati con PCB, di cui esiste anche una versione windows (per la verità un po' limitata).
Chi avesse la pazienza può anche fare a meno dello stampato e montare il tutto su millefori.

Schema elettrico del modulo base: .pdf, .png; schede di espansione: .pdf; tutto in formato gschem: Oprog.sch
Circuito stampato del modulo base: .pdf (anche specchiato), .png; base + schede di espansione: .pdf, .png; tutto in formato PCB: Oprog.pcb
Archivio completo, include sorgenti, gerber, pdf, png.

Come programmare il micro la prima volta?

E' un problema molto interessante, visto che un dispositivo nuovo è vuoto e non funziona come programmatore: a parte il classico "fattelo programmare da qualcuno che ce l'ha già", il mio consiglio è di usare una di quelle interfacce tanto in voga oggi, ad esempio JDM, magari costruita su millefori, e come software winpic o picprog.
Se proprio non sai come procedere contattami e te lo programmo io.
Potrebbe sembrare strano dover costruire un programmatore per farne un altro, ma non c'è modo di comunicare via USB senza firmware; credo però che ne valga la pena, visto che i programmatori seriali non sono molto affidabili, sono lenti, e soprattutto non si possono usare sui nuovi computer.
Un consiglio: assicuratevi di aver programmato bene il dispositivo (tramite verifica) evitando assolutamente di abilitare la programmazione LVP (a bassa tensione); questa infatti riserva RB5 per entrare in program mode, e RB6-RB7 per comunicare, col risultato che il programmatore non funziona.
Inoltre, almeno fino a che non riuscirò a implementare un auto-aggiornamento, consiglio di tenere un micro di scorta per caricare le versioni aggiornate del firmware.

Il circuito base e alcune schede di espansione (28-40p PIC, 8-20p PIC con ZIF, 3.3V PIC16-18, 3.3V PIC24-30-33, EEPROM, ATMEL):

Base + espansione montata:

Dispositivo OneWire (TO92):

Regolatore switching

Per generare una tensione Vpp maggiore di 5V bisogna usare un convertitore DCDC a commutazione di tipo boost.
In commercio ne esistono a migliaia, ma seguendo la filosofia del minimo indispensabile ne ho realizzato uno col micro stesso, al modico costo di un transistor e qualche componente passivo.
Per tenere fissa la tensione d'uscita al variare delle condizioni operative bisogna poi variare la larghezza degli impulsi di commutazione in funzione di questa.
In pratica si tratta di realizzare un regolatore con anello di reazione digitale, come illustrato nello schema seguente.



I blocchi di base ci sono tutti: periferica PWM, convertitore A/D, DSP(quasi).
Attualmente il convertitore A/D usa come riferimento l'alimentazione a 5V, quindi l'uscita varia in funzione di questa; è però possibile collegare un riferimento esterno su RA3 e migliorare la precisione. La frequenza di commutazione è 90 kHz, ben oltre la frequenza di taglio del filtro LC in uscita (~2,3 kHz).
Le prestazioni in corrente sono limitate dalle perdite del transistor, del diodo, dell'induttore, ma visto che l'assorbimento del carico è basso si può usare un comunissimo diodo al silicio, un transistor NPN qualsiasi, e un induttore a goccia; per migliorare il comportamento si può optare per un diodo Shottky, tipo BAT41, un transistor più grosso (o un Mosfet) e un'induttanza avvolta in aria.
Rimane da progettare un regolatore (blocco C) opportuno: è meglio lavorare nel dominio s, quindi serve modello alle variazioni del convertitore, cosa che fortunatamente è stata già fatta e si trova un po' dappertutto, ad esempio qui.
Con i componenti scelti il convertitore opera in regime discontinuo, infatti la corrente critica risulta:
Icrit=Vu*T/(16*L)=86 mA
molto al di sopra del consumo effettivo, che supponiamo 1mA.
Parametri di calcolo:
Vi=5
Vu=12.5
D=(vu-vi)/vo
L=100e-6
C=47e-6
I=1e-3
R=12/I
Rl=1.6 (resistenza serie dell'induttore)
T=1/90e3
La funzione di trasferimento risulta:
Il diagramma di Bode è il seguente:

Dunque il sistema sarebbe stabile anche solo chiuso su se stesso, ma avrebbe un errore a regime inversamente proporzionale al guadagno DC.
Per ovviare a questo bisogna inserire un controllore con un polo nell'origine e uno zero più avanti per stabilizzare il tutto.
Ad esempio usando un controllore di questo tipo:
la funzione di trasferimento si modifica come segue:

Si vede che il sistema rimane stabile, con margine di fase ~75º.

Ora per chiudere l'anello di regolazione in digitale bisogna scegliere la frequenza di campionamento.
Questa da un lato limita la banda passante del regolatore, dall'altra viene limitata dalla potenza di calcolo del micro; un periodo di 250us è risultato un buon compromesso.
Convertendo le varie funzioni di trasferimento nel dominio di z con la trasformazione bilineare si ha:
Il regolatore è:
Ricordo che z^-1 rappresenta un ritardo di un ciclo di clock.
Ora c'è da fare i conti con gli errori di quantizzazione e di calcolo.
Il convertitore A/D è a 10 bit e comadato dal Timer2; al termine della conversione viene generato un interrupt e viene eseguita la funzione di regolazione, che ha come uscita il nuovo duty-cycle del generatore PWM, anch'esso a 10 bit.
Sul ramo di ritorno è necessario un partitore in modo da limitare la tensione di ingresso all'intervallo [0,5V]; R1 e R2 hanno questo compito.
Il diagramma del sistema si modifica come segue:


a=12/34

Vu=C'H(Vi-aVu)
Per ritornare al modello precedente moltiplichiamo ambo i membri per a e poniamo il nuovo ingresso a Vi/a; questo semplicemente comporterà una divisione del valore di tensione desiderato.
aC'=C
aC1'=C1
aC2'=C2

Visto che si lavora con rappresentazioni digitali a 10 bit vogliamo passare da D/err a pwm/[err]

[err]=err*1024/5
pwm=D*1024
pwm(1 - z^-1)=[err](5*C1/a - 5*C2/a z^-1)=[err](3.564 - 3.52 z^-1)

E' chiaro che con moltiplicazioni fra interi non si riuscirebbe ad avere una precisione accettabile sui coefficienti; la soluzione più semplice è usare come uscita il risultato diviso per un multiplo di 2 e ricalcolare i coefficienti di conseguenza.
Considerato che il registro pwm è allineato a sinistra risulta semplicissimo dividere per 64, ossia tralasciare gli ultimi 6 bit.

pwm(1 - z^-1)=[err](k1 - k2 z^-1)/64

k1=5C1/a*64=228.12 ~ 228
k2=5C2/a*64=225.25 ~ 225

Di seguito le risposte al gradino del sistema continuo (blu), di quello campionato con controllore ideale (rosso) e di quello con i coefficienti reali (verde); come si vede coincidono tutte.

Il programma di calcolo è Octave (ovviamente open source), giunto ormai alla versione 3 e utilizzabile senza troppi problemi anche col noto sistema (quasi)operativo a finestre.
Se qualcuno fosse interessato questi sono i listati dei modelli descritti prima.
Il codice effettivo della funzione di controllo è quasi tutto in assembly: questo si è reso necessario per ridurre il tempo di esecuzione; infatti il compilatore C inserisce una chiamata per ogni moltiplicazione (che in questo caso è a 16 bit) con conseguenti salvataggi delle variabili sullo stack; alla fine il tempo di esecuzione arrivava a 50us, ossia una frazione significativa del periodo.
In assembly invece si risparmiano le chiamate e si può fare senza sprechi la moltiplicazione 16x8 bit (visti k1 e k2); alla fine il tempo di esecuzione risulta 12us.  


Qualche forma d'onda:

 
Transitorio di accensione, 50 ms/div


Risposta al variare del carico (carico sopra, uscita in AC sotto), 50ms/div


Risposta al variare del segnale di ingresso (da 11,5 a 12,5 V), 50 ms/div

Come contribuire

Il modo migliore per contribuire a questo progetto è costruirlo, usarlo, e segnalare eventuali bachi, idee, richieste di supporto.
In particolare rimangono da verificare parecchi dispositivi, vedi supporto.
Chi avesse la pazienza e le conoscenze adatte può anche aggiungere altri algoritmi di programmazione o altri comandi interni.
Oppure se vi avanza un dispositivo non supportato potete spedirmelo in modo che io lo possa provare.
Se trovate il progetto utile e lo usate scrivetemi due righe a , e se l'avete modificato mostratemi il vostro lavoro.
Su SourceForge sono presenti vari forum su cui discutere di questo progetto; oppure potete racccomandarlo o lasciare un commento, spero positivo.

Scarica

Schema elettrico e stampato: archivio completo
Firmware: progetto MPLAB completo o firmware compilato(.hex) oppure una versione per 18F2450 (0.8.0) (con funzionalità ridotta, vedi schema elettrico).
opgui (GTK GUI per Linux & Windows): sorgenti o programma
OpenProg (GUI, solo Windows): solo il programma;   i sorgenti (progetto Visual Studio 6)
OP (per linea di comando, Linux e Windows)
Guida all'uso di OpenProg e Opgui
Listati per Octave

Cronologia

molto tempo fa	necessità di un programmatore USB affidabile e gratuito
2007	esperimenti con i PIC USB e vari firmware; regolatore di tensione
2008	primi prototipi e software
luglio 2008	documentazione e sito, pubblicata versione 0.3
agosto 2008	versione 0.4: aggiunto supporto per EEPROM I2C
novembre 2008	versione 0.5: bus I2C e SPI, aggiunti alcuni micro Atmel
gennaio 2009	programmi controllo v0.5.1: aggiunti alcuni PIC, corretti vari bachi
marzo 2009	programmi controllo v0.5.2 e v0.5.3: aggiunti alcuni PIC e Atmel, corretti vari bachi
aprile 2009	schema elettrico e pcb v1.4: modifica alla scheda Atmel
giugno 2009	versione 0.6: firmware USB GPL2, aggiunte memorie MicroWire 93Sx6
settembre 2009	versione 0.6.1: risolti alcuni bachi SPI, aggiunti alcuni Atmel e 93Cx6C
ottobre 2009	programmi controllo v0.6.2: risolti alcuni bachi
gennaio 2010	versione 0.7.0: aggiunti PIC24 e EEPROM SPI; circuiti v1.5: scheda per PIC24-30-33 a 3,3V
febbraio 2010	programmi controllo v0.7.1: aggiunti alcuni micro PIC18 e Atmel; corretti vari bachi
marzo 2010	programmi controllo v0.7.2: aggiunte alcune memorie MicroWire; corretti vari bachi
aprile 2010	programmi controllo v0.7.3: aggiunti PIC16F1xxx; corretti vari bachi; OP per win.; circuiti v1.6: scheda per PIC16-18 a 3,3V
maggio 2010	programmi controllo v0.7.4: aggiunti PIC18FxJx, PIC18FxKx, PIC24H, dsPIC30-33, ATtiny2313, 241024; corretti vari bachi; circuiti v1.7: modifica sulla scheda per PIC24-30-33, PIC30 ora a 5V
giugno 2010	programmi controllo v0.7.5: corretto baco in scrittura config 18Fx, aggiunta scrittura "goto ICD" per i 16Fx, correzioni minori;
luglio 2010	firmware v0.7.6: istruzioni TX16 e RX16 con periodo variabile per comunicazioni ICD; programmi controllo v0.7.6: lettura byte a byte con 93xx6 per maggiore compatibilità; prima versione debugger pdb (v0.1)
agosto 2010	programmi controllo v0.7.7: aggiunti 16F72x, altre modifiche minori; circuiti v1.7.1: ridotto valore resistenza R173 nel modulo PIC16/18 LV
aprile 2011	programmi controllo v0.7.8: aggiornati algoritmi 16F87xA e 16F62xA, 16F1822 diventa 12F1822, aggiunti 30F1010, 30F2020, 30F2023, 16F1847, 12F1840 16F1516, 16F1517, 16F1518, 16F1519, 16F1526, 16F1527 maggiore modularità del codice, corretti alcuni bachi
giugno 2011	programmi controllo v0.7.9: aggiunti ATtiny11-12-24-26-261-44-48-461-4313-84-88-861, ATmega48-88-164A-168-324A-328-644A-1284, 16LF1902-3-4-6-7, varie modifiche minori e correzioni; nuova interfaccia grafica GTK per Linux e Windows
gennaio 2012	programmi controllo v0.7.10: aggiunti 12F617,12F1501,16F1503-7-8-9,16F720-21,16F72,16F707, 18F13K22,18F14K22,18F23K22,18F43K22,18F24K22,18F44K22,18F25K22, 18F45K22,18F26K22,18F46K22,18F8520,18F66J60,18F66J65,18F67J60, 18F86J60,18F86J65,18F87J60,18F96J60,18F96J65,18F97J60, corretta lettura/scrittura file binari, varie correzioni, supporto ICD in OPGUI
luglio 2012	firmware v0.8.0: supporto bus One-Wire e UNIO; programmi controllo v0.8.0: aggiunti DS2430,DS2431,DS2433,DS28EC20,DS1820; 11010-20-40-80-160; 251005,252005,254005,258005,251605,25X10,25X20,25X40,25X80, 25X16,25X32,25X64; 16F1782-3-4-6-7,12C508-9; corretti algoritmi 24x1024/5 e 251024;
giugno 2013	programmi controllo v0.8.1: vari miglioramenti all'interfaccia utente; corretta scrittura EEPROM quando è attiva la protezione codice/dati per 16F83-84, 12F629,12F675,16F627-28,16F630,16F676,16F870-1-2,16F873-74,16F876-77; corretta lettura file > 1MB; modificata entrata prog mode AVR scrittura 93Sx6 protette;
marzo 2014	firmware v0.9.0: supporto ATMEL HV serial programming; nuovo comando PIC24/33; migliorato regolatore DCDC; programmi controllo v0.9.0: Write16F72x richiede solo la config-word1; aggiunto HV serial programming per ATtiny11-12-13-24-25-44-45-84-85; aggiunti 24FJ64GA3xx-GCxx,24FJ128GA3xx-GB2xx-GCxx-DAxx,24FJ256DAxx,24EPx,33EPx; aggiunti 95xx SPI EEPROM,25X05 FLASH; aggiunti 12F1571-72,16F527,16F753,16F1454-55-59; modifiche varie al codice;
novembre 2014	programmi controllo v0.9.1: vari miglioramenti all'interfaccia utente; corretta verifica ATTiny11-12; corretta scrittura 24FJ128GA3xx-GB2xx-GCxx-DAxx; aggiunti: forza configurazione per PIC18, test hardware linee IO, velocità SPI automatica per AVR, scrivi AVR Fuse Low @ 3kHz; verifica veloce per memorie FLASH SPI; aggiunti 10F320-22,12F529T39A,12F752,12F1612-13-14-15-18-19, 16F1512-13,16F1574-75-78-79,16F1703-04-05-07-08-09-13-16-17-18-19, 16F1788-89,16F570,16LF1554-59, 18F24K50-25K50-26K50-45K50-46K50, 18F25K80-26K80-45K80-46K80-65K80-66K80, 18F63J11-90,18F64J11-90,18F65J10-11-15-50-90, 18F66J10-11-15-16-50-55-90-93,18F67J10-11-50-90-93, 18F83J11-90,18F84J11-90,18F85J10-11-15-50-90, 18F86J10-11-15-16-50-55-90-93,18F87J10-11-50-72-90-93, 25X128,25Q40
in futuro	ampliare supporto PIC e ATMEL (quando riuscirò a farmi spedire i campioni gratuiti), aggiungere ST72, JTAG, memorie parallele; ampliare supporto ICD; compilare il firmware anche con SDCC

Risorse in rete

Open Programmer su SourceForge
Standard USB 2.0
HID page on USB.org
Breve guida al firmware HID
pdb, un semplice debugger ICD per PIC16
USB Central
USB & PIC
Microchip
Atmel
Documentazione su hiddev
Winpic
ICprog
Octave
gEDA-Gschem
PCB
licenze GNU/GPL
Piklab IDE for PIC microcontrollers
USBPicprog, un altro programmatore open source
Cygwin, un ambiente linux dentro windows

Contatti

Per informazioni o commenti:
Alberto Maccioni  
Cosiglio anche di usare i forum su sourceforge.

Ringraziamenti

Vorrei ringraziare tutti quelli che hanno contribuito alla crescita di questo progetto, in particolare: Anselmo per le problematiche linux/SCM, Sandro per i PCB altamente professionali, Alessandro per la verifica di parecchi dispositivi, Ken per la verifica di parecchi AVR, Luigi per la verifica di memorie OneWire, Mihaly per la verifica di memorie Flash SPI.

Torna su