prog.cpp

#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>

void XLNX_CAN_sendMessage( int32_t , uint16_t*  , int32_t ) {
    //çàãëóøêà
    return;
}

// Ãëîáàëüíûå ïåðåìåííûå äëÿ õðàíåíèÿ ñîñòîÿíèÿ ïðè¸ìà ïðîøèâêè
// (ðàçìåùàþòñÿ â Filter1_RegsFile, êîòîðûé â ÎÇÓ)
//#pragma DATA_SECTION(g_progState, ".Filter1_RegsFile");
static struct {
    uint32_t currentAddr;       // Òåêóùèé àäðåñ äëÿ çàïèñè
    uint16_t blockSizeWords;    // Ðàçìåð òåêóùåãî áëîêà (â ñëîâàõ)
    uint16_t wordCount;         // Ñ÷¸ò÷èê ïðèíÿòûõ ñëîâ â òåêóùåì áëîêå
    uint8_t buffer[256];        // Áóôåð äëÿ íàêîïëåíèÿ äàííûõ áëîêà
    uint8_t bufferIndex;        // Èíäåêñ â áóôåðå
    uint8_t state;              // 0=îæèäàíèå çàãîëîâêà, 1=ïðè¸ì äàííûõ
    uint8_t sectorBuffer[0x4000]; // Áóôåð äëÿ öåëîãî ñåêòîðà (16KB)
    uint32_t sectorAddr;        // Àäðåñ òåêóùåãî ñåêòîðà
    uint16_t sectorOffset;      // Ñìåùåíèå â òåêóùåì ñåêòîðå
    uint16_t remainingBytes;    // Îñòàòîê áàéò â òåêóùåì áëîêå
    uint16_t skipBytes;         // Êîëè÷åñòâî áàéò äëÿ ïðîïóñêà (çàãîëîâîê)
    uint32_t entriPoint;        //òî÷êà âõîäà â ïðîãðàììó
} g_progState = { 0 };

// Êîíñòàíòû äëÿ ñîñòîÿíèÿ
#define STATE_WAIT_BLOCK_HEADER  0
#define STATE_RECEIVE_DATA       1

// Àäðåñà ñåêòîðîâ ôëåø-ïàìÿòè
static const uint32_t sectorAddresses[] = {
    0x080000, 0x082000, 0x084000, 0x086000,
    0x088000, 0x090000, 0x098000, 0x0A0000,
    0x0A8000, 0x0B0000, 0x0B8000, 0x0BA000,
    0x0BC000, 0x0BE000, 0x0C0000
};

// Ôóíêöèÿ ïîëó÷åíèÿ ñëåäóþùåãî ñëîâà (2 áàéòà) èç CAN-áóôåðà
static uint16_t getNextWord(uint8_t* rx_buff, uint16_t* offset)
{
    uint16_t word;
    word = rx_buff[*offset] | (rx_buff[*offset + 1] << 8);
    //word = (rx_buff[*offset]<<8) | rx_buff[*offset + 1];
    *offset += 2;
    return word;
}

// Ôóíêöèÿ çàïèñè íàêîïëåííûõ äàííûõ â òåêóùèé ñåêòîð
static uint8_t flushSector(void)
{
    uint8_t sectorNum;

    // Îïðåäåëÿåì íîìåð ñåêòîðà ïî àäðåñó
    for (sectorNum = 0; sectorNum < 15; sectorNum++) {
        if (g_progState.sectorAddr >= sectorAddresses[sectorNum]) {
            break;
        }
    }

    if (sectorNum >= 15) {
        return 1; // Îøèáêà: íåâåðíûé àäðåñ ñåêòîðà
    }

    // Çäåñü âûçûâàåòñÿ Flash API äëÿ ïðîãðàììèðîâàíèÿ ñåêòîðà
    // ...
    printf("Write addr sector 0x%08X", g_progState.sectorAddr);
    for (int i = 0; i < 4; ++i)
        printf(" 0x%08X ", g_progState.sectorBuffer[i]);
    printf("\n");

    // Îòïðàâêà ñîîáùåíèÿ î ãîòîâíîñòè ïðèíÿòü ñëåäóþùèé ñåêòîð
    uint16_t msgData[2];
    msgData[0] = 0x0001;  // Êîä ãîòîâíîñòè
    msgData[1] = sectorNum;
    XLNX_CAN_sendMessage(0x01, msgData, 2);

    // Ñáðîñ ñîñòîÿíèÿ äëÿ ñëåäóþùåãî ñåêòîðà
    g_progState.sectorOffset = 0;
    g_progState.currentAddr = g_progState.sectorAddr + 0x4000;

    return 0;
}

