ble-light/src/app_wrist.c

#include <string.h>

#include "bcomdef.h"
#include "OSAL.h"
#include "linkdb.h"
#include "gatt.h"
#include "gapgattserver.h"
#include "gattservapp.h"
#include "ota_app_service.h"
#include "gatt_profile_uuid.h"
// #include "wristservice.h"
#include "devinfoservice.h"
#include "peripheral.h"
#include "gapbondmgr.h"

// #include "led_light.h"
#include "kscan.h"
#include "log.h"
#include "ll.h"

#include "adc.h"


#include "light.h"
#include "app_wrist.h"
#include "wrist_service.h"


// GAP connection handle
// 事件处理Id
uint8 AppWrist_TaskID;  
static uint16 gapConnHandle;
static gaprole_States_t gapProfileState = GAPROLE_INIT;

static uint8 attDeviceName[GAP_DEVICE_NAME_LEN] = BleName;
// Advertising user-cancelled state
static bool WristAdvCancelled = FALSE;

static uint8 scanData[] =
{
  0xa,   // length of this data
  GAP_ADTYPE_LOCAL_NAME_COMPLETE,
  'b',
  'l',
  'e',
  'L',
  'i',
  'g',
  'h',
  't',
  ' ',
};

static uint8 advertData[] = 
{ 
  // flags
  0x02,
  GAP_ADTYPE_FLAGS,
  GAP_ADTYPE_FLAGS_GENERAL | GAP_ADTYPE_FLAGS_BREDR_NOT_SUPPORTED,
  // service UUIDs
  0x03,
  GAP_ADTYPE_16BIT_MORE,
  LO_UINT16(HEARTRATE_SERV_UUID),
  HI_UINT16(HEARTRATE_SERV_UUID),
};





/**
 * @fn      appProcOSALMsg
 * 
 * @brief   Process an incoming task message.
 *
 * @param   pMsg - message to process
 *
 * @return  none
*/
static void appWristProcOSALMsg( osal_event_hdr_t *pMsg );
static void WristGapStateCB( gaprole_States_t newState);

// GAP Role Callbacks
static gapRolesCBs_t WristPeripheralCB =
{
  WristGapStateCB,  // Profile State Change Callbacks
  NULL                            // When a valid RSSI is read from controller
};


static void appWristProcOSALMsg( osal_event_hdr_t *pMsg )
{
    LOG("[fn : appWristProcOSALMsg]  run event is: %d \n", pMsg->event);
}

// Notification from the profile of a state change
static void WristGapStateCB(gaprole_States_t newState)
{
    LOG("app is start gapProfileState: %d WristGapStateCB: %d  \n", gapProfileState,  newState);
    // if connected
    if (newState == GAPROLE_CONNECTED)
    {
        // get connection handle
        GAPRole_GetParameter(GAPROLE_CONNHANDLE, &gapConnHandle);
    }
    // if disconnected
    else if (gapProfileState == GAPROLE_CONNECTED && 
            newState != GAPROLE_CONNECTED)
    {
        uint8 advState = TRUE;
        wristProfile_HandleConnStatusCB( gapConnHandle, LINKDB_STATUS_UPDATE_REMOVED );
        
        if ( newState == GAPROLE_WAITING_AFTER_TIMEOUT )
        {
            // link loss timeout-- use fast advertising
            GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_FAST_ADV_INTERVAL );
            GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_FAST_ADV_INTERVAL );
            GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_FAST_ADV_DURATION );
        }
        else
        {
            // Else use slow advertising
            GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL );
            GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL );
            GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION );
        }

        // Enable advertising
        GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );    
    
    }
    // if advertising stopped
    else if ( gapProfileState == GAPROLE_ADVERTISING && 
            newState == GAPROLE_WAITING )
    {
         // if advertising stopped by user
        if ( WristAdvCancelled )
        {
        WristAdvCancelled = FALSE;
        }
        // if fast advertising switch to slow
        else if ( GAP_GetParamValue( TGAP_GEN_DISC_ADV_INT_MIN ) == DEFAULT_FAST_ADV_INTERVAL )
        {
        uint8 advState = TRUE;
        
        GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL );
        GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL );
        GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION );
        GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );   
        }  
    }
    // if started
  else if (newState == GAPROLE_STARTED)
  {
    // Set the system ID from the bd addr
    uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
    GAPRole_GetParameter(GAPROLE_BD_ADDR, systemId);
    
    // shift three bytes up
    systemId[7] = systemId[5];
    systemId[6] = systemId[4];
    systemId[5] = systemId[3];
    
    // set middle bytes to zero
    systemId[4] = 0;
    systemId[3] = 0;
    
    DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
  }
  
  gapProfileState = newState;
}


