ASM51

Olá pessoal, será que é possivel que a cada pic gravavado incremente um registrador e que o valor desse registrador seja gravado na eeprom interna do pic de maneira que o pic possa futuramente ler esse valor para transmití-lo quando solicitado identificando o dispositivo.

Estou utilizando o Mplab 6.4 e Mc flash.

Esse programa já esta funcionando o problema é que a cada pic que gravo tenho que alterar o valor da eeprom para não repetir o número que identifica o dispositivo.

Obrigado.

Uma questao importante....
Será que protegendo o código, nos configurations bit's - isso impede de ler essa regiao da memória do pic ? Se nao me engano, nos 16F a EEprom interna fica acima do 0x2100.

+++

Nesse caso é o próprio pic que fará a leitura de sua memória interna, não haverá problemas de estar com o código de proteção ativado.

É...mas essa área de EEprom é acessível pelo gravador - no caso o MPLAB permite visualizá-lo.

+++

No caso do Junior eu não sei se é possivel não mas Andre, tem como proteger a EEPROM contra leitura sim.

Com o PROMATE 3 (PM3) gravador de produção é possível, pesquise sobre SQTP, já implementei na flash o problema é o gravador, que não deve ser barato.

Olá Junior_C, por acaso eu esbarrei nesse código no CCS, talves seja o que vc precisa. Em um dos arquivos de exemlo do CCS (EX_CUST.C) o cabeçalho do arquivo começa assim:

Código: Selecionar todos

#pragma case
#pragma type short=8,int=16,long=32
#define version 0x0001

#if defined(__PCB__)
#include <16C56.H>
#pragma fuses HS,NOWDT,NOPROTECT
#pragma use delay(clock=20000000)
#pragma use rs232(baud=9600, xmit=PIN_A3, rcv=PIN_A2)
#define compiler __PCB__

#elif defined(__PCM__)
#include <16F877.H>
#pragma fuses HS,NOWDT,NOPROTECT,NOLVP
#pragma use delay(clock=20000000)
#pragma use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#define compiler __PCM__

#elif defined(__PCH__)
#include <18F452.H>
#pragma fuses HS,NOWDT,NOPROTECT,NOLVP
#pragma use delay(clock=20000000)
#pragma use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#define compiler __PCH__
#endif

#pragma id version
#reserve 0x20:0x2f

int CYCLES;    // Global cycles (note upper case)

#inline
void pulse_B0() {
#pragma use fast_io(B)
      output_low(PIN_B0);
      delay_ms(100);
      output_high(PIN_B0);
      delay_ms(100);
#pragma use standard_io(B)
}


#separate
void send_pulses() {
   int cycles;  // Local cycles (note lower case)

   for(cycles=CYCLES; cycles!=0; --cycles) {
      pulse_B0();
   }
}


#pragma zero_ram
void main() {

   output_low(PIN_B0);
   output_low(PIN_B1);

   printf("Firmware version is %4X\r\n",version);
   printf("Compiled on %s with compiler version %s\r\n",__DATE__,compiler);

   printf("Pulsing B0 and B1...");
   for(CYCLES=100;CYCLES<=300;CYCLES+=100) {
      printf("\r\nMajor cycle #%c...",(CYCLES/100)+'0');
      output_low(PIN_B1);
      output_high(PIN_B1);
      send_pulses();
   }
   printf("\r\nAll Done.");

   delay_ms(3);  // Allow UART to finish
}


não testei, mas acho que essa version deve ser uma versão que vai sendo incrementada a cada compilação ou gravação (só acho, não tenho certeza)

acho que esta usando assembler, mas se esse código for o que vc quer é só assembler no CCS e ver como fica.

Valeu!!

Obrigado pela ajuda, programo em Assembler mesmo estou iniciando em C agora, vou tentar descobrir o que esse fragmento faz.

Junior_C escreveu:Obrigado pela ajuda, programo em Assembler mesmo estou iniciando em C agora, vou tentar descobrir o que esse fragmento faz.

Por favor, quando descobrir o que significa, poste a resposta aqui. Obrigado!!!