VGKitBoard_7669T/project/main.c

#include "main.h"
#include "ReadKey.h"
#include "key.h"
#include "ReadKey.h"
#include "crc8.h"
#include "led.h"
#include "eventUnit.h"
#include "myADC.h"
#include "myInputCapture.h"
#include "myLcd.h"
#include "myDisplayUnit.h"
// #include "myFlashData.h"
#include "myTim.h"
#include "myUart.h"
#include "myBootloader.h"
#include <math.h>
#include "nmeaparser.h"

#define SOFT_VERSION 0x02
#define SET_RF_FREQ_HZ(base, ch,step) base+ch*step*10*1000
//---------------key
KeyParamExt_ts *getKeyReturn;
key_value_te keyPressValue;


static uint16_t present_adcValue;
static uartPacket_ts uartPacket;
static uartPacket_ts uart3Packet;

static bool startToCountingRx = false;
static float present_moduleCurrendValue;
static float validPackageCount = 0;
static uint32_t rfContinuousFreq = 1;
static float rfRxTestRate = 1;

static uint32_t rfTxCount = 0;
static uint32_t rfRxCount = 0;
static uint32_t rfTxAndGetAckTime_ms = 0;
static uint32_t rfTxAndGetAckTimeSet_ms = 3000;
static uint32_t rfTxReTmCount = 0;
static bool rfTxGetAckStatus = false;
static uint8_t rfCtrlMode;
userParams_ts deviceInforDef = 
{
    .deviceId = 1,
    .rfChannel = 0,
    .channelStep = 100,
};
uint16_t utc_time;
uint16_t loc_time;
userParams_ts deviceInfor;
#define EVENT_TIME_CYCLE_10ms         0
#define EVENT_TIME_CYCLE_500ms      1
#define EVENT_UART3_RECV     2
#define EVENT_UART_RECV         3
#define EVENT_BOOT_TIMEOUT       4
#define EVENT_RF_CONTINUOUS_TX       5
#define EVENT_RF_CONTINUOUS_RX       6
#define EVENT_GNSS_TIME       7
#define EVENT_GNSS_LOC_TIME       8
#define EVENT_TIMEOUT_TO_SAVE_PARAMS       9
#define EVENT_RF_GET_RX_PACKET       10
#define EVENT_RF_PACKET_TX       11
#define EVENT_RF_PACKET_RX       12
#define EVENT_TIMEOUT_CHECK_RF_PACKET       13
#define EVENT_GNSS_RX_TIMEOUT       14
static uint16_t eventReturn;
struct nmea_parser parser[1];
extern void decodeGnss(char *src);

void dealKeyPressProccess(void)
{
    if (getKeyReturn->haveKey == false)
    {
        return;
    }
    getKeyReturn->haveKey = false;

    switch (getKeyReturn->value)
    {
    case LEFT_KEY:
    {
        if(getLongKeySt() == true)
        {
            clearLongKey(); 

            EnableReleaseKey();
            myDisplay_enter(ENTER_LAST_PAGE);
        }
        else
        {
            if (getReleaseKeySt())
            {

            }
            else
            {
                EnableLongKey(5);   
            }
        }
    }
        break;
    case RIGHT_KEY:
    {
        if(getLongKeySt() == true)
        {
            clearLongKey(); 

            EnableReleaseKey();
        }
        else
        {
            if (getReleaseKeySt())
            {

            }
            else
            {
                EnableLongKey(5);   
            }
        }
    }
        break;
    case TOP_KEY:
    {
        if(getCyclicKeySt() == true)
        {
            EnableCyclicKey(30); 
            myDisplay_change(1);
        }
        else
        {
            if (getReleaseKeySt())
            {
                beep_shortBeep();
                myDisplay_change(1);
            }
            else
            {
                EnableReleaseKey();
                EnableCyclicKey(300);   
            }
        }
    }
        break;
    case BOTTOM_KEY:
    {
        if(getCyclicKeySt() == true)
        {
            EnableCyclicKey(30); 
            myDisplay_change(0);
        }
        else
        {
            if (getReleaseKeySt())
            {
                beep_shortBeep();
                myDisplay_change(0);
            }
            else
            {
                EnableReleaseKey();
                EnableCyclicKey(300);   
            }
        }
    }
        break;
    case OK_KEY:
    {
        if(getLongKeySt() == true)
        {
            clearLongKey(); 

            EnableReleaseKey();
            beep_shortBeep();
            myDisplay_enter(ENTER_NEXT_PAGE);
        }
        else
        {
            if (getReleaseKeySt())
            {

            }
            else
            {
                EnableLongKey(5);   
            }
        }
    }
        break;
    default:
        break;
    }
}

