PRO MIDI 1284P: Il compromesso tra Arduino Mini e Mega

Dalla nascita del progetto Arduino e successiva diffusione delle schede originali, l’industria elettronica e in special modo la nascente industria dell’elettronica per Maker, si è mossa in due direzioni: la creazione e commercializzazione di schede clone e lo sviluppo di board ibride, ossia concepite per aggiungere al mercato quello che la famiglia Arduino ufficiale non offre.

Schema Elettrico

Di seguito presenteremo una scheda di prototipazione basata sull’Atmega1284 che chiameremo PRO midi 1284P, dove la parola “midi” è relativa alle caratteristiche, ovvero significa una via di mezzo tra una mini ed una mega. La particolarità di questa nuova scheda simil-Arduino è che è basata sulla MCU Atmel/Microchip ATmega1284P. La board è illustrata nella Fig. 1 e, come vedete, è estremamente piccola nelle dimensioni ma ricca di connessioni con l’esterno. Questa scheda è già disponibile per la vendita, ma in ogni caso forniremo anche il file Gerber che potrebbero essere utilizzato per autocostruirsi la scheda stessa.

Fig. 1

La scheda offre, in uno spazio molto ridotto, caratteristiche estremamente interessanti:
• clock generato da quarzo a 16 MHz;
• 128 Kbyte di memoria “FLASH” (per il codice);
• 16 Kbyte di memoria “SRAM” (per i dati);
• 4 Kbyte di memoria “EEPROM” (per i dati, di tipo non volatile);
• 3 interrupt hardware (INT0, INT1 ed INT2);
• 2 porte seriali;
• 1 porta I2C;
• 1 porta SPI;
• 32 pin di GPIO di cui 8 con capacità di PWM;
• 8 ingressi analogici con ADC a 10 bit;
• 1 comparatore analogico;
• 2 timer a 8 bit (Timer 0 e Timer 2); uno di questi (Timer 2) utilizzabile come “Real-Time Counter” con quarzo esterno a 32,768 kHz;
• 2 timer a 16 bit (Timer 1 e Timer 3);
• “Capacitive Touch Sense” con l’uso della libreria Atmel QTouch.

Sono inoltre presenti (singolarmente escludibili tramite dei ponticelli tagliabili e ripristinabili dall’utente) queste periferiche (Fig. 2);
• LED verde (alimentazione 5V, escludibile tagliando la pista LD1);
• LED rosso (pin D13, escludibile tagliando la pista LD2);
• MOSFET (pin D12, escludibile tagliando la pista SWC) per alimentare oggetti esterni (per esempio sensori), in grado di accendere/spegnere carichi fino a 700mA quando si utilizza un’alimentazione esterna di 5V;
• resistenze di pull-up da 4,7 kΩ sulle linee del bus I²C (SCL ed SDA escludibili tagliando le relative piste).

Fig. 2

Tra ogni coppia di piazzole è presente una pista che può essere interrotta tagliandola.
Per chi volesse applicare un’alimentazione esterna diversa dai 5V (comunque fino ad un massimo di 12V), la scheda è dotata di un regolatore LDO (escludibile tagliando la pista RAW) a 5V in grado di alimentare (date la ridotta potenza dissipabile) la sola MCU, ma non utilizzatori esterni.
Di base, nella MCU, viene caricato il bootloader “Optiboot” che, tramite un adattatore seriale <-> USB da collegare esternamente (la scheda è dotata di un connettore a 5 pin per collegare generici adattatori “seriale <-> USB”) ne permette la facile programmazione tramite l’IDE di Arduino.
È comunque presente un connettore standard ISP che permette la programmazione della MCU tramite un programmatore esterno, come ad esempio l’Atmel ICE o qualsiasi altro programmatore compatibili AVR/ISP.
Le dimensioni della scheda sono estremamente ridotte, simili a quelle della serie “Arduino™ MKR”, ovvero 56,1 mm x 26,3 mm ed anche la pinout è parzialmente compatibile con alcune schede della stessa serie MKR.
I pin marcati con le sigle “TCK (18), TMS (19), TDO (20) e TDI (21)” possono essere collegati ad un programmatore/debugger JTAG per la programmazione ed il debug delle applicazioni.
Sui pin TOSC1 (22) e TOSC2 (23) può essere collegato un quarzo a 32,768 KHz che, programmando opportunamente il Timer 2 (TC2), può fornire il clock al “Real Time Counter” che detto Timer 2 è in grado di implementare, “Counter” che è in grado di continuare a funzionare anche con la MCU in modalità “Power-Save”.
Grazie alla possibilità di escludere tutto l’hardware che non occorre (LED, resistenze, MOSFET, regolatore di tensione LDO) tramite gli appositi ponticelli, la scheda si adatta perfettamente ad applicazioni a bassissimo consumo; difatti, escluso appunto, tutto l’hardware “di contorno” non necessario, la sola MCU, messa in modalità “Power-Save” (volendo con il “Real Time Counter” a 32 kHz attivo) assorbe appena 0,6 µA.
Nonostante le piccole dimensioni, il microcontrollore ATmega1284P ha la metà della Flash di un ATmega2560 (la MCU che equipaggia la scheda Arduino MEGA) ma ha il doppio di SRAM (ben 16 kbyte) il che rende questa MCU l’ideale per chi intende sviluppare applicazioni che utilizzino il sistema operativo real-time FreeRTOS; in tali applicazioni, oltre l’ampia memoria per il codice che l’ATmega1284P mette a disposizione, ben 128Kbytes, è fondamentale disporre di un’ampia SRAM, dato che, ciascuna task che viene creata, necessita comunque del suo spazio per lo Stack e per le sue variabili di sistema.

