Programacao a distancia - OTA

[tcpipchip]

QUE TAL POR O PIC NO MODO MICROPROCESSADOR ????

[lucasromeiro]

QUE TAL POR O PIC NO MODO MICROPROCESSADOR ????

Desconheco este modo. (vou pesquisar aqui)

pelas minhas pesquisas, basicamente encontrei 2 formas:
-bootloader
-code-loader

[lucasromeiro]

x

x

x

Depois de um tempo, voltei =)
Agradeco a vcs pela colaboração!
A batalha continua.
Postei algumas informacoes.
Se puderem me ajudar de alguma forma, serei muito grato!

Valeu galera!

[lucasromeiro]

QUE TAL POR O PIC NO MODO MICROPROCESSADOR ????

infelizmente nao achei nada sobre isso.

[tcpipchip]

http://ww1.microchip.com/downloads/en/D ... 39626e.pdf

Pagina 108

[lucasromeiro]

http://ww1.microchip.com/downloads/en/DeviceDoc/39626e.pdf

Pagina 108

Legal, obrigado.
ainda estou entendendo o funcionamento.
ate onde entendi funciona como um code-loader mesmo.
os pontos ruins sao:
precisar daqueles 2 pinos extras (especificos).
se der algo na gravacao, f****.

por isso pensei em usar a memoria eeprom para guardar o programa, para fazer algum tipo de verificacao antes de gravar, ou ate mesmo ter 2 programas na eeprom, se um nao rodar (corromper) roda o segundo que era a versao anterior. algo assim...

mas ja estou complicando muito, o objetivo eh gravar, fazendo isso bem eh o que importa.

[ÁgioFelipe]

Não sei se entendi direito e nem se isso que vou dizer ajuda em alguma coisa, rsrsrsr
Mas eu já fiz um PIC gravar outro, isso ajudaria??

[lucasromeiro]

Não sei se entendi direito e nem se isso que vou dizer ajuda em alguma coisa, rsrsrsr
Mas eu já fiz um PIC gravar outro, isso ajudaria??

Claro que sim!
Acredito que o processo seja parecido!
Como vc fez?

O ideal no meu projeto seria:
baixar o programa, gravar ele na memoria externa.
ao reiniciar o pic ele verifica se tem algum programa novo e muda o programa interno.
ter 2 versoes do programa na memoria externa, caso a nova de algum problema ao iniciar, ele inicializa usando a versao anterior.

[guest2003]

Ola Lucas,

Temos um projeto de rastreador que faz isso que você quer fazer...

Temos um bootloader que gerencia tudo (inclusive confere CRC do software que baixou na flash, confere versão de firmware e hardware se batem)

Ele mantém na flash uma versão ok, e baixa a outra... se tudo mais falhar tem como você via hardware forçar um downgrade.

Prevejo sofrimento

abs!
Marcelo

[lucasromeiro]

Ola Lucas,

Temos um projeto de rastreador que faz isso que você quer fazer...

Temos um bootloader que gerencia tudo (inclusive confere CRC do software que baixou na flash, confere versão de firmware e hardware se batem)

Ele mantém na flash uma versão ok, e baixa a outra... se tudo mais falhar tem como você via hardware forçar um downgrade.

Prevejo sofrimento

abs!
Marcelo

Que interessante!
Basicamente é isso mesmo que preciso.
talvez o crc seja desnecessário pelo fato do protocolo de rede fazer isso sozinho. mas bom saber e por tambem um, nunca se sabe. rsrs
vc pode me dar uma forca nisso???
A unica pessoa que ja fez isso que encontrei foi vc! shauhsuah
teve sucesso? roda perfeito?

[ÁgioFelipe]

Não sei se entendi direito e nem se isso que vou dizer ajuda em alguma coisa, rsrsrsr
Mas eu já fiz um PIC gravar outro, isso ajudaria??

Claro que sim!
Acredito que o processo seja parecido!
Como vc fez?

O ideal no meu projeto seria:
baixar o programa, gravar ele na memoria externa.
ao reiniciar o pic ele verifica se tem algum programa novo e muda o programa interno.
ter 2 versoes do programa na memoria externa, caso a nova de algum problema ao iniciar, ele inicializa usando a versao anterior.

Segui o que está escrito aqui:
http://ww1.microchip.com/downloads/en/D ... 30277d.pdf
http://ww1.microchip.com/downloads/en/D ... 39589C.pdf