/**
 * 
 * 串口回调函数，当串口有硬件超时时会调用该函数
*/
static void rcc_init(void)
{
    //---------普通IO口时钟使能
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE ); 
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE ); 
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE ); 
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOD, ENABLE ); 

    //----------复用功能时钟使能
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

    #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
    /* ADCCLK = PCLK2/2 */
    RCC_ADCCLKConfig(RCC_PCLK2_Div2);
    #else
    /* ADCCLK = PCLK2/4 */
    RCC_ADCCLKConfig(RCC_PCLK2_Div4); 
    #endif
}
/**
 * 
 * 串口回调函数，当串口有硬件超时时会调用该函数
*/
void UART1_CALLBACK(uint8_t *buf, uint16_t len)
{
 if(uartPacket.isValid == 0)
 {
     memcpy(uartPacket.packet, buf, len);
     uartPacket.len = len;
     uartPacket.isValid = 1;
     event_post(EVENT_UART_RECV);
 }
}
void UART3_CALLBACK(uint8_t *buf, uint16_t len)
{
    if(uart3Packet.isValid == 0)
    {
        memcpy(uart3Packet.packet, buf, len);
        uart3Packet.len = len;
        uart3Packet.isValid = true;
        event_post(EVENT_UART3_RECV);
    }
}
/**
 * 
 * 定时器中断回调，当产生定时器中断会调用该函数
*/
void TIM3_CALLBACK(void)
{
    static uint8_t timeCnt_1ms = 0;

    beep_onDriver();
    if(timeCnt_1ms ++ == 5)
    {
        timeCnt_1ms = 0;
        rfTxAndGetAckTime_ms ++;
        eventDriver();
    }
}

