Come si può usare un microcontrollore che ha solo 384 byte di memoria del programma?

Ad esempio un PIC10F200T

Praticamente qualsiasi codice che scrivi sarà più grande di quello, a meno che non sia un chip monouso. C'è un modo per caricare più memoria di programma dalla memoria esterna o qualcosa del genere? Sono solo curioso, non vedo come questo possa essere molto utile ... ma deve essere.

Ragazzi, scendete dal mio prato!

384 byte sono un sacco di spazio per creare qualcosa di abbastanza complesso in assemblatore.

Se ripercorri la storia fino a quando i computer avevano le dimensioni di una stanza, troverai alcune incredibili abilità artistiche eseguite in <1k.

Ad esempio, leggi la classica Story of Mel - A Real Programmer . Certo, quei ragazzi avevano 4096 parole di memoria con cui giocare, gli infedeli decadenti.

Guarda anche alcune delle vecchie competizioni di demoscene in cui la sfida era quella di inserire una "introduzione" nel blocco di avvio di un floppy, con obiettivi tipici di 4k o 40k e di solito riuscendo a includere musica e animazione.

Modifica da aggiungere : risulta che puoi implementare il primo calcolatore scientifico da $ 100 al mondo in 320 parole.

Modifica per i giovani "uns:

• Floppy = floppy disk.
• Bootblock = 1 ° settore del floppy letto all'avvio.
• Demoscene = gare di programmazione tra gruppi di hacker.
• Assembler = modo elegante di programmare un dispositivo se sei troppo morbido per usare 8 interruttori a levetta e un pulsante "store".

I microcontrollori sono sufficientemente economici da essere spesso utilizzati per fare cose davvero semplici che negli anni passati sarebbero state probabilmente realizzate con una logica discreta. Cose davvero semplici. Ad esempio, si potrebbe desiderare che un dispositivo accenda un'uscita per un secondo ogni cinque secondi, più precisamente di quanto sarebbe in grado di fare un timer 555.

  movwf OSCCON
mainLp:
  ; Set output low
  clrf  GPIO
  movlw 0xFE
  movwf TRIS
  clrwdt
  call  Wait1Sec
  clrwdt
  call  Wait1Sec
  clrwdt
  call  Wait1Sec
  clrwdt
  call  Wait1Sec
  ; Set output high
  bsf   GPIO,0
  clrwdt
  call  Wait1Sec
  goto  mainLp
Wait1Sec:
  movlw 6
  movwf count2
  movlw 23
  movwf count1
  movlw 17
  movwf count0
waitLp:
  decfsz count0
   goto   waitLp
  decfsz count1
   goto   waitLp
  decfsz count2
   goto   waitLp
  retlw  0

Sarebbe un'applicazione reale, utilizzabile, in meno di 32 parole (48 byte) di spazio di codice. Si potrebbero facilmente aggiungere alcune opzioni per avere alcune opzioni di temporizzazione del controllo dei pin I / O e avere ancora un sacco di spazio libero, ma anche se tutto il chip fosse esattamente quello che viene mostrato sopra potrebbe essere ancora più economico e più facile di qualsiasi alternativa usando discreto logica. A proposito, le clrwdtistruzioni potrebbero essere spostate nella subroutine, ma ciò renderebbe le cose meno robuste. Come scritto, anche se un glitch fa sì che lo stack dell'indirizzo di ritorno venga danneggiato, il watchdog non verrà alimentato fino a quando l'esecuzione non tornerà al ciclo principale. Se ciò non accade, il watchdog ripristinerà il chip dopo un paio di secondi.

"SOLO" 384 byte?

Nel lontano passato, avevo il compito di scrivere un intero sistema operativo (da solo) per un computer specializzato che serviva l'industria navale, del gasdotto e della gestione della raffineria. Il primo prodotto di questo tipo era basato su 6800 e veniva aggiornato a 6809 e desideravano un nuovo sistema operativo in combinazione con il 6809 in modo da poter eliminare i costi di licenza del sistema operativo originale. Stavano anche aumentando le dimensioni della ROM di boot a 64 byte, da 32 a 32. Se ricordo bene - ERA circa 33 anni fa! - Ho convinto gli ingegneri a darmi 128 byte in modo da poter mettere i driver di dispositivo dell'intero sistema operativo sul rom e quindi rendere l'intero dispositivo più affidabile e versatile. Questo includeva:

