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


67

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.


6
Há uma abundância de aplicativos para pequenas microcontroladores, a partir de geradores de sinais para fins especiais, para conversores de protocolo, para "nós" em um sistema de controle maior, etc., etc.,
Dave Tweed

13
Bem, um programa de xadrez leva 672 bytes, então isso não é bom. en.wikipedia.org/wiki/1K_ZX_Chess
John Burton

8
Aqui estão alguns exemplos do que pode ser feito com pequenos programas (menos de 256 bytes).
hammar

9
O que você quer dizer com "a menos que seja um chip de propósito único"? A maioria dos sistemas embarcados tem um único objetivo.
Jeanne Pindar

6
De volta à faculdade, criei um programa de semáforo totalmente funcional para um computador 8085/8155 (máximo de 256 bytes) que montei. Tinha botões para andar e alguns sensores que simulavam a presença de um veículo.
Zoredache

Respostas:


133

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".

4
O console do jogo Atari 2600 possuía apenas 4KB de armazenamento nos cartuchos de ROM (embora alguns jogos tenham contornado essa limitação usando a troca de banco para acessar mais de 4K).
Johnny

11
Éons atrás, fiz um gorjeio bem realista de pássaro (o suficiente para que as pessoas procurassem pelo pássaro em vez de suspeitar do computador), cujas entranhas (mas não o código aleatório que o impedia de emitir exatamente o mesmo som a cada vez) teriam sacudido. em torno de 384 bytes e eu tinha restrições adicionais de nenhum endereço gravável e um byte zero não era permitido no binário.
Loren Pechtel

2
Eu preciso sair mais, lembrou-se esta de volta no o dia - protetor de tela em 368 bytes: aminet.net/package/util/blank/368blanker
John L

7
+1 para "A história de Mel". Uma das melhores coisas que li a semana toda.
Justin ᚅᚔᚈᚄᚒᚔ

11
@ JohnU: Os primeiros jogos no Atari 2600 foram todos em 2K. Muitos desenvolvedores nunca projetaram nenhum jogo que fosse além de 4K, porque, embora os chips de 8K fossem acessíveis (e os carrinhos de algumas empresas simplesmente usavam metade de um chip de 4K), adicionavam troca de banco a um cartão usando um padrão (seleção de chips com baixo ativo) O chip aumentou o número de chips de suporte de um para três.
Supercat 2/13

59

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.


9
Honestamente, você pode otimizar um pouco o seu código, dando um mau exemplo às crianças - 5 chamadas separadas para wait1sec ??? Wastrel! ;)
John U

9
@JohnU: FYI, o código usa chamadas separadas porque, se ele usasse um contador de contagem de zero e a contagem falhasse, o loop poderia ser executado 255 vezes em vez de quatro, enquanto alimentava o cão de guarda uma vez por segundo. Embora seja possível evitar isso, verificando em cada loop se a contagem estava dentro do intervalo, o código para fazer isso acaba sendo mais complicado do que cinco chamadas e cinco clrwdtinstruções. Este não é o arranjo de contador absolutamente absolutamente à prova de falhas possível, mas é levada em consideração questões de segurança (por exemplo, evitar clrwdtdentro de uma sub-rotina).
Supercat

10
@ coder543: Na ausência de coisas como ruído na fonte de alimentação, não muito. Por outro lado, em partes sem um detector de queda de energia, é possível que todo tipo de coisa louca aconteça se o VDD cair para um nível entre a tensão operacional mínima e o terra, e depois voltar ao normal. Geralmente, deve-se tentar garantir que qualquer estado em que o dispositivo se encontre volte ao normal em um período de tempo razoável. Os dois segundos mais ou menos para o cão de guarda entrar em ação podem ser inevitáveis, mas quatro minutos para um contador com falha chegar a zero pode ser um pouco demais.
Supercat

10
@ coder543, eles acontecem com mais frequência em uma demonstração importante do que você deseja acreditar. Esse tipo de pensamento também é necessário ao criar coisas profundamente arraigadas que não têm como pedir ajuda ou relatar um erro. Ou são inacessíveis (pense no fundo do mar ou no espaço sideral), mesmo que um erro tenha sido notado.
RBerteig

6
@ JohnU: Eu notei, mas achei que explicar por que eu escrevi o código como eu fiz pode ser útil. Aliás, eu também estava tentando mostrar que pequenas tarefas podem caber em um pequeno processador, mesmo que não sejam otimizadas absolutamente perfeitamente.
Supercat 2/13

26

"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 ...


