rgv-kinco/applications/nav/dm_scaner.c

/*******************************************************************************************
 * @file dm_scaner.c
 *
 * @brief ��ά��ɨ��������
 *
 *               (c) Copyright 2020, Shandong Huali electromechanical Co., Ltd..
 *             This is protected by international copyright laws. Knowledge of the
 *             source code may not be used to write a similar product. This file may
 *             only be used in accordance with a license and should not be redistributed
 *             in any way. We appreciate your understanding and fairness.
 *
 *
 * @author      Deman
 * @date        Created: 2020.08.06-T11:18:09+0800
 *
*******************************************************************************************/
#include "dm_scaner.h"
#include "hardware.h"
#include "env.h"

#define DBG_SECTION_NAME  "scaner"
#define DBG_LEVEL         DBG_INFO
#include <rtdbg.h>


typedef struct
{
    rt_device_t device;

    char end_sign;

    uint8_t *recv_buffer;
    rt_size_t recv_bufsz;
    rt_size_t cur_recv_len;
    rt_sem_t rx_notice;
}DMScaner_parser_t;

static DMScaner_parser_t DMScannerParser = {0};

DmScanerData_t DmScanerData;

Scaner_TypeDef	scan = {0};

/**
 * @funtion Xor
 * @brief �����
 * @Author Deman
 * @DateTime 2020.08.12-T8:54:31+0800
 *
 * @param   data  ��������
 * @param   len  ���ݳ���
 * @return  ����
 */
uint8_t DMScannerXor(uint8_t* data,uint8_t len)
{
    uint8_t i;
    uint8_t xor_res = 0;
    for(i = 0;i < len -1 ; i++)
        xor_res ^= data[i];
    return xor_res;
}

static rt_err_t DMScannerRxInd(rt_device_t dev, rt_size_t size)
{
    if(DMScannerParser.rx_notice)
    {
        rt_sem_release(DMScannerParser.rx_notice);
        return RT_EOK;
    }
    return RT_ENOMEM;
}

void DmUsart7_Send(uint8_t *ch, int len)
{
    RS485_TX_EN = 1;
    rt_device_write(DMScannerParser.device, 0, ch, len);
    RS485_TX_EN = 0;
}


static rt_err_t DMScannerGetchar(DMScaner_parser_t *parser, char *ch, rt_int32_t timeout)
{
    rt_err_t result = RT_EOK;

    while (rt_device_read(parser->device, 0, ch, 1) == 0)
    {
        rt_sem_control(parser->rx_notice, RT_IPC_CMD_RESET, RT_NULL);

        result = rt_sem_take(parser->rx_notice, rt_tick_from_millisecond(timeout));
        if (result != RT_EOK)
        {
            return result;
        }
    }

    return RT_EOK;
}

static int DMScannerReadline(DMScaner_parser_t *parser, uint32_t timeout)
{
    rt_size_t read_len = 0;
    char ch = 0;
    int rc = RT_EOK;

    rt_memset(parser->recv_buffer, 0x00, parser->recv_bufsz);
    parser->cur_recv_len = 0;

    while (parser->device)
    {
        rc = DMScannerGetchar(parser, &ch, timeout);
        if(rc != RT_EOK)
        {
            return read_len;
        }

        if (read_len < parser->recv_bufsz)
        {
            parser->recv_buffer[read_len++] = ch;
            parser->cur_recv_len = read_len;
        }
    }

    return read_len;
}

/**
 * @funtion mb_send
 * @brief ���ݷ���
 * @Author Deman
 * @DateTime 2020.08.12-T8:53:08+0800
 *
 * @param   buffer  ���ݻ���ָ��
 * @param   len  �������ݳ���
 */
static void mb_send(uint8_t* buffer, uint16_t len)
{
    DmUsart7_Send(buffer, len);
}
/**
 * @funtion DMScanerDH_parse
 * @brief ɨ��������������
 * @Author Deman
 * @DateTime 2020.08.12-T8:48:59+0800
 *
 * @param   parser  �������ݽṹ��
 * @param   timeout  ���ճ�ʱʱ�䣬��ʱ˵��һ֡���ݽ������
 * @return  description
 */