void uiEnterCallback(int pageId, int cursorCount, int status, int value)
{
    switch (pageId - 1)
    {
    case UI_PAGE_ID_ITEM_MODE:
    {

    }break;
    case UI_PAGE_ID_RF_CONTINUOUS:
    {
    }
        break;
    case UI_PAGE_ID_RX_PACKET:
    {
    }
        break;
    case UI_PAGE_ID_SETTING:
    {
        switch (cursorCount)
        {
        case SET_ITEM_INDEX_TYPE://chipType
        {
            deviceInfor.chipType = value;

            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        case SET_ITEM_INDEX_FREQ://Freq
        {
            deviceInfor.rfChannel = value;

            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        case SET_ITEM_INDEX_STEP://channelStep
        {
            deviceInfor.channelStep = value;

            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        case SET_ITEM_INDEX_TXPOWER://TxPower
        {
            deviceInfor.txPower = value;


            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
        break;
        case SET_ITEM_INDEX_RFBAUDRATE://RFBAUDRATE
        {
            deviceInfor.rfBaudrate = value;
            setEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS, false, 200);
        }
            break;
        default:
            break;
        }
    }
        break;

    default:
        break;
    }
}
void sort(int arr[], int n) {  
    int i, j, temp;  
    for (i = 0; i < n-1; i++) {  
        for (j = 0; j < n-i-1; j++) {  
            if (arr[j] < arr[j+1]) {  
                temp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = temp;  
            }  
        }  
    }  
} 
/*
 * Print navigation data and wait for user's keystroke
 * @navdata:    the navigation data
 */
void display_navdata(struct nav_data *navdata) {
        // printf("NAVDATA:\n");
        // printf("NAVDATA.FIX_VALID = %d\n", navdata->is_fixed);
        // printf("NAVDATA.DATE = %d-%02d-%02d\n", navdata->date.year, navdata->date.month, navdata->date.day);
        // printf("NAVDATA.TIME= %02d:%02d:%02d.%03d\n", navdata->time.hour, navdata->time.minute, navdata->time.second, navdata->time.ms);
        // printf("NAVDATA.LAT = %.6f\n", navdata->lat);
        // printf("NAVDATA.LON = %.6f\n", navdata->lon);
        // printf("NAVDATA.ALT = %.2f\n", navdata->alt);
        // printf("NAVDATA.HEADING = %.2f\n", navdata->heading);
        // printf("NAVDATA.SPEED = %.2f\n", navdata->speed);
        // printf("NAVDATA.HDOP = %.1f\n", navdata->hdop);
        // printf("NAVDATA.VDOP = %.1f\n", navdata->vdop);
        // printf("NAVDATA.PDOP = %.1f\n", navdata->pdop);
        // printf("NAVDATA.NUM_SV_FIX = %d\n", navdata->sv_inuse);
        // printf("NAVDATA.NUM_SV_VIEW = %d\n", navdata->sv_inview);

        int svid;
        int getIndex = 0;
        int cn0List[100];
        memset(cn0List, 0, sizeof(cn0List));
        for (svid = 0; svid < MAX_SVID; svid++) { 
            struct sate *sate = navdata->sates + svid;
            if (sate->valid)
            {
                cn0List[getIndex++] = sate->cn0;
                printf("NAVDATA.SATE%d.VALID = %d\n", svid, cn0List[getIndex]);
            }
        } 
        sort(cn0List, navdata->sv_inview);
        for (svid = 0; svid < 5; svid++) { 
            myDisplay_ui_rf_cn0_display_buffer(svid, "cn%d=%2d", svid, cn0List[svid]);
        } 

        printf("{\"LAT\":%.6f,\"LON\":%.6f,\"TIME\":%02d-%02d-%02d-%03d}\r\n", navdata->lat, navdata->lon, navdata->time.hour, navdata->time.minute, navdata->time.second, navdata->time.ms);
        // printf("\n");
        // printf("Press any key to continue...");
        myDisplay_ui_rf_display_buffer(0, "%d-%02d-%02d", navdata->date.year, navdata->date.month, navdata->date.day);
        myDisplay_ui_rf_display_buffer(1, "%02d:%02d:%02d.%03d", navdata->time.hour, navdata->time.minute, navdata->time.second, navdata->time.ms);
        myDisplay_ui_rf_display_buffer(2, "LAT=%3.10f", navdata->lat);
        myDisplay_ui_rf_display_buffer(3, "LON=%3.10f", navdata->lon);
        myDisplay_ui_rf_display_buffer(4, "SPEED=%.6f", navdata->speed);
        myDisplay_ui_rf_display_buffer(5, "SV:%d u:%d", navdata->sv_inview, navdata->sv_inuse);
        // getchar();
        setEvent(EVENT_GNSS_RX_TIMEOUT, false, 2000);
        if ((navdata->date.year + navdata->date.month + navdata->date.day + navdata->time.hour+navdata->time.minute+navdata->time.second+navdata->time.ms) == 0)
        {
            event_post(EVENT_GNSS_TIME);
        }
        else
        {
            utc_time = 0;
        }
        if ((navdata->lat + navdata->lon) == 0)
        {
            event_post(EVENT_GNSS_LOC_TIME);
        }
        else
        {
            loc_time = 0;
        }
        
}
int main(void)
{
#ifdef BOOTLOADER_APP
	SCB->VTOR = FLASH_BASE | 0x000C800;
#endif
    userParams_ts userParamsTemp;
    
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
    rcc_init();
        
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//关闭jtag , 开启swd
    //读取本地保存数据
    // myFlash_read((uint8_t*)&deviceInfor, sizeof(userParams_ts));
    // if (crc8_gernCheckT((unsigned char*)&deviceInfor, 
    //                     sizeof(userParams_ts) - 1, 
    //                     deviceInfor.checkSum) == 0)
    // {
    //     deviceInfor = deviceInforDef;
    // }
    //初始化按键
    key_init();

    //初始化LED灯
    LED_Init();

    //初始化串口
    myUart3_init(9600, UART3_CALLBACK);    //用于透传模块测试，需要时再打开
    myUart1_init(115200, UART1_CALLBACK);

    //初始化定时器
    myTim1_init(200, TIM3_CALLBACK);
    //初始化模拟转换ADC，用于无线模块驱动电流检测
    myADC_init();

    //蜂鸣器初始化
    beep_init();
    beep_setFreq(deviceInfor.beepNumb);

    // LCD显示屏初始化界面显示
    myDisplay_init(uiEnterCallback);
    myDisplay_ui_firstUi_setDeviceName("GNSS");

    //上电长想一声
    beep_longBeep();
    printf("Vollgo Module GNSS\r\n");
    setEvent(EVENT_TIME_CYCLE_10ms, true, 10);
    setEvent(EVENT_TIME_CYCLE_500ms, true, 3000);
    // setEvent(EVENT_BOOT_TIMEOUT, false, 60000);

    nmea_parser_init(parser);
    parser->report_nav_status = display_navdata; 
    while(1)
    {   
        eventReturn = event_pend();

        if (getEvent(EVENT_TIME_CYCLE_10ms))
        {
            getKeyReturn = KeyValueChange(keyPressValue);
            dealKeyPressProccess();
        }
        if (getEvent(EVENT_TIME_CYCLE_500ms))
        {
            present_moduleCurrendValue = myADC_getVoltageValue()/50/0.5*1000;
            myDisplay_ui_rf_continuos_txCurrent(present_moduleCurrendValue);
            myDisplay_ui_rf_rxPacket_rxCurrent(present_moduleCurrendValue);
            uiTimerFlash_callBack();
            // myPrintf3("AT\r\n");
        }
        if (getEvent(EVENT_RF_CONTINUOUS_RX))
        {
        }
        if (getEvent(EVENT_RF_CONTINUOUS_TX))
        {
        }

        if (getEvent(EVENT_RF_PACKET_TX))
        {

        }
        if (getEvent(EVENT_RF_PACKET_RX))
        {

        }
        if (getEvent(EVENT_RF_GET_RX_PACKET))
        {

            LED2_ON_ONE();
        }
        if (getEvent(EVENT_GNSS_RX_TIMEOUT))
        {
            nmea_parser_init(parser);
            parser->report_nav_status = display_navdata; 
            utc_time = 0;
            loc_time = 0;
        }
        if (getEvent(EVENT_GNSS_TIME))
        {
            myDisplay_ui_gnss_timer(++utc_time);
        }        
        if (getEvent(EVENT_GNSS_LOC_TIME))
        {
            myDisplay_ui_gnss_timer_loc(++loc_time);
        }
        if (getEvent(EVENT_UART_RECV))
        {
            if (uartPacket.isValid)
            {

                uartPacket.isValid = false;
            }
        }
        if (getEvent(EVENT_UART3_RECV))
        {
            if (uart3Packet.isValid)
            {
                // char *token;
                // /* 获取第一个子字符串 */
                // token = strtok((char *)uart3Packet.packet, "\r\n");
                // while (token != NULL)
                // {
                //     /* 继续获取其他的子字符串 */
                //     decodeGnss(token);
                //     // myPrintf1(uart3Packet.packet);
                //     token = strtok(NULL, "\r\n");
                // }
                // printf((char *)uart3Packet.packet);
                for (int i = 0; i < uart3Packet.len; i++)                     // parse nmea data
                        nmea_parser_putchar(parser, uart3Packet.packet[i]);
                uart3Packet.isValid = false;
                uart3Packet.len = 0;
                memset(uart3Packet.packet, 0, sizeof(uart3Packet.packet));
            }
        }
        if (getEvent(EVENT_TIMEOUT_TO_SAVE_PARAMS))
        {
            // deviceInfor.checkSum = crc8_ger((unsigned char*)&deviceInfor, sizeof(userParams_ts) - 1);
            // myFlash_write((uint8_t*)&deviceInfor, sizeof(userParams_ts));
        }
        if (getEvent(EVENT_BOOT_TIMEOUT))
        {
            NVIC_SystemReset();
        }
        
        keyPressValue = keyScan();
        
    }     
}