codigo protegido contra escrita

[lucastanure]

pessoal eu estou escrevendo um bootloader , mas tenho um problema que não consigo resolver ...
eu gravo todo o codigo que recebo do pc na memoria , mas a chamada inicial desse codigo que deveria estar na possição 0x0000 eu gravo no final do bootloader..... assim o bootloader inicia e depois o codigo principal é chamado...
meu problema é que não consigo escrever dentro do codigo do bootloader...
eu uso o compilador da ccs em c .... ja tentei usar as duas funções de gravação na flash...
alguem pode me ajudar???

[fabim]

voce esta fazendo desta forma por ex:

ORG 0X0000;vetor de reset
goto bootloader.
main
x
x
x
x end;
bootloader
x
x
x
x
x
goto main.
end



??

[lucastanure]

é bem assim mesmo...olha o codigo...

tudo o que eu quero é reescrever o goto la do final para um endereço diferente de 0x0000 ... mas quando escrevo nessa posição de memoria da tudo errado

#include <18f4550.H>
#device ADC=10 *=16

#case

#fuses HSPLL, NOWDT , NOPROTECT ,PUT, USBDIV,PLL5, NODEBUG, CPUDIV1, VREGEN, BROWNOUT, NOWRT
#use delay(clock=48000000)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)

// define possible reply bytes
#define READY_FOR_NEXT 0x11
#define FINISH_FLAG 0x55
#define BOOTLOADER_OVERWRITE 0x80

#define LOADER_BEGIN 0x7b00
#define LOADER_END 0x7fff

#define USBBufferSize 32 // USB input buffer size

#define RUN_BUTTON PIN_B7
#define RUN_LED PIN_B6
#define USER_LED PIN_D0


// #org tells the compiler where to put the procedures in memory
#ORG LOADER_BEGIN, LOADER_END auto=0 default


// a slim version of atoi().
// converts ascii text to integer
// i.e. '1' = 1, 'A' = 10
int a2i(char asciiByte) {

if (asciiByte >= 'A' && asciiByte <= 'F')
return((asciiByte) - 'A' + 10);
else if (asciiByte >= '0' && asciiByte <= '9')
return( asciiByte - '0');
}

void main()
{
///////////////////////////////////////////////////////////////////////
// contadores e flags
///////////////////////////////////////////////////////////////////////
int i=0,j=0;
int1 notDone = 1;
///////////////////////////////////////////////////////////////////////
// endereços
///////////////////////////////////////////////////////////////////////
unsigned int16 extended_linear_address = 0;
unsigned int32 UserBootVectorAddr;
unsigned int16 writeAddr =0 ;
///////////////////////////////////////////////////////////////////////
// variaveis para dados
///////////////////////////////////////////////////////////////////////
int Buffer[USBBufferSize];
int aux[32];
///////////////////////////////////////////////////////////////////////
// configurações de escrita
///////////////////////////////////////////////////////////////////////
int recLen;
char recType;

//usb_cdc_init();
//usb_init();

if (input(RUN_BUTTON))
{
UserBootVectorAddr = label_address(UserBootVector);
output_high(RUN_LED); output_high(USER_LED);
while (notDone)
{
while (getc() != ':') ;

for(i=0;i<6;i++)// leitura de dados padrões
{
aux[i] = getc();
}

recLen = (a2i(aux[0]) << 4) + a2i(aux[1]);// numero de bytes de dados

writeAddr = a2i(aux[2]);
writeAddr <<= 4;
writeAddr += a2i(aux[3]);
writeAddr <<= 4;
writeAddr += a2i(aux[4]);
writeAddr <<= 4;
writeAddr += a2i(aux[5]);

getc();
recType = getc();// tipo de escrita , esta prevista 0, 1 e 4

////////////////////////////////////////////////////////////////////////////
// Manipulando os dados
////////////////////////////////////////////////////////////////////////////
for(i=0;i<(recLen*2);i++)// pegando dados
{
aux[i] = getc();
}

for(i=0,j=0;i<(recLen*2);i=i+2,j++)// montando os bytes
{
Buffer[j] = a2i(aux[i]);
Buffer[j] <<= 4;
Buffer[j] += a2i(aux[i+1]);
}

if (recType == '1')
{
notDone = 0;
}

else if (recType == '4')
{
extended_linear_address = Buffer[0];
extended_linear_address <<= 8;
extended_linear_address += Buffer[1];
putc(READY_FOR_NEXT);
}

else if (recType == '0')
{
if(extended_linear_address > 0) // recebendo codigo da eeprom , bits de configuração, id ,
{
if (extended_linear_address == 0xf0)
{
for(i=0,j=0;i<(recLen/2);i++,j=j+2)
{
write_eeprom((int)(writeAddr + i), Buffer[j]);
}
}
else if (extended_linear_address == 0x30 )
{
// Não se pode reescrever os bits de configuração
// caso isso aconteça o bootloader não ira funcionar
}
}
else // extended_linear_address == 0 , recebendo o codigo principal
{
if ((writeAddr >= LOADER_BEGIN) && (writeAddr <= LOADER_END))
{
putc(BOOTLOADER_OVERWRITE);
}
else
{
if (writeAddr < 0x0008) // se for o goto do codigo recebido
{

write_program_memory(UserBootVectorAddr,Buffer,recLen);
}
else
{
write_program_memory(writeAddr,Buffer,recLen);
}
}
}
putc(READY_FOR_NEXT);
}
}
putc(FINISH_FLAG);
for (j=0;j<255;j++){for (i=0;i<255;i++){};}
}
UserBootVector:
#asm
MOVLW 0x00
MOVWF 0x0A
GOTO 0x00
NOP
NOP
#endasm
}
#ORG default

[ze]

o hitech-c tem 1 exemplo de bootloader. instale-o e avalie.

bootloader: não consegue viver sem ele??

[lucastanure]

Eu preciso usar o ccs c , pois ele possui uma biblioteca usb-serial. Essa biblioteca cria uma porta serial atraves da usb.
Depois de fazer esse bootloader funcionar em serial vou altera-lo para esse tipo de comunicação.
Voce naum tem ideia de por que ocorre o erro quando escrevo na area de codigo do bootloader?

[andre_luis]

lucas,

Suponho que voce esteja usando o ICD2 para gravar. O MPLAB define manualmente ou automaticamente o endereço inicial e final de gravação. Dá uma olhada nisso.

+++

[lucastanure]

Não , uso um gravador serial. Eu mesmo defino as posições do codigo.
No codigo , na parte de cima, voce pode ver que existe uma #org que define isso.

[lucastanure]

eu fiz alguns testes e me parece que as diretivas asm meio que protegem contra escrita... removi essas diretivas e coloquei uma função goto_address(0x0000);
e agora quero reescrever essa parte