// Èíèöèàëèçàöèÿ ïðîöåññà çàãðóçêè (âûçûâàåòñÿ îäèí ðàç ïåðåä íà÷àëîì)
void initFirmwareDownload(void)
{
    g_progState.state = STATE_WAIT_BLOCK_HEADER;
    g_progState.wordCount = 0;
    g_progState.skipBytes = 0;
    g_progState.remainingBytes = 0;
    g_progState.bufferIndex = 0;
    g_progState.sectorOffset = 0;
}

// Îñíîâíàÿ ôóíêöèÿ îáðàáîòêè ïðèíÿòûõ äàííûõ
// Âûçûâàåòñÿ êàæäûé ðàç ïðè ïðèõîäå î÷åðåäíîãî CAN-ñîîáùåíèÿ (8 áàéò)
void processCANFirmwareData(uint8_t* rx_buff_from_can, uint16_t length)
{
    static uint32_t offset_global = 0;
    uint16_t offset = 0;
    uint16_t bytesToCopy;

    if (length == 0) return;

    while (offset < length) {

        // ========== ÎÁÐÀÁÎÒÊÀ ÇÀÃÎËÎÂÊÀ (ïåðâîå ñîîáùåíèå) ==========
        if (g_progState.state == STATE_WAIT_BLOCK_HEADER && g_progState.wordCount == 0) {

            // Ïðîïóñêàåì êëþ÷ (0xAA 0x08) è çàðåçåðâèðîâàííûå áàéòû (âñåãî 18 áàéò) --------
            if (g_progState.skipBytes == 0 && offset_global == 0) {
                g_progState.skipBytes = 18;
            }

            // Ïðîïóñêàåì áàéòû çàãîëîâêà
            while (offset < length && g_progState.skipBytes > 0) {
                offset++;
                offset_global++;
                g_progState.skipBytes--;
            }

            if (g_progState.skipBytes > 0) continue; // Æä¸ì ñëåäóþùèé ïàêåò
            //-----------------------------------------------------------------------------------

            //  òî÷ê âõîäà (4 áàéòà)
            if (offset + 4 <= length && offset_global == 18) {
                g_progState.entriPoint = getNextWord(rx_buff_from_can, &offset);
                g_progState.entriPoint |= (getNextWord(rx_buff_from_can, &offset) << 16);
                offset += 4;
                offset_global += 4;
            }
            else {
                // Òî÷êà âõîäà ïðèøëà íå ïîëíîñòüþ
                // Äëÿ óïðîùåíèÿ ñ÷èòàåì, ÷òî CAN-ñîîáùåíèå âñåãäà ñîäåðæèò öåëûå ïîëÿ
                return;
            }

            //----------------------------------------------------------------------------------

            // ×òåíèå ðàçìåðà ïåðâîãî áëîêà
            if (offset + 2 <= length && offset_global == 22) {
                g_progState.blockSizeWords = getNextWord(rx_buff_from_can, &offset);
            }
            else {
                return;
            }

            // ×òåíèå àäðåñà íàçíà÷åíèÿ
            if (offset + 4 <= length && offset_global == 24) {
                g_progState.currentAddr = getNextWord(rx_buff_from_can, &offset);
                g_progState.currentAddr |= (getNextWord(rx_buff_from_can, &offset) << 16);
            }
            //else {
            //    return;
            //}

            // Èíèöèàëèçàöèÿ ñîñòîÿíèÿ äëÿ ïðè¸ìà äàííûõ
            g_progState.sectorAddr = g_progState.currentAddr & 0xFFFFC000;
            g_progState.sectorOffset = g_progState.currentAddr & 0x3FFF;
            g_progState.bufferIndex = 0;
            g_progState.remainingBytes = g_progState.blockSizeWords * 2;
            g_progState.state = STATE_RECEIVE_DATA;

            continue;
        }

        // ========== ÏÐÈ¨Ì ÄÀÍÍÛÕ ==========
        if (g_progState.state == STATE_RECEIVE_DATA) {

            // Îïðåäåëÿåì ñêîëüêî áàéò ìîæíî ñêîïèðîâàòü
            bytesToCopy = (length - offset);
            if (bytesToCopy > g_progState.remainingBytes) {
                bytesToCopy = g_progState.remainingBytes;
            }

            // Êîïèðóåì äàííûå â áóôåð ñåêòîðà
            for (uint16_t i = 0; i < bytesToCopy; i++) {
                g_progState.sectorBuffer[g_progState.sectorOffset + g_progState.bufferIndex] = rx_buff_from_can[offset + i];
                g_progState.bufferIndex++;
            }

            offset += bytesToCopy;
            g_progState.remainingBytes -= bytesToCopy;

            // Åñëè çàïîëíèëè òåêóùèé ñåêòîð
            if (g_progState.sectorOffset + g_progState.bufferIndex >= 0x4000) {
                flushSector();
            }

            // Åñëè áëîê ïîëíîñòüþ ïðèíÿò
            if (g_progState.remainingBytes == 0) {

                // ×òåíèå ñëåäóþùåãî áëîêà (ðàçìåð è àäðåñ) èç îñòàâøèõñÿ äàííûõ
                if (offset + 2 <= length) {
                    g_progState.blockSizeWords = getNextWord(rx_buff_from_can, &offset);
                }
                else {
                    // Ðàçìåð ñëåäóþùåãî áëîêà ïðèä¸ò â ñëåäóþùåì CAN-ñîîáùåíèè
                    g_progState.state = STATE_WAIT_BLOCK_HEADER;
                    g_progState.wordCount = 1; // Ìàðêåð, ÷òî çàãîëîâîê óæå íà÷àëè îáðàáàòûâàòü
                    continue;
                }

                // Ïðîâåðêà íà êîíåö çàãðóçêè (ðàçìåð áëîêà = 0)
                if (g_progState.blockSizeWords == 0) {
                    // Çàâåðøåíèå çàãðóçêè
                    uint16_t msgData[2];
                    msgData[0] = 0x0002;  // Êîä çàâåðøåíèÿ
                    msgData[1] = 0x0000;
                    XLNX_CAN_sendMessage(0x01, msgData, 2);
                    g_progState.state = STATE_WAIT_BLOCK_HEADER;
                    g_progState.wordCount = 0;
                    g_progState.skipBytes = 0;
                    return;
                }

                // ×òåíèå ñëåäóþùåãî àäðåñà
                if (offset + 4 <= length) {
                    g_progState.currentAddr = getNextWord(rx_buff_from_can, &offset);
                    g_progState.currentAddr |= (getNextWord(rx_buff_from_can, &offset) << 16);
                }
                else {
                    // Àäðåñ ïðèä¸ò â ñëåäóþùåì ñîîáùåíèè
                    g_progState.state = STATE_WAIT_BLOCK_HEADER;
                    g_progState.wordCount = 2; // Ìàðêåð ñîñòîÿíèÿ
                    continue;
                }

                // Îïðåäåëÿåì íîâûé ñåêòîð
                if ((g_progState.currentAddr & 0xFFFFC000) != g_progState.sectorAddr) {
                    flushSector();
                    g_progState.sectorAddr = g_progState.currentAddr & 0xFFFFC000;
                    g_progState.sectorOffset = g_progState.currentAddr & 0x3FFF;
                }

                // Èíèöèàëèçàöèÿ äëÿ ñëåäóþùåãî áëîêà
                g_progState.bufferIndex = 0;
                g_progState.remainingBytes = g_progState.blockSizeWords * 2;
                g_progState.state = STATE_RECEIVE_DATA;
            }
        }

        // ========== ÄÎÎÁÐÀÁÎÒÊÀ ÍÀ×ÀËÀ ÑËÅÄÓÞÙÅÃÎ ÁËÎÊÀ ==========
        // Åñëè íàõîäèìñÿ â ñîñòîÿíèè WAIT ñ ìàðêåðîì, ÷òî ðàçìåð óæå ïðî÷èòàí
        if (g_progState.state == STATE_WAIT_BLOCK_HEADER && g_progState.wordCount == 2) {
            if (offset + 4 <= length) {
                g_progState.currentAddr = getNextWord(rx_buff_from_can, &offset);
                g_progState.currentAddr |= (getNextWord(rx_buff_from_can, &offset) << 16);

                // Îïðåäåëÿåì íîâûé ñåêòîð
                if ((g_progState.currentAddr & 0xFFFFC000) != g_progState.sectorAddr) {
                    flushSector();
                    g_progState.sectorAddr = g_progState.currentAddr & 0xFFFFC000;
                    g_progState.sectorOffset = g_progState.currentAddr & 0x3FFF;
                }

                g_progState.bufferIndex = 0;
                g_progState.remainingBytes = g_progState.blockSizeWords * 2;
                g_progState.state = STATE_RECEIVE_DATA;
                g_progState.wordCount = 0;
            }
        }
    }
}


