OBD_BleBox/BleCanBoxCode/STM32F103RCT6/MOD/Src/mod_spi.c

#include "mod_spi.h"
#include "mod_candataprocess.h"
#include "mod_sys.h"

#include "sys_queue.h"
#include "sys_log.h"
#include "sys_crc.h"
#include "sys_common.h"

#include "string.h"

#include "hal_spi.h"
#define  WECHAT_DEBUG         1
#define  BLE_CONFIG_BUF_LEN   32

static uint16_t g_s_tlen = 0;
static uint16_t g_s_clen = 0;
static uint8_t g_s_ble_config[BLE_CONFIG_BUF_LEN];
#if WECHAT_DEBUG

static uint8_t test_cmd[] = {0x00, 0x00, 0x06, 0xf1, 0x05, 0x12, 0x03, 0x22, 0xf1, 0x8a};
uint8_t test_tx_buffer[] = {0x52, 0x01, 0x00, 0x00, 0x00, 0x06, 0x12, 0x08, 0xf1, 0x06, 0x62, 0xf1, 0x8a, 0x22, 0x22, 0x22};
#endif //WECHAT_DEBUG

static spi_send_callback_fp g_s_spi_send_callback = NULL;

void MOD_SpiDataProcess(uint8_t* data, uint8_t data_len)
{
    SPI_HEADER_T* pHeader = (SPI_HEADER_T*)data;
    uint16_t check_crc = 0, pack_crc;
    uint8_t pack_len;
    uint8_t pack_cmd;
    uint8_t header_len = sizeof(SPI_HEADER_T);
    uint8_t crc_index;
    uint8_t ver = 0;

    pack_cmd = pHeader->message_code;
    pack_len = pHeader->len;
    crc_index = header_len-2+pack_len-3;
    
    check_crc = UTIL_CRC(&data[2], crc_index);
    memcpy(&pack_crc, &data[crc_index+2], 2);

    small_big_transfer16(&pack_crc);

    if(check_crc != pack_crc)
    {
        return;
    }
		
    DLOG_I("spi_rx_data:%s,len:%d", SYS_Hex2str((uint8_t* )data, data_len), data_len);

    if(pack_cmd == BLE_CMD_VER)
    {
        ver = data[4];
        DLOG_I("BLE_CMD_VER");
        DLOG_I("ble ver:0x%x", ver);
        MOD_SpiSetBleConfig();
    }
    else if(pack_cmd == BLE_CMD_CFG)
    {
        DLOG_I("BLE_CMD_CFG");
    }
    else if(pack_cmd == BLE_CMD_TRANSFER)
    {
        DLOG_I("BLE_CMD_TRANSFER");
        if(data[4] == TRANSFER_GET_CAN_CMD)
        {
            DLOG_I("send_can_data_cmd");
#if WECHAT_DEBUG
            if(!memcmp(&data[7], test_cmd, sizeof(test_cmd)))
            {
                DLOG_I("wechat test cmd");
                MOD_SpiDataSend(BLE_CMD_TRANSFER, test_tx_buffer, sizeof(test_tx_buffer));
            }
            else
            {
                MOD_CanTransferData(&data[5], pack_len-3-1);
            }
#else
            MOD_CanTransferData(&data[5], pack_len-3-1);
#endif //WECHAT_DEBUG
        }
    }
    else if(pack_cmd == BLE_CMD_CONNECT)
    {
        DLOG_I("BLE_CMD_CONNECT");
    }
    else if(pack_cmd == BLE_CMD_DISCONNECT)
    {
        DLOG_I("BLE_CMD_DISCONNECT");
    }
    else if(pack_cmd == BLE_CMD_TEST)
    {
        ver = data[4];
        DLOG_I("BLE_CMD_TEST");
        DLOG_I("get ble ver:0x%x", ver);
    }
}

void MOD_SpiDataSendCallbackRegister(spi_send_callback_fp fp)
{
    g_s_spi_send_callback = fp;
}