[lucasromeiro]

Não sei se entendi direito e nem se isso que vou dizer ajuda em alguma coisa, rsrsrsr
Mas eu já fiz um PIC gravar outro, isso ajudaria??

Claro que sim!
Acredito que o processo seja parecido!
Como vc fez?

O ideal no meu projeto seria:
baixar o programa, gravar ele na memoria externa.
ao reiniciar o pic ele verifica se tem algum programa novo e muda o programa interno.
ter 2 versoes do programa na memoria externa, caso a nova de algum problema ao iniciar, ele inicializa usando a versao anterior.

Segui o que está escrito aqui:
http://ww1.microchip.com/downloads/en/D ... 30277d.pdf
http://ww1.microchip.com/downloads/en/D ... 39589C.pdf

vou ler com calma!
Obrigado amigo!

[lucasromeiro]

olhando as bibliotecas disponíveis no CCS, vi que tem:
bootloader.h
loader.c
tem tambem 3 exemplos:
ex_load.c
ex_bootload.c
ex_bootloader.c

isso que irei usar, correto?
mas eu nao entendi ainda a diferenca de bootloader.h para loader.c.
qual eu deveria usar?
agora que achei estes exemplos e bibliotecas, ficou mais facil! não tinha visto antes!
estou pensando em fazer assim. me corrija se eu estiver errado.
1- uso bootloader.h junto com o loader.c, igual o exemplo EX_BOOTLOADER.c. mas no lugar de ler se tem algum pino em alta, eu leio um flag na eeprom para saber se devo atualizar.
2- eu recebo o codigo atraves do gprs, gravo na eeprom e sinalizo o flag de atualizacao. depois reinicio o pic.
3- vou ler que preciso atualizar e vou carregar os dados da eeprom na memoria do pic usando o loader.c. mas terei que fazer modificacoes para ele aceitar a leitura da eeprom.
4- mudo flag da memoria para gravado e reinicio o pic.

estou correto?

Eu só preciso entender 2 coisas.
1- como gravar na eeprom os dados recebidos. é cada caractere em um espaco de memoria?
2- como alterar o loader.c para ler da eeprom externa.

esqueci algo?

[HC908]

A galera aqui complica pra caramba uma coisa bem simples. Qualquer duvida pode perguntar.

Código: Selecionar todos

//bootloader code
#ifndef __BOOTLOADER_H__
#define __BOOTLOADER_H__

#define __BOOTLOADER_INCLUDED__ TRUE

#if defined(__PCM__)
#define LOADER_SIZE   0x1FF
#elif defined(__PCH__)
#define LOADER_SIZE   0xFFF
#endif
#endif
//BOOTLOADER AT END
// LOADER_END - This is the end of the general purpose bootload code.
#define LOADER_END      getenv("PROGRAM_MEMORY")-1
#define LOADER_ADDR LOADER_END-LOADER_SIZE

#ORG LOADER_ADDR+10, LOADER_END auto=0 default

//typedef  int32  int32;
#define FLASH_MAX_BLOCK_SIZE 1024

unsigned char g_flash_buffer[FLASH_MAX_BLOCK_SIZE] = "\0";


int1 g_flashBufferChanged = FALSE;
int1 flash_GOODEC;

int32 g_flashBufferAddress = 0xFFFF;

unsigned char flash_read_data(int32 address, int16 size, unsigned char * ptr);
unsigned char flash_write_data(int32 address, int16 size, unsigned char * ptr);

unsigned char flash_read_block(int32 address, int16 size, unsigned char * ptr);
unsigned char flash_write_block(int32 address, int16 size, unsigned char * ptr);

/// Fast Functions ! ///


unsigned char flash_load_buffer(void);
unsigned char flash_flush_buffer(void);
unsigned char flash_move_buffer(int32 new_addr);
unsigned char flash_read_byte(int32 addr, unsigned char* data);
unsigned char flash_write_byte(int32 addr, unsigned char data);


#byte TBLPTRU = 0xFF8
#byte TBLPTRH = 0xFF7
#byte TBLPTRL = 0xFF6
#byte TABLAT  = 0xFF5
#byte EECON2  = 0xFA7
#byte EECON1  = 0xFA6