• Driver della tastiera con debounce dei tasti
• Driver video
• Driver dell'unità disco e file system rudimentale ("abloader format" Motorola, IIRC), con capacità integrata di trattare la memoria "in banca" come se fosse uno spazio su disco veramente veloce.
• Driver del modem (hanno ottenuto l'FSK al contrario, quindi questi modem hanno solo parlato tra loro)

Sì, tutti questi erano nudi come l'osso e ottimizzati a mano per rimuovere ogni ciclo estraneo, ma perfettamente funzionanti e affidabili. Sì, ho inserito tutto ciò nei byte disponibili - oh, ha anche impostato la gestione degli interrupt, i vari stack e inizializzato il sistema operativo in tempo reale / multitasking, richiesto all'utente le opzioni di avvio e avviato il sistema.

Un mio amico che è ancora affiliato all'azienda (il suo successore) mi ha detto alcuni anni fa che il mio codice è ancora in servizio!

Puoi fare MOLTO con 384 byte ...

Puoi usarlo per applicazioni molto piccole (ad es. Avvio ritardato dell'alimentatore , sostituzione del timer 555 , controllo basato sul triac , LED lampeggiante ecc ...) con un ingombro inferiore rispetto a quello che ti servirà con le porte logiche o un timer 555.

Ho progettato un sensore di umidità per le piante che traccia la quantità di acqua della pianta e fa lampeggiare un LED se la pianta ha bisogno di acqua. Puoi fare in modo che il sensore apprenda il tipo di impianto e quindi cambi le sue impostazioni durante il funzionamento. Rileva bassa tensione sulla batteria. Ho esaurito flash e ram ma sono stato in grado di scrivere tutto nel codice C per far funzionare perfettamente questo prodotto.

Ho usato l'immagine di cui parli.

Ecco il codice che ho creato per il mio sensore dell'acqua dell'impianto. Ho usato pic10f220 poiché ha un modulo ADC, ha la stessa memoria di pic10f200, domani proverò a trovare lo schema.

Il codice è in spagnolo, ma è molto semplice e dovrebbe essere facilmente compreso. Quando Pic10F si riattiva dalla modalità di sospensione, verrà ripristinato, quindi è necessario verificare se si trattava di un PowerUp o di un ripristino e agire di conseguenza. L'impostazione della pianta è mantenuta nella ram poiché non si spegne mai veramente.

MAIN.C

/*
Author: woziX (AML)

Feel free to use the code as you wish. 
*/

#include "main.h"

void main(void) 
{  
    unsigned char Humedad_Ref;
    unsigned char Ciclos;
    unsigned char Bateria_Baja;
    unsigned char Humedad_Ref_Bkp;

    OSCCAL &= 0xfe;             //Solo borramos el primer bit
    WDT_POST64();                   //1s
    ADCON0 = 0b01000000;
    LEDOFF();
    TRIS_LEDOFF(); 

    for(;;) 
    {  
        //Se checa si es la primera vez que arranca
        if(FIRST_RUN())
        {
            Ciclos = 0;
            Humedad_Ref = 0;
            Bateria_Baja = 0;
        }

        //Checamos el nivel de la bateria cuando arranca por primera vez y cada 255 ciclos.
        if(Ciclos == 0)
        {
            if(Bateria_Baja)
            {
                Bateria_Baja--;
                Blink(2);
                WDT_POST128();
                SLEEP();
            }       

            if(BateriaBaja())
            {
                Bateria_Baja = 100;     //Vamos a parpadear doble por 100 ciclos de 2 segundos
                SLEEP();
            }
            Ciclos = 255;
        }   

        //Checamos si el boton esta picado
        if(Boton_Picado)
        {
            WDT_POST128();
            CLRWDT();
            TRIS_LEDON(); 
            LEDON();
            __delay_ms(1000);   
            TRIS_ADOFF();
            Humedad_Ref = Humedad();
            Humedad_Ref_Bkp = Humedad_Ref;
        }   

        //Checamos si esta calibrado. Esta calibrado si Humedad_Ref es mayor a cero
        if( (!Humedad_Ref) || (Humedad_Ref != Humedad_Ref_Bkp) )
        {
            //No esta calibrado, hacer blink y dormir
            Blink(3);
            SLEEP();
        }   

        //Checamos que Humedad_Ref sea mayor o igual a 4 antes de restarle 
        if(Humedad_Ref <= (255 - Offset_Muy_Seca))
        {
            if(Humedad() > (Humedad_Ref + Offset_Muy_Seca)) //planta casi seca
            {
                Blink(1);
                WDT_POST32();
                SLEEP();    
            }       
        }

        if(Humedad() >= (Humedad_Ref))  //planta seca
        {
            Blink(1);
            WDT_POST64();
            SLEEP();    
        }   

        if(Humedad_Ref >= Offset_Casi_Seca )
        {
            //Si Humedad_Ref es menor a Humedad, entonces la tierra esta seca. 
            if(Humedad() > (Humedad_Ref - Offset_Casi_Seca))  //Planta muy seca
            {
                Blink(1);
                WDT_POST128();
                SLEEP();    
            }
        }

        SLEEP();
    }  
} 

unsigned char Humedad (void)
{
    LEDOFF();
    TRIS_ADON();
    ADON();
    ADCON0_CH0_ADON();
    __delay_us(12); 
    GO_nDONE = 1;
    while(GO_nDONE);
    TRIS_ADOFF();
    ADCON0_CH0_ADOFF();
    return ADRES;
}   

//Regresa 1 si la bateria esta baja (fijado por el define LOWBAT)
//Regresa 0 si la bateria no esta baja
unsigned char BateriaBaja (void)
{
    LEDON();                
    TRIS_ADLEDON();
    ADON();
    ADCON0_ABSREF_ADON();
    __delay_us(150);        //Delay largo para que se baje el voltaje de la bateria 
    GO_nDONE = 1;
    while(GO_nDONE);
    TRIS_ADOFF();
    LEDOFF();
    ADCON0_ABSREF_ADOFF();  
    return (ADRES > LOWBAT ? 1 : 0);
}   

void Blink(unsigned char veces)
{
    while(veces)
    {
        veces--;
        WDT_POST64();
        TRIS_LEDON(); 
        CLRWDT();
        LEDON();
        __delay_ms(18); 
        LEDOFF();
        TRIS_ADOFF();
        if(veces)__delay_ms(320);   
    }   
}   

main.h

/*
Author: woziX (AML)

Feel free to use the code as you wish. 
*/

#ifndef MAIN_H
#define MAIN_H

#include <htc.h>
#include <pic.h>

 __CONFIG (MCPU_OFF  & WDTE_ON & CP_OFF & MCLRE_OFF & IOSCFS_4MHZ ); 

#define _XTAL_FREQ              4000000
#define TRIS_ADON()             TRIS = 0b1101
#define TRIS_ADOFF()            TRIS = 0b1111
#define TRIS_LEDON()            TRIS = 0b1011
#define TRIS_LEDOFF()           TRIS = 0b1111
#define TRIS_ADLEDON()          TRIS = 0b1001


#define ADCON0_CH0_ADON()          ADCON0 = 0b01000001;     // Canal 0 sin ADON
#define ADCON0_CH0_ADOFF()       ADCON0 = 0b01000000;       // Canal 0 con adON
#define ADCON0_ABSREF_ADOFF()    ADCON0 = 0b01001100;       //Referencia interna absoluta sin ADON
#define ADCON0_ABSREF_ADON()     ADCON0 = 0b01001101;       //referencia interna absoluta con ADON

//Llamar a WDT_POST() tambien cambia las otras configuracion de OPTION
#define WDT_POST1()   OPTION = 0b11001000
#define WDT_POST2()   OPTION = 0b11001001
#define WDT_POST4()   OPTION = 0b11001010
#define WDT_POST8()   OPTION = 0b11001011
#define WDT_POST16()  OPTION = 0b11001100
#define WDT_POST32()  OPTION = 0b11001101
#define WDT_POST64()  OPTION = 0b11001110
#define WDT_POST128() OPTION = 0b11001111

#define Boton_Picado    !GP3
#define FIRST_RUN()     (STATUS & 0x10) //Solo tomamos el bit TO

//Offsets
#define Offset_Casi_Seca  5
#define Offset_Muy_Seca   5

 //Low Bat Threshold
#define LOWBAT                    73
/*
Los siguientes valores son aproximados
LOWBAT  VDD
50      3.07
51      3.01
52      2.95
53      2.90
54      2.84
55      2.79
56      2.74
57      2.69
58      2.65
59      2.60
60      2.56
61      2.52
62      2.48
63      2.44
64      2.40
65      2.36
66      2.33
67      2.29
68      2.26
69      2.23
70      2.19
71      2.16
72      2.13
73      2.10
74      2.08
75      2.05
76      2.02
77      1.99
78      1.97
*/


#define LEDON()                 GP2 = 0; //GPIO = GPIO & 0b1011
#define LEDOFF()                GP2 = 1; //GPIO = GPIO | 0b0100
#define ADON()                  GP1 = 0; //GPIO = GPIO & 0b1101
#define ADOFF()                 GP1 = 1; //GPIO = GPIO | 0b0010

unsigned char Humedad (void);
unsigned char BateriaBaja (void);
void Delay_Parpadeo(void);
void Blink(unsigned char veces);

#endif

Fammi sapere se hai domande, proverò a rispondere in base a ciò che ricordo. L'ho codificato diversi anni fa, quindi non controllare le mie capacità di codifica, sono migliorate :).

Nota finale Ho usato il compilatore Hi-Tech C.

Una cosa che non ho mai visto menzionato: il microcontrollore che hai citato è solo $ 0,34 ciascuno in quantità di 100. Quindi, per prodotti economici, fabbricati in serie, può avere senso andare al problema di codifica aggiuntivo imposto da un'unità così limitata. Lo stesso potrebbe valere per dimensioni o consumo energetico.

Quando ero al liceo, avevo un insegnante che insisteva sul fatto che l'oscuramento della luce fosse un compito troppo difficile da affrontare per uno studente come me.

Così sfidato, ho trascorso un bel po 'di tempo a imparare e comprendere l'oscuramento della luce basato sulla fase usando triac e programmando il 16C84 dal microchip per eseguire questa impresa. Ho finito con questo codice assembly:

'Timing info:
'There are 120 half-cycles in a 60Hz AC waveform
'We want to be able to trigger a triac at any of 256 
'points inside each half-cycle.  So:
'1 Half cycle takes 8 1/3 mS
'1/256 of one half cycle takes about 32.6uS
'The Pause function here waits (34 * 0xD)uS, plus 3uS overhead
'Overhead includes CALL PAUSE.
'This was originally assembled using Parallax's "8051 style" 
'assembler, and was not optimized any further.  I suppose
'it could be modified to be closer to 32 or 33uS, but it is
'sufficient for my testing purposes.

list 16c84

    movlw   0xFD     '11111101
    tris    0x5      'Port A
    movlw   0xFF     '11111111
    tris    0x6      'Port B
WaitLow:             'Wait for zero-crossing start
    btfss   0x5,0x0  'Port A, Bit 1
    goto    WaitLow  'If high, goto WaitLow
WaitHigh:            'Wait for end of Zero Crossing
    btfsc   0x5,0x0  'Port A, Bit 1
    goto    WaitHigh 'If low, goto waitHigh
    call    Pause    'Wait for 0xD * 34 + 3 uS
    bcf     0x5,0x1  'Put Low on port A, Bit 1
    movlw   0x3      'Put 3 into W
    movwf   0xD      'Put W into 0xD
    call    Pause    'Call Pause, 105 uS
    bsf     0x5,0x1  'Put High on Port A, Bit 1
    decf    0xE      'Decrement E
    movf    0x6,W    'Copy Port B to W
    movwf   0xD      'Copy W to 0xD
    goto    Start    'Wait for zero Crossing
Pause:               'This pauses for 0xD * 34 + 3 Micro Seconds
                     'Our goal is approx. 32 uS per 0xD
                     'But this is close enough for testing
    movlw   0xA      'Move 10 to W
    movwf   0xC      'Move W to 0xC
Label1:
    decfsz  0xC      'Decrement C
    goto    Label1   'If C is not zero, goto Label1
    decfsz  0xD      'Decrement D
    goto    Pause    'If D is not zero, goto Pause
    return           'Return

Ovviamente dovresti modificarlo per il chip che menzioni, e forse aggiungere una routine seriale economica per l'input poiché il tuo chip non ha una porta larga 8 bit da ascoltare, ma l'idea è che un lavoro apparentemente complesso può eseguire con pochissimo codice: è possibile inserire dieci copie del programma sopra in 10F200.

Puoi trovare ulteriori informazioni sul progetto nella mia pagina Light Dimming . Per inciso, non l'ho mai mostrato al mio insegnante, ma alla fine ho fatto una serie di impianti di illuminazione per il mio amico DJ.

Bene, anni fa ho scritto un controller di temperatura con I / O seriale (bit-bang sull'I / O seriale perché l'MCU non aveva un UART) e un semplice interprete di comandi per parlare con il controller. MCU era un MC68HC705K1 Motorola (ora Freescale) che aveva un enorme 504 byte di memoria del programma (OTPROM) e circa 32 byte di RAM. Non meno del PIC a cui fai riferimento, ma ricordo di aver lasciato un po 'di ROM. Mi rimangono ancora alcune unità assemblate, 17 anni dopo; vuoi comprarne uno?

Quindi sì, può essere fatto, almeno in assemblea.

In ogni caso, di recente ho scritto programmi C molto semplici che probabilmente si sarebbero adattati a 384 byte se ottimizzati. Non tutto richiede un software ampio e complesso.

È possibile scrivere in un batter d'occhio un LED con 384 byte di memoria di programma e anche di più.

Per quanto ne so, non è possibile estendere la memoria del programma con un chip esterno (a meno che non si stia costruendo un interprete ASM completo nei 384 byte , che sarebbe lento). Tuttavia, è possibile estendere la memoria dei dati con un chip esterno (EEPROM, SRAM).

In realtà è peggio di quanto pensi. La tua pagina Mouser collegata è fonte di confusione quando specifica che questo processore ha 384 byte di memoria del programma. Il PIC10F200 in realtà ha 256 parole a 12 bit di memoria del programma.

Quindi, cosa puoi farci? Il set di istruzioni PIC a 12 bit utilizzato dai dispositivi PIC10F20 x sono tutte istruzioni a parola singola, quindi dopo aver sottratto alcune istruzioni per la configurazione del processore, viene lasciato spazio sufficiente per un programma di circa 250 passaggi. Questo è abbastanza per molte applicazioni. Probabilmente potrei scrivere un controller di lavatrice in quel tipo di spazio, per esempio.

Ho appena esaminato i compilatori PIC C disponibili e sembra che circa la metà di essi non proverà nemmeno a emettere codice per un PIC10F200. Quelli che probabilmente emettono così tanto codice del boilerplate che potresti essere in grado di scrivere solo un lampeggiatore a LED nello spazio a sinistra. Volete davvero usare il linguaggio assembly con un tale processore.

agitando la mia canna ai miei giorni, abbiamo dovuto incidere i nostri pezzi dalla sabbia!

Nel 1976 (o giù di lì) il sistema Atari 2600 VCS era una delle "piattaforme di videogiochi" più popolari dell'epoca. In esso, il microprocessore (MOSTEK 6507) funzionava ad un ardente ~ 1 MHz e aveva **** 128 byte di RAM **.

Un secondo esempio che ricordo di un microcontrollore con RAM estremamente limitata (~ 128 byte) è stato un PIC12F utilizzato su un convertitore DC-DC. Questo micro doveva anche usare il linguaggio assembly per funzionare.