static void wristCB(uint8 event, uint8 param_size, uint8* param)
{
  switch(event){

    case WRIST_NOTI_ENABLED:
    
        // if connected start periodic measurement
        if (gapProfileState == GAPROLE_CONNECTED)
        {
        //osal_start_timerEx( AppWrist_TaskID, HEART_PERIODIC_EVT, DEFAULT_HEARTRATE_PERIOD );
        }
        break;
    
    case WRIST_NOTI_DISABLED:
        // stop periodic measurement
        //osal_stop_timerEx( AppWrist_TaskID, HEART_PERIODIC_EVT );
        break;
    
  }
}


static void user_key_1_handler(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("user key 1 handler:%d %d\n", pin, type);
} 
static void user_key_2_handler(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("user key 2 handler:%d %d\n", pin, type);
}
static void user_key_3_handler(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("user key 3 handler:%d %d\n", pin, type);
}
static void user_key_4_handler(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("user key 4 handler:%d %d\n", pin, type);
}

static void user_key_1_handler_ppp(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("+++ 1 handler ppp:%d %d\n", pin, type);
} 
static void user_key_2_handler_ppp(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("+++ 2 handler ppp:%d %d\n", pin, type);
}
static void user_key_3_handler_ppp(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("+++ 3 handler ppp:%d %d\n", pin, type);
}
static void user_key_4_handler_ppp(GPIO_Pin_e pin, IO_Wakeup_Pol_e type)
{
	LOG("+++ 4 handler ppp:%d %d\n", pin, type);
}

static void getPinState(){
	LOG("---------------------------------\n\n\n");
	LOG("P01:%d\n",hal_gpio_read(GPIO_P01));
	LOG("P02:%d\n",hal_gpio_read(GPIO_P02));
	LOG("P03:%d\n",hal_gpio_read(GPIO_P03));
	LOG("P04:%d\n",hal_gpio_read(GPIO_P04));
	LOG("P05:%d\n",hal_gpio_read(GPIO_P05));
	LOG("---------------------------------\n");
}

void test_adc_evt(adc_Evt_t* pev){
    int i = 0;
    LOG("test_adc_evt\n");
    if(pev->type == HAL_ADC_EVT_DATA){
        LOG("HAL_ADC_EVT_DATA\n");
    }
    // typedef struct _adc_Evt_t{
    //     int       type;
    //     adc_CH_t  ch;
    //     uint16_t* data;
    //     uint8_t   size; //word size
    // }adc_Evt_t;
    LOG("adc event type:%d ch:%d\n", pev->type, pev->ch);
    // 输出adc数据
    LOG("[adc data] size:%d value: ", pev->size);
    for(i = 0; i < pev->size; i++){
        LOG("%02x", pev->data[i]);
    }
    LOG("\n");
    uint16 adc_buf[6][64];
    osal_memcpy(adc_buf[pev->ch-2], pev->data, 2*(pev->size));


    // 输出adcbuf数据
    for(i = 0; i < 6; i++){
        LOG("adc_buf[%d]: ", i);
        for(int j = 0; j < 64; j++){
            LOG("%02x", adc_buf[i][j]);
        }
        LOG("\n");
    }

    float value = 0;
    static uint8_t channel_done_flag = 0;
    channel_done_flag |= BIT(pev->ch);
    for(i=2;i<8;i++)
    {
        if(channel_done_flag & BIT(i))
		{
        // is_high_resolution = (adc_cfg.is_high_resolution & BIT(i))?TRUE:FALSE;
            // is_differential_mode = (adc_cfg.is_differential_mode & BIT(i))?TRUE:FALSE;
            LOG("PEV: %d %d %d\n", i, pev->size, pev->data[0]);
            value = hal_adc_value_cal((adc_CH_t)i, adc_buf[i-2], pev->size, TRUE, FALSE);
            // 最终电压值 
            if(i<7)
            {
                LOG("P%d %d mv val: %d mv V: %d",(i+9),(int)(value*1000), (int)(value * 1000 * 4), (int)(value*1000) * 4 * 12);
                // 输出电压值 V 12倍 浮点数
                LOG("[BATT]: %dmV", (int)(value*1000) * 4 * 13);
            } else
            {
                LOG("P%d %d mv ",(20),(int)(value*1000));
            }
        }
    }	
    // getPinState();
}
void test_adc_read(){
   LOG("[test_adc_read] read Read Adc");
   hal_adc_init();
    GPIO_Pin_e controlPin = P34;
   GPIO_Pin_e adcPin = P14;
   adc_Cfg_t adc_cfg = {
        .channel = ADC_BIT(ADC_CH2P_P14),
        .is_continue_mode = FALSE,
        .is_differential_mode = FALSE,
        .is_high_resolution = TRUE,
    };
   
    // 注册adc
    hal_adc_config_channel(adc_cfg, test_adc_evt);
    LOG("hal_adc_config_channel end\n");
    hal_adc_start();
}