#bit  WR =    0xFA6.1
#bit  EEPGD = 0xFA6.7
#bit  CFGS  = 0xFA6.6      
#bit  WREN =  0xFA6.2
#bit  FREE =  0xFA6.4

#bit  GIE  =  0xFF2.7

#SEPARATE

void ReadFlash(int32 startaddr, int16 num_bytes, unsigned char *flash_array) {
    int16 temp = 0, count = 0;
    ;
    TBLPTRU = ((int32) startaddr >> 16); //Load the address to Address pointer registers
    TBLPTRH = (int32) (((int32) startaddr) >> 8);
    TBLPTRL = ((int32) startaddr);

    if (num_bytes == 0) {
        num_bytes = 0x400;
        while (num_bytes--) {
#asm   TBLRD*+ #endasm
            temp = TABLAT;
        }
    } else {
        for (count = 0; count < num_bytes; count++) {
            //*********** Table read sequence ******************************
#asm   TBLRD*+ #endasm
            *flash_array++ = TABLAT;
        }
    }
}
#SEPARATE

void EraseFlash(int32 startaddr, int32 endaddr) {
    unsigned char flag = 0;

    //startaddr =(int32) ((unsigned char)(startaddr / 0x40)) *0x40;   //Calculate starting address of the block

    while (startaddr < endaddr) {
        TBLPTRU = ((int32) startaddr >> 16); //Load the address to Address pointer registers
        TBLPTRH = (int32) (((int32) startaddr) >> 8);
        TBLPTRL = ((int32) startaddr);
        //*********Flash Erase sequence*****************

        WREN = 1;
        FREE = 1;
        if (GIE) {
            GIE = 0;
            flag = 1;
        }
        EECON2 = 0x55;
        EECON2 = 0xAA;
        WR = 1;
        if (flag)GIE = 1;

        startaddr = startaddr + 0x400;
    }
}
#SEPARATE

void WriteBlockFlash(int32 startaddr, int16 num_blocks, unsigned char *flash_array) {
    int16 write_byte = 0, flag = 0;
    unsigned char data = 0;
    //   startaddr =(int32)(startaddr / 0x40) *0x40;   //Calculate starting address of the block
    //   ReadFlash(startaddr,0,flash_array);


    EraseFlash(startaddr, startaddr + 0x400);
    num_blocks = 16;
    while (num_blocks--) {

        for (write_byte = 0; write_byte < 0x40; write_byte++) {
            data = *flash_array;
            TABLAT = data;
#asm TBLWT*+    #endasm
            flash_array++;

        }
        TBLPTRU = ((int32) startaddr >> 16); //Load the address to Address pointer registers
        TBLPTRH = (int32) (((int32) startaddr) >> 8);
        TBLPTRL = ((int32) startaddr);
        //*********** Flash write sequence ***********************************
        WREN = 1;
        if (GIE) {
            GIE = 0;
            flag = 1;
        }
        EECON2 = 0x55;
        EECON2 = 0xAA;
        WR = 1;

        if (flag) {
            GIE = 1;
            flag = 0;
        }
        WREN = 0;

        startaddr = startaddr + 0x40; //increment to one block of 64 bytes


    }

}

#SEPARATE

unsigned char flash_reflash(int32 address) {
    return (flash_read_block(address, FLASH_MAX_BLOCK_SIZE, g_flash_buffer));
}
#SEPARATE

unsigned char flash_read_block(int32 address, int16 size, unsigned char * ptr) {
    ReadFlash((address * FLASH_MAX_BLOCK_SIZE), FLASH_MAX_BLOCK_SIZE, ptr);
    return flash_GOODEC;
}
#SEPARATE

unsigned char flash_write_block(int32 address, int16 size, unsigned char * ptr) {
    WriteBlockFlash((address * FLASH_MAX_BLOCK_SIZE), 1, ptr);
    return flash_GOODEC;
}
#SEPARATE

unsigned char flash_load_buffer(void) {
    g_flashBufferChanged = FALSE;
    return (flash_read_block(g_flashBufferAddress, FLASH_MAX_BLOCK_SIZE, g_flash_buffer));
}
#SEPARATE

unsigned char flash_flush_buffer(void) {
    if (g_flashBufferChanged) {
        g_flashBufferChanged = FALSE;
        return (flash_write_block(g_flashBufferAddress, FLASH_MAX_BLOCK_SIZE, g_flash_buffer));
    }
    return (0); //ok
}
#SEPARATE

