Como alguém pode usar um microcontrolador que possui apenas 384 bytes de memória de programa?

Por exemplo, um PIC10F200T

Praticamente qualquer código que você escrever será maior que isso, a menos que seja um chip de finalidade única. Existe alguma maneira de carregar mais memória de programa do armazenamento externo ou algo assim? Só estou curioso, não vejo como isso poderia ser muito útil ... mas deve ser.

Vocês, crianças, desçam do meu gramado!

384 bytes é bastante espaço para criar algo bastante complexo no assembler.

Se você pesquisar na história quando os computadores eram do tamanho de uma sala, você encontrará alguns feitos de arte verdadeiramente incríveis, executados em <1k.

Por exemplo, leia o clássico Story of Mel - A Real Programmer . É certo que esses caras tinham 4096 palavras de memória para brincar, os infiéis decadentes.

Observe também algumas das antigas competições demoscene em que o desafio era encaixar uma "introdução" no bloco de inicialização de um disquete, os alvos típicos eram 4k ou 40k e geralmente conseguiam incluir música e animação.

Editar para adicionar : Acontece que você pode implementar a primeira calculadora científica de US $ 100 do mundo em 320 palavras.

Edite para os jovens:

• Disquete = disquete.
• Bootblock = 1º setor da leitura de disquete na inicialização.
• Demoscene = programação de competições entre grupos de hackers.
• Assembler = maneira sofisticada de programar um dispositivo, se você é muito macio para usar 8 interruptores e um botão "armazenar".

Os microcontroladores são baratos o suficiente para serem usados ​​com frequência para fazer coisas realmente simples que, no passado, provavelmente teriam sido feitas com lógica discreta. Coisas realmente simples. Por exemplo, pode-se querer que um dispositivo ligue uma saída por um segundo a cada cinco segundos, mais precisamente do que um temporizador 555 seria capaz de fazer.

  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

Isso seria um aplicativo real, utilizável, em menos de 32 palavras (48 bytes) de espaço de código. Pode-se facilmente adicionar algumas opções para que alguns pinos de E / S controlem as opções de tempo e ainda tenha muito espaço de sobra, mas mesmo que todo o chip tenha sido exatamente o que é mostrado acima, ainda pode ser mais barato e fácil do que qualquer alternativa usando discretos lógica. BTW, as clrwdtinstruções poderiam ser movidas para a sub-rotina, mas isso tornaria as coisas menos robustas. Como está escrito, mesmo que uma falha faça com que a pilha de endereço de retorno seja corrompida, o cão de guarda não será alimentado até que a execução retorne ao loop principal. Se isso nunca acontecer, o cão de guarda reiniciará o chip após alguns segundos.

"SOMENTE" 384 bytes?

No passado, eu tinha o trabalho de escrever um sistema operacional inteiro (sozinho) para um computador especializado que atendia o setor de gerenciamento de navios, oleodutos e refinarias. O primeiro produto da empresa foi baseado em 6800 e estava sendo atualizado para 6809, e eles queriam que um novo sistema operacional fosse compatível com o 6809 para eliminar os custos de licença do sistema operacional original. Eles também estavam aumentando o tamanho da ROM de inicialização para 64 bytes, acima dos 32. Se bem me lembro - foi há cerca de 33 anos! - Eu convenci os engenheiros a fornecerem 128 bytes para que eu pudesse colocar todos os drivers de dispositivo do sistema operacional na ROM e, assim, tornar todo o dispositivo mais confiável e versátil. Isso inclui:

• Driver de teclado com devolução de tecla
• Driver de vídeo
• Driver de unidade de disco e sistema de arquivos rudimentar (Motorola "formato de carregador", IIRC), com capacidade integrada de tratar a memória "depositada" como se fosse um espaço em disco realmente rápido.
• Driver de modem (eles obtiveram o FSK para trás, portanto esses modems apenas conversaram entre si)

Sim, tudo isso foi o mais simples possível e otimizado para as mãos para remover todos os ciclos estranhos, mas perfeitamente funcional e confiável. Sim, coloquei tudo isso nos bytes disponíveis - ah, também configurou o tratamento de interrupções, as várias pilhas e inicializei o sistema operacional em tempo real / multitarefas, avisei o usuário sobre as opções de inicialização e iniciei o sistema.

Um amigo meu que ainda é afiliado à empresa (seu sucessor) me disse há alguns anos que meu código ainda está em serviço!

Você pode fazer muito com 384 bytes ...

Você pode usar isso para aplicações muito pequenas (por exemplo , início atrasado da PSU , substituição do temporizador 555 , controle baseado em triac , LED piscando etc ...) com tamanho menor do que o necessário com portas lógicas ou um temporizador 555.

Projetei um sensor de umidade para plantas que rastreia a quantidade de água que a planta possui e pisca um LED se a planta precisar de água. Você pode fazer o sensor aprender o tipo de planta e, assim, alterar suas configurações durante a execução. Ele detecta baixa voltagem na bateria. Eu fiquei sem flash e ram, mas consegui escrever tudo em código C para fazer com que este produto funcionasse perfeitamente.