void appWristInit( uint8 task_id)
{
    AppWrist_TaskID = task_id;
	LOG("\n\n\nappWristInit\n\n\n");

    // Setup the GAP Peripheral Role Profile
    {
        uint8 initial_advertising_enable = TRUE;
        uint8 advChnMap = GAP_ADVCHAN_37 | GAP_ADVCHAN_38 | GAP_ADVCHAN_39; 

        // By setting this to zero, the device will go into the waiting state after
        // being discoverable for 30.72 second, and will not being advertising again
        // until the enabler is set back to TRUE
        uint16 gapRole_AdvertOffTime = 0;
        
        uint8 enable_update_request = DEFAULT_ENABLE_UPDATE_REQUEST;
        uint16 desired_min_interval = DEFAULT_DESIRED_MIN_CONN_INTERVAL;
        uint16 desired_max_interval = DEFAULT_DESIRED_MAX_CONN_INTERVAL;
        uint16 desired_slave_latency = DEFAULT_DESIRED_SLAVE_LATENCY;
        uint16 desired_conn_timeout = DEFAULT_DESIRED_CONN_TIMEOUT;
        uint8 peerPublicAddr[] = {
                0x01,
                0x02,
                0x03,
                0x04,
                0x05,
                0x06
            };

        GAPRole_SetParameter(GAPROLE_ADV_DIRECT_ADDR, sizeof(peerPublicAddr), peerPublicAddr);
        // set adv channel map
        GAPRole_SetParameter(GAPROLE_ADV_CHANNEL_MAP, sizeof(uint8), &advChnMap);        
        
        // Set the GAP Role Parameters
        GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &initial_advertising_enable );
        GAPRole_SetParameter( GAPROLE_ADVERT_OFF_TIME, sizeof( uint16 ), &gapRole_AdvertOffTime );
        
        GAPRole_SetParameter( GAPROLE_SCAN_RSP_DATA, sizeof ( scanData ), scanData );
        GAPRole_SetParameter( GAPROLE_ADVERT_DATA, sizeof( advertData ), advertData );
        
        GAPRole_SetParameter( GAPROLE_PARAM_UPDATE_ENABLE, sizeof( uint8 ), &enable_update_request );
        GAPRole_SetParameter( GAPROLE_MIN_CONN_INTERVAL, sizeof( uint16 ), &desired_min_interval );
        GAPRole_SetParameter( GAPROLE_MAX_CONN_INTERVAL, sizeof( uint16 ), &desired_max_interval );
        GAPRole_SetParameter( GAPROLE_SLAVE_LATENCY, sizeof( uint16 ), &desired_slave_latency );
        GAPRole_SetParameter( GAPROLE_TIMEOUT_MULTIPLIER, sizeof( uint16 ), &desired_conn_timeout );
    }

    // Set the GAP Characteristics
    GGS_SetParameter( GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName );


    // Set advertising interval
    {
        uint16 advInt = 400;   // actual time = advInt * 625us

        GAP_SetParamValue( TGAP_LIM_DISC_ADV_INT_MIN, advInt );
        GAP_SetParamValue( TGAP_LIM_DISC_ADV_INT_MAX, advInt );
        GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, advInt );
        GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, advInt );
    }

    // Initialize GATT attributes
    GGS_AddService( GATT_ALL_SERVICES );         // GAP
    GATTServApp_AddService( GATT_ALL_SERVICES ); // GATT attributes
    DevInfo_AddService( );
    ota_app_AddService();
    // 初始化蓝牙模块
    wristProfile_AddService(wristCB);

    app_datetime_init();

    // Setup a delayed profile startup
    osal_set_event( AppWrist_TaskID, START_DEVICE_EVT );
    // light_init(-1);
    LOG("appWristInit end\n");
    // 初始化按键
    // temp_set(5500, 0, NULL);
    LOG("temp_set end\n");
    // light_set(10, 0, NULL);
    LOG("appWristInit end\n");
    // test_adc_read();
    // 注册定时器. 持续读取数据
    // osal_start_reload_timer( AppWrist_TaskID, TIMER_LIGHT_EVT, 2000);
}

// 事件处理器
uint16 appWristProcEvt( uint8 task_id, uint16 events )
{
    if ( events & SYS_EVENT_MSG )
    {
        uint8 *pMsg;

        if ( (pMsg = osal_msg_receive( AppWrist_TaskID )) != NULL )
        {
        appWristProcOSALMsg( (osal_event_hdr_t *)pMsg );

        // Release the OSAL message
        VOID osal_msg_deallocate( pMsg );
        }

        // return unprocessed events
        return (events ^ SYS_EVENT_MSG);
    }

    if ( events & START_DEVICE_EVT )
    {
        // LOG("START_DEVICE_EVT\n");
        // Start the Device
        VOID GAPRole_StartDevice( &WristPeripheralCB );

        // Register with bond manager after starting device
    //    GAPBondMgr_Register( (gapBondCBs_t *) &WristBondCB );
        
        return ( events ^ START_DEVICE_EVT );
    }

    if ( events & TIMER_LIGHT_EVT )
    {
        LOG("TIMER_LIGHT_EVT\n");
        return ( events ^ TIMER_LIGHT_EVT );
    }
     return 0;
}