unsigned char flash_move_buffer(int32 new_addr) {
    unsigned char ec;
    int32 new_block;

    ec = flash_GOODEC;

    new_block = new_addr / FLASH_MAX_BLOCK_SIZE;

    //if(cur_block != new_block)
    if (g_flashBufferAddress != new_block) {
        // dump the old buffer
        if (g_flashBufferChanged) {

            ec = flash_flush_buffer();
            if (ec != flash_GOODEC)
                return ec;
            g_flashBufferChanged = FALSE;
        }
        // figure out the best place for a block
        g_flashBufferAddress = new_block;
        // load up a new buffer
        ec = flash_load_buffer();
    }

    return ec;
}
#SEPARATE

unsigned char flash_read_byte(int32 addr, unsigned char* data) {
    unsigned char ec;

    ec = flash_move_buffer(addr);
    if (ec != flash_GOODEC) {
        return ec;
    }

    *data = g_flash_buffer[addr % FLASH_MAX_BLOCK_SIZE];

    return flash_GOODEC;
}
#SEPARATE

unsigned char flash_write_byte(int32 addr, unsigned char data) {
    unsigned char ec;
    ec = flash_move_buffer(addr);
    if (ec != flash_GOODEC)
        return ec;

    g_flash_buffer[addr % FLASH_MAX_BLOCK_SIZE] = data;

    g_flashBufferChanged = TRUE;

    return flash_GOODEC;
}
#SEPARATE

unsigned char flash_read_data(int32 address, int16 size, unsigned char * ptr) {
    unsigned char r1;
    int32 new_block;
    int16 i; // counter for loops

    new_block = address / FLASH_MAX_BLOCK_SIZE;
    if (new_block == g_flashBufferAddress) {
        r1 = flash_reflash(new_block);
        if (r1 != flash_GOODEC)
            return r1;
    }
    for (i = 0; i < size; i++) {
        r1 = flash_read_byte(address++, ptr++);
        if (r1 != flash_GOODEC)
            return r1;
    }

    return flash_GOODEC;
}
#SEPARATE

unsigned char flash_write_data(int32 address, int16 size, unsigned char * ptr) {
    unsigned char ec;
    int32 new_block;
    int16 i; // counter for loops


    new_block = address / FLASH_MAX_BLOCK_SIZE;
    if (new_block == g_flashBufferAddress)flash_reflash(new_block);
    //  if(g_mmcsdBufferAddress==address)mmcsd_reflash(address);
    for (i = 0; i < size; i++) {

        ec = flash_write_byte(address++, *ptr++);
        if (ec != flash_GOODEC)
            return ec;
    }
    flash_flush_buffer();
    return flash_GOODEC;
}

#SEPARATE
void InitEEpromExtBootLoader(void) {

    output_high(EEPROM_CS_IO);
    output_high(EEPROM_CS_IO2);
    output_low(EEPROM_SCK); // Set SCK pin as an output
    input(EEPROM_SDI); // Make sure SDI pin is an input
    output_low(EEPROM_SDO); // Set SDO pin as an output

    ClearSPIDoneFlag();
    EEPROM_SPICON1 = PROPER_SPICON1; // See PROPER_SPICON1 definition above

    CKE = 1; // Transmit data on rising edge of clock
    SMP = 0; // Input sampled at middle of data output time
}

void ReadFlashEEpromBootLoader(int32 startaddr, int16 num_bytes, unsigned char *eeprom_ext_array) {
    volatile BYTE Dummy;

    if (startaddr > EEPROM_LENGTH) {
        startaddr -= (EEPROM_LENGTH);
        startaddr--;
        memoria = 1;
    } else memoria = 0;

    ClearSPIDoneFlag();
    if (!memoria)
        output_low(EEPROM_CS_IO);
    else
        output_low(EEPROM_CS_IO2);

    // Send READ opcode
    EEPROM_SSPBUF = OPCODE_READ;
    WaitForDataByte();
    Dummy = EEPROM_SSPBUF;

    EEPROM_SSPBUF = make8(startaddr, 1);
    WaitForDataByte();
    Dummy = EEPROM_SSPBUF;

    EEPROM_SSPBUF = make8(startaddr, 0);
    WaitForDataByte();
    Dummy = EEPROM_SSPBUF;

    while (num_bytes--) {
        EEPROM_SSPBUF = 0;
        WaitForDataByte();
        Dummy = EEPROM_SSPBUF;
        *eeprom_ext_array++ = Dummy;
    }
    if (!memoria)
        output_high(EEPROM_CS_IO);
    else
        output_high(EEPROM_CS_IO2);
}