static int DMScanerDH_parse(DMScaner_parser_t *parser)
{
    uint8_t * DmRecvData;
    static uint16_t recvErrCnt;

    if(DMScannerXor(parser->recv_buffer, parser->cur_recv_len - 1)
        == parser->recv_buffer[parser->cur_recv_len - 1])
    {
        if(parser->recv_buffer[0] == 0)
        {
            DmRecvData = parser->recv_buffer;
            S.DmS = DmRecvData[0];
            //LogInfo("S.DmS: %X\r\n",S.DmS);
            S.xOffset = (DmRecvData[4] & (0X01<<6))> 0?(DmRecvData[4]<<7 | DmRecvData[5] + 0xC000):(DmRecvData[4]<<7 | DmRecvData[5]);
            S.yOffset = (DmRecvData[6] & (0X01<<6))> 0?(DmRecvData[6]<<7 | DmRecvData[7] + 0xC000):(DmRecvData[6]<<7 | DmRecvData[7]);
            S.Angle = DmRecvData[10] * 0x80 + DmRecvData[11];
            //LogInfo("S.DmAngle: %d\r\n",S.DmAngle);
			/* C X Y 01002004 */
			uint32_t TagNum;
			uint32_t	xValue;	//巷值
			uint32_t	yValue;	//坡值
			uint32_t	cValue;	//层值
            TagNum = (DmRecvData[14] << 21 | DmRecvData[15] << 14 | DmRecvData[16] << 7 | DmRecvData[17]);
			if(TagNum)
			{
				 S. TagNum = TagNum;
				xValue = (S.TagNum / 1000) % 1000;
				if(xValue)
				scan.xValue = xValue;
				else	LOG_E("scan err x");
				yValue = S.TagNum % 1000;
				if(yValue)
				scan.yValue = yValue;
				else	LOG_E("scan err y");			
				cValue = (S.TagNum / 1000 /1000) % 1000;	
				if(cValue)
				scan.cValue = cValue;
				else	LOG_E("scan err c");
			
			}			
//			S.yValue = scan.yValue;			
//			S.xValue = (S.TagNum / 1000) % 1000;
//            //LogInfo("S.xValue: %d\r\n",S.xValue);
//            S.yValue = S.TagNum % 1000;
//            //LogInfo("S.yValue: %d\r\n",S.yValue);
//            /*��С�����������ϣ��������ⲿ����(��ȡ�������������¡�λ���������)*/
//            if(S.TagNum != Set.TsjStation)	//提升机码
//			{
//                S.cValue = (S.TagNum / 1000 /1000) % 1000;
//            }
            //LogInfo("S.yValue: %d\r\n",S.yValue);       
            //LogInfo("S.Point: %d\r\n",S.Point);
            DmScanerData.Ready = true;
            DmScanerData.Sta = DMSCANER_VALUE_UPDATE;
        }
        else
        {
            DmScanerData.Ready = false;
            DmScanerData.Sta = DMSCANER_VALUE_INVALID;
        }
        recvErrCnt = 0;
    }
    else{
        recvErrCnt++;
    }

    if(parser->rx_notice)
    {
        /*��ʱδ���յ����������ݣ���Ϊ������ʧЧ*/
        if(recvErrCnt > 100){
             DmScanerData.Sta = DMSCANER_ERR;
             S.Status = STATUS_DRIVER_ERROR;
        }
    }
    return 0;
}

/**
 * @funtion DMDMScanerDH_Ready
 * @brief ��ȡ��ǰ��ά���Ƿ���Ч
 * @Author Deman
 * @DateTime 2020.08.13-T14:26:43+0800
 *
 * @return  description
 */
bool DMScanerDH_Ready(void)
{
    return DmScanerData.Ready;
}

/**
 * @funtion DMScanerDH_poll
 * @brief DMɨ������ʱ���Ͳ�ѯָ���Լ������������
 * @Author Deman
 * @DateTime 2020.08.12-T8:48:01+0800
 *
 */
void DMScanerDH_poll(void *param)	//二维码
{
    static uint32_t read_time = 0;
    DMScannerParser.recv_bufsz = 200;
    DMScannerParser.cur_recv_len = 0;
    DMScannerParser.recv_buffer = (uint8_t *) rt_calloc(1, DMScannerParser.recv_bufsz);
    DMScannerParser.rx_notice = rt_sem_create("gnss_cs", 0, RT_IPC_FLAG_FIFO);

    DMScannerParser.device = rt_device_find("uart7");
    if (DMScannerParser.device)
    {
        rt_err_t open_result = RT_EOK;

        open_result = rt_device_open(DMScannerParser.device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
        RT_ASSERT(open_result == RT_EOK);
        rt_device_set_rx_indicate(DMScannerParser.device, DMScannerRxInd);
    }
    while(1)
    {
        if(read_time >= 2){
            read_time = 0;
            uint8_t send_buf[3];
            send_buf[0] = 0xC8;
            send_buf[1] = 0X37;
            mb_send(send_buf, 2);
        }
        if(DMScannerReadline(&DMScannerParser, 8))
        {
            DMScanerDH_parse(&DMScannerParser);
        }
		if(S.xValue == 0 ||S.yValue == 0|| S.cValue == 0)
		{
			LOG_E("S-xyz err");
		}
		if(scan.xValue)
		S.xValue = scan.xValue;
		if(scan.yValue)
		S.yValue = scan.yValue;			
		if(S.TagNum != Set.TsjStation)	//非提升机码
		{
			if(scan.cValue)
			S.cValue = scan.cValue;
		}
		else
		{
			if(scan.Set_cValue)
			S.cValue = scan.Set_cValue;
		}
		S.Point = (S.xValue * 1000 + S.yValue);
        read_time++;
    }
}

/**
 * @funtion DMScanerInit
 * @brief  ɨ������ʼ��
 * @Author Deman
 * @DateTime 2020.08.06-T11:20:25+0800
 *
 * @return  description
 */
int DMScanerInit(void)
{
	scan.Set_cValue = 1;
	S.xValue  = 255;
	S.yValue  = 255;
	S.cValue  = 255;
	
    rt_thread_t tid;
    // thread
    tid = rt_thread_create("scan",
            DMScanerDH_poll, RT_NULL,
                              1024,
                              8, 10);

    if (tid != RT_NULL)
    {
        rt_thread_startup(tid);
    }
    return RT_EOK;
}
INIT_APP_EXPORT(DMScanerInit);