Piano di montaggio

Elenco Componenti:
R1, R2: 4,7 kohm (0603)
R3, R6: 10 kohm (0603)
R4, R5, R7: 470 ohm (0603)
C1, C2, C3, C4, C5: 100 nF ceramico (0603)
C6, C7: 18 pF ceramico (0603)
C8: 470 pF ceramico (0603)
C9: 10 µF 10V tantalio
XTAL: Quarzo 16 MHz
U1: ATMEGA1284P-AU
U2: MIC5205-3.3YM5-TR
LED1: LED verde (0805)
LED2: LED rosso (0805)
Q1: FDN360P
S1: Microswitch
Varie
– Strip maschio 5 vie
– Strip maschio 20 vie (2 pz.)
– Strip maschio 2×3 vie
– Circuito stampato S1493 (57×27 mm)

Schema a blocchi dell’Atmega1284P

Come già esposto nei precedenti paragrafi, il cuore della scheda Pro Midi 1284P è il microcontrollore Atmel/Microchip ATmega1284P, comprendere le caratteristiche del quale è più immediato gettando uno sguardo alla Fig. 3 che mostra lo schema a blocchi “funzionale”. In essa vediamo periferiche, moduli e registri, oltre al particolare generatore di clock.

Fig. 3

Programmazione della scheda

Come già segnalato, la scheda può essere programmata nell’ambiente Arduino IDE.
Per fare questo occorre aggiungere all’IDE l’opportuno “core”.
Aperte le “preferenze” dell’IDE, occorrerà aggiungere, nel campo “URL aggiuntive per il gestore di schede” (… per chi usa l’IDE in inglese: “Additional Boards manager URLs”) la seguente riga:

https://mcudude.github.io/MightyCore/package_MCUdude_MightyCore_index.json

Dopo di che, bisogna andare nel menu Strumenti, impartire il comando gestore Schede e selezionare, dal sottomenu che si apre, come scheda la:

MightyCore
Atmega1284

Selezionata la scheda, occorre selezionare, tra le opzioni che appaiono:

Clock: “External 16 MHz”
BOD: “disabled” (o il livello di tensione da voi scelto)
Compiler LTO: “LTO disabled”
Variant: “1284P”
Pinout: “Standard pinout”
Bootloader: “YES (UART0)”

In questo modo si è configurato l’IDE per utilizzare la scheda e, una volta selezionata la corretta porta seriale (quella creata dall’adattatore USB <-> seriale), sarà possibile caricare il codice direttamente tramite bootloader.
Per facilitare la scrittura del codice, viene fornito un modulo “.h” che può essere incluso nel progetto e che definisce, in modo mnemonico, una serie di “pin” presenti sulla scheda “PRO midi 1284P”. Il nome di tale modulo è “ProMidi1284P.h” e può essere scaricato dall’area download in piede alla pagina (contiene le definizioni riepilogate nel Listato 1).

Listato 1