#SEPARATE
void real_load_program(void) {
    int32 addr = 0;
    int32 limit_program=LOADER_ADDR-(FLASH_MAX_BLOCK_SIZE*2);
    InitEEpromExtBootLoader();
    for (;;) {
        if (addr < limit_program) {
            output_bit(PIN_E2, !input_state(PIN_E2));
            ReadFlashEEpromBootLoader(addr,EEPROM_PAGE_SIZE,g_eeprom_ext_buffer);
            flash_write_data(addr,EEPROM_PAGE_SIZE,g_eeprom_ext_buffer);
            addr += EEPROM_PAGE_SIZE;
        } else {
            addr = 0;
            reset_cpu();
        }
    }
}
#ORG default
#ORG LOADER_ADDR, LOADER_ADDR+9
void load_program(void) {
    real_load_program();
}







Código: Selecionar todos

/*
 * File:   eeprom_ext.h
 * Author: Administrator
 *
 * Created on 18 de Outubro de 2013, 17:11
 */

#ifndef EEPROM_EXT_H
#define   EEPROM_EXT_H

#ifdef   __cplusplus
extern "C" {
#endif
#define EEPROM_CS_IO   PIN_D0
#define EEPROM_CS_IO2   PIN_G0

#define EEPROM_SCK      PIN_C3
#define EEPROM_SDI      PIN_C4
#define EEPROM_SDO      PIN_C5

#define EEPROM_SSPBUF      SSP1BUF
#define EEPROM_SPICON1      SSP1CON1
#define EEPROM_SPICON2      SSP1CON2
#define EEPROM_SPISTAT      SSP1STAT
#define EEPROM_SPI_IF      SSPIF
#define OPCODE_READ    0x03    // Read data from memory array beginning at selected address
#define OPCODE_WRITE   0x02    // Write data to memory array beginning at selected address
#define OPCODE_WRDI    0x04    // Reset the write enable latch (disable write operations)
#define OPCODE_WREN    0x06    // Set the write enable latch (enable write operations)
#define OPCODE_RDSR    0x05    // Read Status register
#define OPCODE_WRSR    0x01    // Write Status register

#define EEPROM_MAX_SPI_FREQ     10000000    // Hz

#define EEPROM_LENGTH 0xFFFF

#define PROPER_SPICON1  (0x22)      /* SSPEN bit is set, SPI in master mode, FOSC/64, IDLE state is low level */



#define ClearSPIDoneFlag()  {EEPROM_SPI_IF = 0;}
#define WaitForDataByte()   {while(!EEPROM_SPI_IF); EEPROM_SPI_IF = 0;}
#define SPI_ON_BIT          SSPEN



#define EEPROM_PAGE_SIZE            128

    char g_eeprom_ext_buffer[EEPROM_PAGE_SIZE] = "\0";
    int1 g_eeprom_extBufferChanged = FALSE;
    int1 eeprom_ext_GOODEC;
    int1 memoria = 0;
    int32 g_eeprom_extBufferAddress = 0xFFFF;
#SEPARATE

    void InitEEpromExt(void) {

        output_high(EEPROM_CS_IO);
        output_high(EEPROM_CS_IO2);
        output_low(EEPROM_SCK); // Set SCK pin as an output
        input(EEPROM_SDI); // Make sure SDI pin is an input
        output_low(EEPROM_SDO); // Set SDO pin as an output

        ClearSPIDoneFlag();
        EEPROM_SPICON1 = PROPER_SPICON1; // See PROPER_SPICON1 definition above

        CKE = 1; // Transmit data on rising edge of clock
        SMP = 0; // Input sampled at middle of data output time
    }
#SEPARATE

    BOOL XEEIsBusy(void) {
        BYTE result;

        // Save SPI state
        //SPICON1Save = EEPROM_SPICON1;
        //vSPIONSave = SPI_ON_BIT;

        // Configure SPI
        //SPI_ON_BIT = 0;
        //EEPROM_SPICON1 = PROPER_SPICON1;
        //SPI_ON_BIT = 1;
        if (!memoria)
            output_low(EEPROM_CS_IO);
        else
            output_low(EEPROM_CS_IO2);
        // Send RDSR - Read Status Register opcode
        EEPROM_SSPBUF = OPCODE_RDSR;
        WaitForDataByte();
        result = EEPROM_SSPBUF;

        // Get register contents
        EEPROM_SSPBUF = 0;
        WaitForDataByte();
        result = EEPROM_SSPBUF;
        if (!memoria)
            output_high(EEPROM_CS_IO);
        else
            output_high(EEPROM_CS_IO2);
        // Restore SPI State
        //SPI_ON_BIT = 0;
        //EEPROM_SPICON1 = SPICON1Save;
        //SPI_ON_BIT = vSPIONSave;

        return bit_test(result, 0);
    }

#SEPARATE

    void ReadFlashEEprom(int32 startaddr, int16 num_bytes, unsigned char *eeprom_ext_array) {
        volatile BYTE Dummy;



        if (startaddr > EEPROM_LENGTH) {
            startaddr -= (EEPROM_LENGTH);
            startaddr--;
            memoria = 1;
        } else memoria = 0;


        // Save SPI state (clock speed)
        //SPICON1Save = EEPROM_SPICON1;
        //vSPIONSave = SPI_ON_BIT;

        // Configure SPI
        //SPI_ON_BIT = 0;
        //EEPROM_SPICON1 = PROPER_SPICON1;
        //SPI_ON_BIT = 1;


        ClearSPIDoneFlag();
        if (!memoria)
            output_low(EEPROM_CS_IO);
        else
            output_low(EEPROM_CS_IO2);

        // Send READ opcode
        EEPROM_SSPBUF = OPCODE_READ;
        WaitForDataByte();
        Dummy = EEPROM_SSPBUF;

        //  EEPROM_SSPBUF = ((DWORD*)&address)->v[1];
        EEPROM_SSPBUF = make8(startaddr, 1);
        WaitForDataByte();
        Dummy = EEPROM_SSPBUF;

        //   EEPROM_SSPBUF = ((DWORD*)&address)->v[0];
        EEPROM_SSPBUF = make8(startaddr, 0);
        WaitForDataByte();
        Dummy = EEPROM_SSPBUF;

        while (num_bytes--) {
            EEPROM_SSPBUF = 0;
            WaitForDataByte();
            Dummy = EEPROM_SSPBUF;
            *eeprom_ext_array++ = Dummy;
        };
        if (!memoria)
            output_high(EEPROM_CS_IO);
        else
            output_high(EEPROM_CS_IO2);
        // Restore SPI state
        //SPI_ON_BIT = 0;
        //EEPROM_SPICON1 = SPICON1Save;
        //SPI_ON_BIT = vSPIONSave;

    }


#SEPARATE

    void WriteBlockEEprom(int32 startaddr, int16 num_blocks, unsigned char *eeprom_ext_array) {
        BYTE i;
        volatile BYTE vDummy;

        if (startaddr > EEPROM_LENGTH) {
            startaddr -= (EEPROM_LENGTH);
            startaddr--;
            memoria = 1;
        } else memoria = 0;


        // Save SPI state
        //SPICON1Save = EEPROM_SPICON1;
        //vSPIONSave = SPI_ON_BIT;

        // Configure SPI
        //SPI_ON_BIT = 0;
        //EEPROM_SPICON1 = PROPER_SPICON1;
        //SPI_ON_BIT = 1;

        // Set the Write Enable latch

        ClearSPIDoneFlag();
        if (!memoria)
            output_low(EEPROM_CS_IO); // = 0;
        else output_low(EEPROM_CS_IO2);


        EEPROM_SSPBUF = OPCODE_WREN;
        WaitForDataByte();
        vDummy = EEPROM_SSPBUF;

        if (!memoria)
            output_high(EEPROM_CS_IO); // = 0;
        else
            output_high(EEPROM_CS_IO2);


        if (!memoria)
            output_low(EEPROM_CS_IO); // = 0;
        else
            output_low(EEPROM_CS_IO2);

        EEPROM_SSPBUF = OPCODE_WRITE;
        WaitForDataByte();
        vDummy = EEPROM_SSPBUF;

        EEPROM_SSPBUF = make8(startaddr, 1);
        WaitForDataByte();
        vDummy = EEPROM_SSPBUF;

        EEPROM_SSPBUF = make8(startaddr, 0);
        WaitForDataByte();
        vDummy = EEPROM_SSPBUF;


        for (i = 0; i < EEPROM_PAGE_SIZE; i++) {
            // Send the byte to write
            EEPROM_SSPBUF = eeprom_ext_array[i];
            WaitForDataByte();
            vDummy = EEPROM_SSPBUF;
        }

        // Begin the write
        if (!memoria)
            output_high(EEPROM_CS_IO); // = 0;
        else
            output_high(EEPROM_CS_IO2);
        // Restore SPI State
        //SPI_ON_BIT = 0;
        //EEPROM_SPICON1 = SPICON1Save;
        //SPI_ON_BIT = vSPIONSave;


        // Wait for write to complete
        while (XEEIsBusy());


    }

    //unsigned char eeprom_ext_read_block(int32 address, int16 size, unsigned char * ptr);
#SEPARATE

    unsigned char eeprom_ext_read_block(int32 address, int16 size, unsigned char * ptr) {
        ReadFlashEEprom((address * EEPROM_PAGE_SIZE), EEPROM_PAGE_SIZE, ptr);
        return eeprom_ext_GOODEC;
    }

#SEPARATE

    unsigned char eeprom_ext_reflash(int32 address) {
        return (eeprom_ext_read_block(address, EEPROM_PAGE_SIZE, g_eeprom_ext_buffer));
    }

#SEPARATE

    unsigned char eeprom_ext_write_block(int32 address, int16 size, unsigned char * ptr) {
        WriteBlockEEprom((address * EEPROM_PAGE_SIZE), 1, ptr);
        return eeprom_ext_GOODEC;
    }
#SEPARATE

    unsigned char eeprom_ext_load_buffer(void) {
        g_eeprom_extBufferChanged = FALSE;
        return (eeprom_ext_read_block(g_eeprom_extBufferAddress, EEPROM_PAGE_SIZE, g_eeprom_ext_buffer));
    }
#SEPARATE

    unsigned char eeprom_ext_flush_buffer(void) {
        if (g_eeprom_extBufferChanged) {
            g_eeprom_extBufferChanged = FALSE;
            return (eeprom_ext_write_block(g_eeprom_extBufferAddress, EEPROM_PAGE_SIZE, g_eeprom_ext_buffer));
        }
        return (0); //ok
    }
#SEPARATE

    unsigned char eeprom_ext_move_buffer(int32 new_addr) {
        unsigned char ec;
        int32 new_block;

        ec = eeprom_ext_GOODEC;

        new_block = new_addr / EEPROM_PAGE_SIZE;

        //if(cur_block != new_block)
        if (g_eeprom_extBufferAddress != new_block) {
            // dump the old buffer
            if (g_eeprom_extBufferChanged) {

                ec = eeprom_ext_flush_buffer();
                if (ec != eeprom_ext_GOODEC)
                    return ec;
                g_eeprom_extBufferChanged = FALSE;
            }
            // figure out the best place for a block
            g_eeprom_extBufferAddress = new_block;
            // load up a new buffer
            ec = eeprom_ext_load_buffer();
        }

        return ec;
    }
#SEPARATE

    unsigned char eeprom_ext_read_byte(int32 addr, unsigned char* data) {
        unsigned char ec;

        ec = eeprom_ext_move_buffer(addr);
        if (ec != eeprom_ext_GOODEC) {
            return ec;
        }

        *data = g_eeprom_ext_buffer[addr % EEPROM_PAGE_SIZE];

        return eeprom_ext_GOODEC;
    }
#SEPARATE

    unsigned char eeprom_ext_write_byte(int32 addr, unsigned char data) {
        unsigned char ec;
        ec = eeprom_ext_move_buffer(addr);
        if (ec != eeprom_ext_GOODEC)
            return ec;

        g_eeprom_ext_buffer[addr % EEPROM_PAGE_SIZE] = data;

        g_eeprom_extBufferChanged = TRUE;

        return eeprom_ext_GOODEC;
    }
#SEPARATE

    unsigned char eeprom_ext_read_data(int32 address, int16 size, unsigned char * ptr) {
        unsigned char r1;
        int32 new_block;
        int16 i; // counter for loops

        new_block = address / EEPROM_PAGE_SIZE;
        if (new_block == g_eeprom_extBufferAddress) {
            r1 = eeprom_ext_reflash(new_block);
            if (r1 != eeprom_ext_GOODEC)
                return r1;
        }
        for (i = 0; i < size; i++) {
            r1 = eeprom_ext_read_byte(address++, ptr++);
            if (r1 != eeprom_ext_GOODEC)
                return r1;
        }

        return eeprom_ext_GOODEC;
    }
#SEPARATE

    unsigned char eeprom_ext_write_data(int32 address, int16 size, unsigned char * ptr) {
        unsigned char ec;
        int32 new_block;
        int16 i; // counter for loops


        new_block = address / EEPROM_PAGE_SIZE;
        if (new_block == g_eeprom_extBufferAddress)eeprom_ext_reflash(new_block);
        //  if(g_mmcsdBufferAddress==address)mmcsd_reeeprom_ext(address);
        for (i = 0; i < size; i++) {

            ec = eeprom_ext_write_byte(address++, *ptr++);
            if (ec != eeprom_ext_GOODEC)
                return ec;
        }
        eeprom_ext_flush_buffer();
        return eeprom_ext_GOODEC;
    }

    void eeprom_apagar(void) {
        int32 count=0;
        for (count = 0; count < 0x1FFFE; count++) {
            eeprom_ext_write_byte(count, 0xFF);
            output_bit(PIN_E2, !input_state(PIN_E2));
            restart_wdt();
        }
    }


#ifdef   __cplusplus
}
#endif