Eu usei o pic10f que você mencionou.

Aqui está o código que eu criei para o meu sensor de água da planta. Eu usei o pic10f220, pois possui um módulo ADC, ele tem a mesma memória que o pic10f200, tentarei encontrar o esquemático amanhã.

O código está em espanhol, mas é muito simples e deve ser facilmente entendido. Quando o Pic10F sair do modo de suspensão, ele será redefinido para que você precise verificar se foi um PowerUp ou uma redefinição e agir em conformidade. A configuração da planta é mantida no aríete, pois nunca realmente desliga.

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

Deixe-me saber se você tiver dúvidas, tentarei responder com base no que me lembro. Eu codifiquei isso há vários anos, então não verifique minhas habilidades de codificação, elas melhoraram :).

Nota final. Eu usei o compilador Hi-Tech C.

Uma coisa que eu não vi mencionado: o microcontrolador que você mencionou custa apenas US $ 0,34 cada, em quantidades de 100. Portanto, para produtos baratos produzidos em massa, pode fazer sentido ir para o problema extra de codificação imposto por uma unidade tão limitada. O mesmo pode se aplicar ao tamanho ou ao consumo de energia.

Quando eu estava no colegial, tive um professor que insistia que o escurecimento da luz era uma tarefa muito difícil para um aluno como eu enfrentar.

Assim desafiado, passei bastante tempo aprendendo e entendendo o escurecimento da luz com base em fase usando triacs e programando o 16C84 do microchip para realizar esse feito. Acabei com este código de montagem:

'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

É claro que você precisaria modificar isso para o chip mencionado e talvez adicionar uma rotina serial barata para entrada, já que seu chip não tem uma porta de 8 bits de largura para ouvir, mas a idéia é que um trabalho aparentemente complexo possa feito em muito pouco código - você pode ajustar dez cópias do programa acima no 10F200.

Você pode encontrar mais informações sobre o projeto na minha página Light Dimming . Aliás, eu nunca mostrei isso ao meu professor, mas acabei fazendo uma série de equipamentos de iluminação para o meu amigo DJ.

Bem, anos atrás, eu escrevi um controlador de temperatura com E / S serial (batendo a E / S serial porque o MCU não tinha um UART) e um simples interpretador de comandos para conversar com o controlador. O MCU era um MC68HC705K1 da Motorola (agora Freescale), com 504 bytes de memória de programa (OTPROM) e cerca de 32 bytes de RAM. Não tão pequeno quanto o PIC que você mencionou, mas eu lembro de ter sobrado ROM. Ainda tenho algumas unidades montadas, 17 anos depois; quer comprar um?

Então, sim, isso pode ser feito, pelo menos na montagem.

De qualquer forma, recentemente escrevi programas C muito simples que provavelmente caberiam em 384 bytes quando otimizados. Nem tudo requer software grande e complexo.

Você pode gravar um LED piscando com 384 bytes de memória de programa e muito mais.

Até onde eu sei, não é possível estender a memória do programa com um chip externo (a menos que você esteja criando um interpretador ASM completo nos 384 bytes , o que seria lento). É possível estender a memória de dados com um chip externo (EEPROM, SRAM).

Na verdade, é pior do que você pensa. A página vinculada da Mouser está confusa quando especifica esse processador como tendo 384 bytes de memória de programa. Na verdade, o PIC10F200 possui 256 palavras de 12 bits da memória do programa.

Então, o que você pode fazer com isso? O conjunto de instruções PIC de 12 bits usado pelos dispositivos PIC10F20 x são instruções de uma única palavra; portanto, depois de subtrair algumas instruções para a configuração do processador, você fica com espaço suficiente para um programa de cerca de 250 etapas. Isso é suficiente para muitas aplicações. Eu provavelmente poderia escrever um controlador de máquina de lavar nesse tipo de espaço, por exemplo.

Acabei de examinar os compiladores PIC C disponíveis e parece que cerca de metade deles nem sequer tentará emitir código para um PIC10F200. Aqueles que provavelmente publicam tanto código padrão que você pode apenas escrever um pisca-pisca de LED no espaço restante. Você realmente deseja usar a linguagem assembly com esse processador.

balançando minha bengala no meu dia, tivemos que gravar nossos próprios pedaços na areia!

Em 1976 (ou nos arredores), o sistema Atari 2600 VCS era uma das "plataformas de videogame" mais populares da época. Nele, o microprocessador (MOSTEK 6507) funcionava a aproximadamente 1 MHz e possuía **** 128 bytes de RAM **.

Um segundo exemplo que me lembro de um microcontrolador com RAM extremamente limitada (~ 128 bytes) foi um PIC12F usado em um conversor DC-DC. Este micro também teve que usar a linguagem assembly para rodar.