cómo almacenar una matriz de valores enteros largos en una memoria de 16 bits

Por lo tanto, el flash que está utilizando solo admite la escritura de una palabra de 16 bits a la vez y no se puede acceder a él de otra manera (es un poco extraño). Debido a eso, tendrá que hacer un poco de administración de direcciones manual, pero el flash afortunadamente viene con una dirección de escritura de incremento automático.

De todos modos, como puede transferir solo un byte a través de SPI (hay algunas variantes de 16 bits, pero olvidémonos de ellas por un minuto, aunque sería lo más apropiado aquí), la forma más natural de interactuar con ellas es con matrices de bytes.

Así que cambiaría el Flash_Write así:

long int Start_Flash_Write(int StartAddress, unsigned char* Data, long int Datacount, const unsigned char FINISH_BYTE)
{
    long int dataSent = 0;
    // Make chip select Low
    Flash_Set_CS_Status(0);

    // Send Command ID 0x17
    data0 = Flash_SPI_SendByte(0x17);

    // Send Address Byte 3
    data0 = Flash_SPI_SendByte((StartAddress & 0xFF0000) >> 16);    

    // Send Address Byte 2
    data0 = Flash_SPI_SendByte((StartAddress & 0xFF00) >> 8);

    // Send Address Byte 1
    data0 = Flash_SPI_SendByte(StartAddress & 0xFF);

    // Send first two DataBytes
    data0 = Flash_SPI_SendByte(Data[dataSent++]);
    if (dataSent < (Datacount))
    {
        data0 = Flash_SPI_SendByte(Data[dataSent++]);
    }
    else
    {
        data0 = Flash_SPI_SendByte(FINISH_BYTE);
    }
    // Send Dummy Byte
    data0 = Flash_SPI_SendByte(0);

    // Make Chip select high
    Flash_Set_CS_Status(1);

    return dataSent;

}

int Flash_Write(int StartAddress, unsigned char* Data, long int Datacount)   //Flash wirte function
{ 
    int error ;
    int data0 = 0;
    long int dataSent;
    const unsigned char FINISH_BYTE  = 0xFF;

    if (Datacount == 0)
    {
        return 0; // writing nothing is easy
    }

    // First Write sets StartAddress
    dataSent = Start_Flash_Write(StartAddress, Data, Datacount, FINISH_BYTE);

    while (dataSent < (Datacount))
    {
        // Make chip select Low
        Flash_Set_CS_Status(0);

        // Send Command ID 0x18 (auto increment write)
        data0 = Flash_SPI_SendByte(0x18);

        // Send first two DataBytes
        data0 = Flash_SPI_SendByte(Data[dataSent++]);
        if (dataSent < (Datacount))
        {
            data0 = Flash_SPI_SendByte(Data[dataSent++]);
        }
        else
        {
            data0 = Flash_SPI_SendByte(FINISH_BYTE);
        }

        // Send Dummy Byte
        data0 = Flash_SPI_SendByte(0);

        // Make Chip select high
        Flash_Set_CS_Status(1); 
    }
}

Y luego lo llamarías así:

Flash_Write(0x1234, (unsigned char*)(sampledata), sizeof(sampledata))

Cómo funciona:

Comienza con la escritura de la Dirección de inicio y los dos primeros bytes en la memoria flash. Luego escribe los bytes como un par en la siguiente dirección usando el modo de incremento automático de la memoria flash.

Como el recuento de bytes de datos puede no ser uniforme, verifico si se ha alcanzado el recuento de datos después de que se escribe cada byte. Si ese es el caso, se usa una constante FINISH_BYTE para finalizar la transferencia de manera normal.

Notas:

Recomiendo encarecidamente que no se utilicen tipos de datos integrales directamente, ya que nadie puede saber qué tan grandes son en realidad (¿es un int 16 o 32 bit de ancho?).

La cuenta de datos se debe pasar a la función, ya que la información sobre el tamaño de la matriz se pierde cuando se convierte en un puntero y queda fuera del alcance.

La función no devuelve algo, eso debería ser arreglado. El error no se usa.