#endif   /* EEPROM_EXT_H */



Código: Selecionar todos

//:1000000023EF48F0000C000C046ED8CF05F0E0CFD1
//: -> Inicio
//10 -> 16 byte tamanho
//0000 -> 0x0000 endere‡o parte baixa
//00 ->  00 line type =0 endereco parte alta se igual =4
//D1 ->  cheksun
//23EF48F0000C000C046ED8CF05F0E0CF-> informa‡„o gravada.

void Modem02FtpTratarArquivoRecebido(void) {
    char* dptr02 = NULL;
    char c = 0;
    static char buffidx = 0;
    static char buffer_aux[50] = "\0";
    int8 data[32];
    int1 do_ACKLOD;
    int8 checksum, line_type;

    int32 addr;
    int32 next_addr;
    int8 dataidx, i, count;

    dptr02 = find_carac2(&serialModem02, '\"', 3);

    if (dptr02 != NULL) {
        ModemWatchDogGprsClear();
        Modem01WatchdogClear();
        Modem02WatchdogClear();
        for (;;) {
            c = *dptr02++;
            if (c == '\0' || c == '\"') {
                break;
            } else
                if (c != 0x0D && c != 0x0A) {
                buffer_aux[buffidx++] = c;
                buffer_aux[buffidx] = '\0';
            } else
                if (buffer_aux[0] == ':') {
                buffidx++;
                count = atoi_b16(&buffer_aux[1]);
                l_addr = make16(atoi_b16(&buffer_aux[3]), atoi_b16(&buffer_aux[5]));
                line_type = atoi_b16(&buffer_aux[7]);
                addr = make32(h_addr, l_addr);

                checksum = 0; // Sum the bytes to find the check sum value
                for (i = 1; i < (buffidx - 3); i += 2)
                    checksum += atoi_b16(&buffer_aux[i]);
                checksum = 0xFF - checksum + 1;
                if (addr >= 0 && addr <= 80) {
                    c = 0;
                }
                if (checksum != atoi_b16(&buffer_aux[buffidx - 3])) {
                    do_ACKLOD = FALSE; // ERRO NO SOMA DE CHAGAEM ABORA DOWNALOD
                    reset_cpu();
                } else {
                    if (line_type == 1) {
                        disable_interrupts(GLOBAL);
                        load_program();
                        break;
                    } else
                        if (line_type == 0) {
                        for (i = 9, dataidx = 0; i < buffidx - 3; i += 2) {
                            data[dataidx++] = atoi_b16(&buffer_aux[i]);
                        }
                        next_addr = addr + 1;
                        eeprom_ext_write_data(addr, count, data);

                    } else
                        if (line_type == 4) {
                        h_addr = make16(atoi_b16(&buffer_aux[9]), atoi_b16(&buffer_aux[11]));
                    }
                }
                buffidx = 0;
                buffer_aux[buffidx] = '\0';
            }
        }
    }
}