/*
 * ZD24C02A.c
 *
 *  Created on: 8 сент. 2023 г.
 *      Author: seklyuts
 */
#include <ZD24C02A_Power_Module.h>
#include "f28x_project.h"
#include "i2c_init.h"
#include "Arr.h"

//Нуждается в проверке и отладке, так как с этой микросхемой не удалось добиться стабильной работы, она то работает, то нет

volatile uint16_t PowerModuleSlaveAdr = I2C_POWER_MODULE_SLAVE_ADDRESS;
uint16_t BufferZD24C02A_PowerModule[17];

uint16_t ZD24C02A_Power_Module_write_8(uint16_t Addr, uint16_t * Array, uint16_t quant)// может писать очередями по 16 байт
{
    if(I2CWrite(PowerModuleSlaveAdr, Addr, quant, true, Array)) return 1;
    else return 0;
}

uint16_t ZD24C02A_PowerModule_read_8(uint16_t Addr, uint16_t * Array, uint16_t quant)
{

    if(I2CWrite(PowerModuleSlaveAdr, Addr, 0, false, Array)) return 1;
    if(I2CRead(PowerModuleSlaveAdr, quant, true, Array)) return 1;
    else return 0;
}


uint16_t ZD24C02A_PowerModule_verify_16(uint16_t Addr, uint16_t * Array, uint16_t quant)
{
    uint16_t VerifyErr = 0;

    if(I2CWrite(PowerModuleSlaveAdr, Addr, 0, false, BufferZD24C02A_PowerModule)) return 1;
    VerifyErr = I2CVerify(PowerModuleSlaveAdr, quant, true, Array);
    return VerifyErr;
}

uint16_t ZD24C02A_PowerModule_write(uint32_t Addr, uint16_t quant8, uint16_t * write_data)
{
    uint32_t i=0;
    uint16_t addr_write_data[0x100];
    uint16_t quant16;

    quant16 = quant16bitWords(quant8);
    copy16_to_8(write_data, addr_write_data, quant16);

    for(i = 0; i < quant8; i += 1)
    {
        if( ZD24C02A_Power_Module_write_8(Addr+i, addr_write_data+i, 1)) return 1;
    }

    return 0;
}

uint16_t ZD24C02A_PowerModule_read(uint32_t Addr, uint16_t quant8, uint16_t * read_data)
{
    uint32_t i=0;
    uint16_t addr_read_data[8];

    if(quant8 > 8)
    {
        for(i = 0; i < (quant8-8); i += 8)
        {//в этом цикле только полные посылки по 8 байт
            if( ZD24C02A_PowerModule_read_8(Addr+i, addr_read_data, 8)) return 1;
            copy8_to_16(addr_read_data, read_data, 4);
            read_data+=4;
        }
    }
    if(i < quant8)
    {//тут м.б. от 1 до 8 байт
        if( ZD24C02A_PowerModule_read_8(Addr+i, addr_read_data, (quant8 - i))) return 1;
        if((quant8 - i) & 1) {addr_read_data[quant8] = 0; quant8++; }//если байт нечётное число, то дополняем до чётного нулём
        copy8_to_16(addr_read_data, read_data, (quant8 - i)/2);
    }
    return 0;
}

uint16_t ZD24C02A_PowerModule_verify(uint32_t Addr, uint16_t quant8, uint16_t * verify_data)
{
    uint32_t i=0;
    uint16_t addr_vfy_data[8];
    uint16_t Err_read = 0;
    uint16_t quant16;

    if(quant8 > 8)
    {
        for(i = 0; i < (quant8-8); i += 8)
        {//в этом цикле только полные посылки по 8 байт
            copy16_to_8(verify_data, addr_vfy_data, 4);
            Err_read = ZD24C02A_PowerModule_verify_16(Addr+i, addr_vfy_data, 8);
            if(Err_read) return Err_read;
            verify_data+=4;
        }
    }
    if(i < quant8)
    {//тут м.б. от 1 до 8 байт
        quant16 = quant16bitWords(quant8-i);
        copy16_to_8(verify_data, addr_vfy_data, quant16);
        Err_read = ZD24C02A_PowerModule_verify_16(Addr+i, addr_vfy_data, (quant8 - i));
        if(Err_read) return Err_read;
    }
    return 0;
}



void ZD24C02A_PowerModule_read_all(uint16_t byteCount, uint16_t * Array)
{
    I2CRead(PowerModuleSlaveAdr, byteCount, true, Array);
//    I2CWriteRead(I2C_SLAVE_ADDRESS, byteCount, true, Array);
//    I2CWriteReadOnes(I2C_SLAVE_ADDRESS);
}


void ZD24C02A_PowerModule_test(uint16_t * Array)
{
    uint16_t i=0;
    for(i=0;i<=255;i+=15)
    {
//        I2CWrite(SlaveAdr, 1, true, Array);
    }
}