2
você diz boot rom e menciona a movimentação de drivers para o boot rom ... isso indica para mim que havia um meio de armazenamento secundário disponível. Nesta discussão, já determinamos que você não pode carregar o código do armazenamento externo neste PIC.
coder543

5
@ coder543 Isso está errado: 384 bytes são suficientes para fazer bastante! A pergunta original parecia uma queixa de que 384 não era suficiente para fazer algo útil - era mais do que eu precisava - muito mais - fornecer todos os componentes fundamentais de um sistema operacional multitarefa em tempo real ...
O que você


17

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.


3
Seria realmente interessante ler como você fez isso. Você fez alguma anotação enquanto fazia isso que não se importaria de compartilhar nas redes?
RhysW #

11
Olá RhysW, acredito que ainda tenho o código. Na verdade, era realmente simples. Eu poderia enviar meu código se você estiver interessado. Avise-se me. O circuito que eu projetei é muito simples e legal, apenas 3 resistores, um mosfet de canal p (para proteção reversa da bateria) uma tampa de 100nF e um LED. Eu uso um diodo interno no pic10f para usar como referência para medição de bateria e manter as leituras de ADC constantes.
scrafy

11
Isso soa como um projeto arrumado. Existe alguma chance de você poder postar os detalhes aqui (ou pelo menos publicá-los em algum lugar e vincular a eles)?
Ilmari Karonen

11
Olá scrafy! Por favor, se você tiver algo a acrescentar a uma resposta, use o link "editar" em vez de postar uma nova resposta, pois este site usa votação e não funciona como um fórum.
clabacchio

16

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.


2
Esse foi exatamente o meu primeiro pensamento. Além disso: se eu fosse uma startup com uma idéia interessante, mas apenas algumas centenas de dólares a mais, coisas assim podem significar a diferença entre voltar ao trabalho do dia e sair do trabalho do dia.
Phresnel

14

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.


12

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.


5

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).


11
Não seria duro para construir um simulador de máquina de Turing em 384 bytes ...
Chris Stratton

@ ChrisStratton, eu quis dizer um intérprete completo, para que a 'memória estendida do programa' tenha os mesmos recursos que o normal.

Sim, foi o que sugeri um meio de implementar rigidamente. O resto é projeto apenas compilador ...
Chris Stratton

7
Se alguém quiser que a lógica do programa seja armazenada em uma EEPROM externa, tentar emular o conjunto de instruções PIC não seria o caminho a seguir. Uma abordagem melhor seria projetar um conjunto de instruções otimizado para uso com a máquina virtual; de fato, essa é a abordagem que a Parallax adotou com seu "Selo Básico" nos anos 90. Era um PIC com 3072 bytes de espaço de código, emparelhado com um chip EEPROM serial.
Supercat

3
BTW, uma observação adicional sobre o carimbo BASIC: foi introduzido em um momento em que microcontroladores baseados em flash ou EEPROM eram comparativamente raros, mas os chips seriais EEPROM eram relativamente baratos. Para aplicativos que não precisavam de muita velocidade, um micro de código fixo com uma peça EEPROM serial seria mais barato que um EEPROM de tamanho comparável ou micro baseado em flash. O design do BASIC Stamp não faria sentido hoje, mas era bastante prático quando foi introduzido.
Supercat 2/13

4

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.


Você está certo sobre as 256 palavras de instrução. Na verdade, um deles é utilizado com a constante de calibração do oscilador, para que você obtenha 255 instruções úteis. Além disso, o 10F200 não usa o conjunto de instruções de 14 bits PIC 16 usual. Ele usa o conjunto de instruções PIC 12 de 12 bits. No entanto, concordo com suas premissas básicas. Eu fiz muitas coisas úteis com uma PIC 10F200. +1
Olin Lathrop

@OlinLathrop: Esclareci a resposta. Eu peguei o termo PIC16 na página 51 do conjunto de dados , mas decidi que é mais claro apenas se referir ao "conjunto de instruções de 12 bits". O prefixo da peça não é um guia confiável para o conjunto de instruções usado.
Warren Young

0

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.


4
O OP não está falando sobre RAM, ele está falando sobre o espaço do programa. O espaço do programa no Atari 2600 está no cartucho, não no chip RIOT . O 2600 suportou ROMs de programa de até 4 kiB sem troca de banco. (E alguns cartuchos comerciais se ! Fazer a mudança de banco) Quanto ao seu exemplo PIC12F, o OP está com você vencer: os dispositivos da série PIC10F20x tem 16 ou 24 bytes de SRAM.
Warren Young
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.