void MOD_SpiDataSend(uint8_t cmd, uint8_t*data, uint8_t len)
{
    uint8_t send_buf[QUEUE_MAX_DATA_LEN] = {0};
    int pack_len = 0;
    uint16_t crc;
    uint16_t header_len = sizeof(SPI_HEADER_T);
    SPI_HEADER_T* pHeader = (SPI_HEADER_T*)send_buf;

    memset(send_buf, 0, QUEUE_MAX_DATA_LEN);

    pHeader->ident[0] = SPI_DATA_IDENT;
    pHeader->ident[1] = SPI_DATA_IDENT;
    pHeader->len = 3 + len;
    pHeader->message_code = cmd;

    if ((len>0)&&(len<QUEUE_MAX_DATA_LEN-2-header_len))
    {
        memcpy(&send_buf[header_len], data, len);
    }

    crc = UTIL_CRC(&send_buf[2], header_len-2+len);
    send_buf[header_len + len] = (crc >> 8) & 0xFF;
    send_buf[header_len + len + 1] = crc & 0xFF;

    pack_len = header_len+len+2;

    DLOG_I("spi_tx_data:%s,len:%d", SYS_Hex2str(send_buf, pack_len), pack_len);

    if(NULL != g_s_spi_send_callback)
    {
        g_s_spi_send_callback(send_buf, QUEUE_MAX_DATA_LEN);
    }
}

int MOD_SpiSetBleConfig(void)
{
    uint8_t ble_mac[6] = {0};
    uint8_t ble_name[10] = {0};
    uint32_t ble_adv_interval = 0;
    uint8_t* p_name = NULL;
    uint8_t ble_name_len = 0;

    memset(ble_mac, 0, 6);
    memcpy(ble_mac, (uint8_t* )MOD_SysGetPara(PARA_BLE_MAC), 6);
    DLOG_I("set ble_mac:%X%X%X%X%X%X", ble_mac[0],ble_mac[1],ble_mac[2],ble_mac[3],ble_mac[4],ble_mac[5]);

    memset(ble_name, 0, 10);
    p_name = (uint8_t* )MOD_SysGetPara(PARA_BLE_NAME);
    ble_name_len = strlen(p_name);

    memcpy(ble_name, p_name, ble_name_len);
    DLOG_I("set ble_name:%s,len:%d", ble_name, ble_name_len);

    ble_adv_interval = *(uint32_t* )MOD_SysGetPara(PARA_BLE_ADV_INTERVAL);
    DLOG_I("set ble_adv_interval:%d", ble_adv_interval);

    MOD_SpiTlvInit(g_s_ble_config, BLE_CONFIG_BUF_LEN);
    MOD_SpiTlvSetValue(g_s_ble_config, TAG_DL_MAC, 6, ble_mac);
    MOD_SpiTlvSetValue(g_s_ble_config, TAG_DL_ADV_NAME, ble_name_len, ble_name);
    MOD_SpiTlvSetValue(g_s_ble_config, TAG_DL_ADV_INTERVAL, 4, &ble_adv_interval);

    MOD_SpiDataSend(BLE_CMD_CFG, g_s_ble_config, MOD_SpiTlvGetLen());
    return 0;
}

uint16_t srv_ble_byte_2_short(uint8_t* bytes) 
{
    uint16_t result = bytes[1] & 0xFF;
    result |= ((bytes[0] << 8) & 0xFF00);
    return result;
}

uint16_t MOD_SpiTlvGetLen(void) 
{
    return g_s_clen;
}

void MOD_SpiTlvInit(uint8_t *buf, uint16_t len) 
{
    g_s_tlen = len;
    g_s_clen = 0;
    memset(buf, 0, len);
}

uint16_t MOD_SpiTlvGetValue(uint16_t id, void* input ,uint16_t inputLen, void* output) 
{
    uint8_t* tmp;
    uint16_t curr = 0;
    uint16_t len = 0;
    uint8_t* end;

    tmp = input;
    end = (uint8_t*)input + inputLen;

    while (tmp + 4 <= end) 
    {
        curr = srv_ble_byte_2_short(tmp);
        tmp += 2;
        len = srv_ble_byte_2_short(tmp);
        tmp += 2;
        if( tmp + len > end )
            return 0;
        if (curr == id) 
        {
            memcpy(output, tmp, len);
            return len;
        }
        tmp += len;
    }
    return 0;
}

void MOD_SpiTlvSetValue(uint8_t *buf, uint16_t id, uint16_t size, void *value) 
{
    if(g_s_clen + size + 4 > g_s_tlen) 
    {
        DLOG_E("tlv buffer is too small[%d]", g_s_clen + size + 4);
        return;
    }
    buf[g_s_clen++] = (id >> 8) & 0xFF;
    buf[g_s_clen++] = id & 0xFF;
    buf[g_s_clen++] = (size >> 8) & 0xFF;
    buf[g_s_clen++] = size & 0xFF;
    memcpy(buf + g_s_clen, value, size);
    g_s_clen += size;
}