/*
Pins definitions addendum for ProMidi 1284P
Guglielmo Braguglia – May 2019

*/
#ifndef Pins_ProMidi1284_h
#define Pins_ProMidi1284_h
#ifdef LED_BUILTIN
#undef LED_BUILTIN
#endif
#define LED_BUILTIN 13
#ifndef SWC_BUILTIN
#define SWC_BUILTIN 12
#endif
#ifndef NOT_AN_INTERRUPT
#define NOT_AN_INTERRUPT -1
#define digitalPinToInterrupt(p) ( (p) == 10 ? 0 : (
(p) == 11 ? 1 : ( (p) == 2 ? 2 : NOT_AN_INTERRUPT ) ) )
#endif
#define PIN_D0 (0)
#define PIN_D1 (1)
#define PIN_D2 (2)
#define PIN_D3 (3)
#define PIN_D4 (4)
#define PIN_D5 (5)
#define PIN_D6 (6)
#define PIN_D7 (7)
#define PIN_D8 (8)
#define PIN_D9 (9)
#define PIN_D10 (10)
#define PIN_D11 (11)
#define PIN_D12 (12)
#define PIN_D13 (13)
#define PIN_D14 (14)
#define PIN_D15 (15)
#define PIN_D16 (16)
#define PIN_D17 (17)
#define PIN_D18 (18)
#define PIN_D19 (19)
#define PIN_D20 (20)
#define PIN_INT0 (10)
#define PIN_INT1 (11)
#define PIN_INT2 (2)
static const uint8_t D0 = PIN_D0;
static const uint8_t D1 = PIN_D1;
static const uint8_t D2 = PIN_D2;
static const uint8_t D3 = PIN_D3;
static const uint8_t D4 = PIN_D4;
static const uint8_t D5 = PIN_D5;
static const uint8_t D6 = PIN_D6;
static const uint8_t D7 = PIN_D7;
static const uint8_t D8 = PIN_D8;
static const uint8_t D9 = PIN_D9;
static const uint8_t D10 = PIN_D10;
static const uint8_t D11 = PIN_D11;
static const uint8_t D12 = PIN_D12;
static const uint8_t D13 = PIN_D13;
static const uint8_t D14 = PIN_D14;
static const uint8_t D15 = PIN_D15;
static const uint8_t D16 = PIN_D16;
static const uint8_t D17 = PIN_D17;
static const uint8_t D18 = PIN_D18;
static const uint8_t D19 = PIN_D19;
static const uint8_t D20 = PIN_D20;
static const uint8_t PIN_RX0 = PIN_D8;
static const uint8_t PIN_TX0 = PIN_D9;
static const uint8_t PIN_RX1 = PIN_D10;
static const uint8_t PIN_TX1 = PIN_D11;
static const uint8_t PIN_SCL = PIN_D16;
static const uint8_t PIN_SDA = PIN_D17;
static const uint8_t PIN_SCK = PIN_D7;
static const uint8_t PIN_MISO = PIN_D6;
static const uint8_t PIN_MOSI = PIN_D5;
static const uint8_t PIN_SS = PIN_D4;
#endif

Per chi poi preferisce altri ambienti di sviluppo, segnaliamo che la scheda è completamente programmabile utilizzando l’IDE di Microchip MPLAB X sia con il compilatore XC8 (che al momento supporta solo codice ‘C’) sia installando l’apposita “AVR Toolchain” (che permette anche di caricare codice ‘C++’). Il vantaggio nelll’utilizzare tale ambiente è che, collegando la scheda ad un programmatore/debugger JTAG supportato da MPLAB X, non solo è possibile effettuare la programmazione della MCU, ma è anche possibile fare il vero debug sia inserendo breakpoint che eseguendo il codice in modalità “step-by-step”.
Utilizzando la programmazione “ISP”, o quella “JTAG”, con l’ausilio di un programmatore esterno, si cancella il “bootloader”. Volendo ripristinare la scheda alle condizioni di origine, con il “bootloader” ed il programma di “blink” precaricati, è sufficiente scaricare dall’area download qui di seguito il file di nome “ProMidi.hex” e, sempre con l’aiuto del programmatore esterno, caricare tale file sulla scheda.
Nel caso si siano alterati anche i valori dei “FUSE”, sempre con l’ausilio di un programmatore esterno, è possibile ripristinarli ai seguenti valori originali:

Low = 0xD7, High = 0xDE, Ext = 0xFD.

Per quanto riguarda la piedinatura, la Tabella 1 fornisce dettagliate informazioni su ciascun pin che la scheda Pro Midi 1284P mette a disposizione.

Tab. 1

Schema del circuito ON/OFF MOSFET

Come accennato, la Pro Midi 1284P è dotata di un interruttore, basato su un MOSFET FDN360P, che è in grado di accendere e spegnere carichi collegati tra il pin SW della scheda e il pin GND. Tale transistor permette di controllare carichi con un assorbimento massimo di 800mA e solo in presenza di un alimentatore stabilizzato esterno in grado di fornire la necessaria corrente (quindi quando la scheda è alimentata tramite il pin RAW). Esso è controllato dal pin D12 (Fig. 4).

Fig. 4

Conclusioni

La Pro Midi 1284P che vi abbiamo presentato in questo articolo è la scheda ideale per chi, pur volendo rimanere nella famiglia AVR di Atmel, necessita di una notevole quantità sia di memoria Flash per il proprio codice, che di memoria SRAM. Proprio la notevole quantità di quest’ultima (si tratta di ben 16 kB), la rende la scheda ideale per chi vuole sviluppare applicazioni con l’ausilio del sistema operativo “real time” FreeRTOS™, mantenendo la semplicità di programmazione in ambiente Arduino grazie al suddetto “MightyCore”, installabile dal gestore di schede aggiuntive dell’IDE.
Le dimensioni estremamente ridotte ne permettono poi l’inserimento in apparecchiature estremamente compatte e, grazie alla possibilità di eliminare il “superfluo” (LED, pull-up, ecc.), anche a bassissimo consumo (si tratta di pochi microampere).
In un prossimo futuro ci ripromettiamo di proporre un’applicazione della scheda montata su una “developer’s board”, per consentire agli sviluppatori di realizzare prototipi basati sulla Pro Midi 1284P, fornendo accesso a tutti i pin, permettendone la programmazione da IDE Arduino o da MPLAB X da dove, con l’ausilio di un programmatore/debugger JTAG, è possibile l’esame del programma, delle variabili ed il completo“debug”.

Download

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Menu