void initFirmwareDownload_mod(void)
{
    g_progState.state = STATE_WAIT_BLOCK_HEADER;
    g_progState.wordCount = 0;
    g_progState.skipBytes = 0;
    g_progState.remainingBytes = 0;
    g_progState.bufferIndex = 0;
    g_progState.sectorOffset = 0;

    // Ñáðîñ ñòàòè÷åñêèõ ïåðåìåííûõ â ôóíêöèè processCANFirmwareData
    // (ëó÷øå âûíåñòè èõ â ãëîáàëüíîå ñîñòîÿíèå)
}

// Îñíîâíàÿ ôóíêöèÿ îáðàáîòêè ïðèíÿòûõ äàííûõ
void processCANFirmwareData_mod(uint8_t* rx_buff_from_can, uint16_t length)
{
    static uint8_t headerSkipRemaining = 18;  // Îñòàëîñü ïðîïóñòèòü áàéò çàãîëîâêà
    static uint8_t readingEntryPoint = 1;     // Ôëàã ÷òåíèÿ òî÷êè âõîäà
    static uint8_t readingBlockSize = 0;      // Ôëàã ÷òåíèÿ ðàçìåðà áëîêà
    static uint8_t readingAddress = 0;        // Ôëàã ÷òåíèÿ àäðåñà

    uint16_t offset = 0;
    uint16_t bytesToCopy;

    if (length == 0) return;

    while (offset < length) {

        // ========== ÏÐÎÏÓÑÊ ÇÀÃÎËÎÂÊÀ (òîëüêî â ñàìîì íà÷àëå) ==========
        if (headerSkipRemaining > 0) {
            uint8_t skipNow = (headerSkipRemaining < (length - offset)) ?
                headerSkipRemaining : (length - offset);
            offset += skipNow;
            headerSkipRemaining -= skipNow;
            if (headerSkipRemaining > 0) return; // Æäåì ñëåäóþùèé ïàêåò
            continue;
        }

        // ========== ×ÒÅÍÈÅ ÒÎ×ÊÈ ÂÕÎÄÀ (4 áàéòà) ==========
        if (readingEntryPoint) {
            if (offset + 4 <= length) {
                g_progState.entriPoint = getNextWord(rx_buff_from_can, &offset)<<16;
                g_progState.entriPoint |= getNextWord(rx_buff_from_can, &offset);
                readingEntryPoint = 0;
                readingBlockSize = 1;
                printf("Entry point: 0x%08X\n", g_progState.entriPoint);
            }
            else {
                return; // Æäåì ñëåäóþùèå ïàêåòû
            }
        }

        // ========== ×ÒÅÍÈÅ ÐÀÇÌÅÐÀ ÁËÎÊÀ (2 áàéòà) ==========
        if (readingBlockSize) {
            if (offset + 2 <= length) {
                g_progState.blockSizeWords = getNextWord(rx_buff_from_can, &offset);
                readingBlockSize = 0;

                // Ïðîâåðêà íà êîíåö çàãðóçêè
                if (g_progState.blockSizeWords == 0) {
                    // Çàâåðøåíèå çàãðóçêè
                    uint16_t msgData[2];
                    msgData[0] = 0x0002;
                    msgData[1] = 0x0000;
                    XLNX_CAN_sendMessage(0x01, msgData, 2);

                    // Ñáðîñ ñîñòîÿíèÿ
                    headerSkipRemaining = 18;
                    readingEntryPoint = 1;
                    g_progState.state = STATE_WAIT_BLOCK_HEADER;
                    return;
                }

                readingAddress = 1;
                printf("Block size: %d words (%d bytes)\n",
                    g_progState.blockSizeWords,
                    g_progState.blockSizeWords * 2);
            }
            else {
                return;
            }
        }

        // ========== ×ÒÅÍÈÅ ÀÄÐÅÑÀ (4 áàéòà) ==========
        if (readingAddress) {
            if (offset + 4 <= length) {
                g_progState.currentAddr = getNextWord(rx_buff_from_can, &offset) << 16;
                g_progState.currentAddr |=  getNextWord(rx_buff_from_can, &offset) ;
                readingAddress = 0;

                // Èíèöèàëèçàöèÿ ñîñòîÿíèÿ äëÿ ïðèåìà äàííûõ
                g_progState.sectorAddr = g_progState.currentAddr & 0xFFFFC000;
                g_progState.sectorOffset = g_progState.currentAddr & 0x3FFF;
                g_progState.bufferIndex = 0;
                g_progState.remainingBytes = g_progState.blockSizeWords * 2;
                g_progState.state = STATE_RECEIVE_DATA;

                printf("Address: 0x%08X, Sector: 0x%08X, Offset: 0x%04X\n",
                    g_progState.currentAddr,
                    g_progState.sectorAddr,
                    g_progState.sectorOffset);
            }
            else {
                return;
            }
        }

        // ========== ÏÐÈÅÌ ÄÀÍÍÛÕ ==========
        if (g_progState.state == STATE_RECEIVE_DATA && g_progState.remainingBytes > 0) {

            // Îïðåäåëÿåì ñêîëüêî áàéò ìîæíî ñêîïèðîâàòü
            bytesToCopy = (length - offset);
            if (bytesToCopy > g_progState.remainingBytes) {
                bytesToCopy = g_progState.remainingBytes;
            }

            // Êîïèðóåì äàííûå â áóôåð ñåêòîðà
            for (uint16_t i = 0; i < bytesToCopy; i++) {
                uint32_t bufferPos = g_progState.sectorOffset + g_progState.bufferIndex;
                if (bufferPos < 0x4000) {
                    g_progState.sectorBuffer[bufferPos] = rx_buff_from_can[offset + i];
                }
                g_progState.bufferIndex++;
            }

            offset += bytesToCopy;
            g_progState.remainingBytes -= bytesToCopy;

            // Åñëè çàïîëíèëè òåêóùèé ñåêòîð
            if (g_progState.sectorOffset + g_progState.bufferIndex >= 0x4000) {
                flushSector();
            }

            // Åñëè áëîê ïîëíîñòüþ ïðèíÿò
            if (g_progState.remainingBytes == 0) {
                
                flushSector();

                // Ïåðåõîä ê ÷òåíèþ ñëåäóþùåãî áëîêà
                g_progState.state = STATE_WAIT_BLOCK_HEADER;
                readingBlockSize = 1;  // Ñëåäóþùèé áëîê íà÷èíàåòñÿ ñ ðàçìåðà
                g_progState.bufferIndex = 0;

                printf("Block completed. Total bytes in sector: %d\n",
                    g_progState.bufferIndex);
            }
        }
    }
}