nrf51822 AT SIM868

使用Nordic的nrf52832进行主从机连接抓包分析 对nrf52832主从机连接过程中产生的数据包进行抓包分析,包括对空中数据包格式分析和主从机交互过程中SN和NESN变化分析。 阅读详情
/* Copyright (c) 2009 Nordic Semiconductor. All Rights Reserved.
 *
 * The information contained herein is property of Nordic Semiconductor ASA.
 * Terms and conditions of usage are described in detail in NORDIC
 * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
 *
 * Licensees are granted free, non-transferable use of the information. NO
 * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
 * the file.
 *
 */


/** @file
 * @defgroup uart_example_pca10000_main main.c
 * @{
 * @ingroup uart_example_pca10000
 *
 * @brief UART Example Application main file.
 *
 * This file contains the source code for a sample application using UART.
 *
 */


#include <stdbool.h>
#include <stdint.h>
#include "nrf_delay.h"
#include "nrf.h"
#include "simple_uart.h"
#include "nrf_gpio.h"
#include "boards.h"
#include "app_fifo.h"
#include "app_uart.h"
#include "compiler_abstraction.h"
#include "app_error.h"


//BLE
#include "softdevice_handler.h"
#include "ble.h"
#include "ble_bas.h"
#include "ble_hrs.h"
#include "ble_dis.h"
#include "ble_advdata.h"
#include "ble_srv_common.h"
//#include "device_manager.h"


#define IS_SRVC_CHANGED_CHARACT_PRESENT      0                                          /**< Include or not the service_changed characteristic. if not enabled, the server's database cannot be changed for the lifetime of the device*/
                                                                             
#define HR_INC_BUTTON_PIN_NO                 BUTTON_0                                   /**< Button used to increment heart rate. */
#define HR_DEC_BUTTON_PIN_NO                 BUTTON_1                                   /**< Button used to decrement heart rate. */
#define BOND_DELETE_ALL_BUTTON_ID            HR_DEC_BUTTON_PIN_NO                       /**< Button used for deleting all bonded centrals during startup. */


#define DEVICE_NAME                          "Nordic_HRM"                               /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME                    "NordicSemiconductor"                      /**< Manufacturer. Will be passed to Device Information Service. */
#define APP_ADV_INTERVAL                     40                                         /**< The advertising interval (in units of 0.625 ms. This value corresponds to 25 ms). */
#define APP_ADV_TIMEOUT_IN_SECONDS           180                                        /**< The advertising timeout in units of seconds. */


#define APP_TIMER_PRESCALER                  0                                          /**< Value of the RTC1 PRESCALER register. */
#define APP_TIMER_MAX_TIMERS                 5                                          /**< Maximum number of simultaneously created timers. */
#define APP_TIMER_OP_QUEUE_SIZE              5                                          /**< Size of timer operation queues. */


#define BATTERY_LEVEL_MEAS_INTERVAL          APP_TIMER_TICKS(2000, APP_TIMER_PRESCALER) /**< Battery level measurement interval (ticks). */


#define HEART_RATE_MEAS_INTERVAL             APP_TIMER_TICKS(1000, APP_TIMER_PRESCALER) /**< Heart rate measurement interval (ticks). */
#define MIN_HEART_RATE                       60                                         /**< Minimum heart rate as returned by the simulated measurement function. */
#define MAX_HEART_RATE                       300                                        /**< Maximum heart rate as returned by the simulated measurement function. */
#define HEART_RATE_CHANGE                    2                                          /**< Value by which the heart rate is incremented/decremented during button press. */


#define APP_GPIOTE_MAX_USERS                 1                                          /**< Maximum number of users of the GPIOTE handler. */


#define BUTTON_DETECTION_DELAY               APP_TIMER_TICKS(50, APP_TIMER_PRESCALER)   /**< Delay from a GPIOTE event until a button is reported as pushed (in number of timer ticks). */


#define MIN_CONN_INTERVAL                    MSEC_TO_UNITS(500, UNIT_1_25_MS)           /**< Minimum acceptable connection interval (0.5 seconds). */
#define MAX_CONN_INTERVAL                    MSEC_TO_UNITS(1000, UNIT_1_25_MS)          /**< Maximum acceptable connection interval (1 second). */
#define SLAVE_LATENCY                        0                                          /**< Slave latency. */
#define CONN_SUP_TIMEOUT                     MSEC_TO_UNITS(4000, UNIT_10_MS)            /**< Connection supervisory timeout (4 seconds). */


#define FIRST_CONN_PARAMS_UPDATE_DELAY       APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY        APP_TIMER_TICKS(30000, APP_TIMER_PRESCALER)/**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT         3                                          /**< Number of attempts before giving up the connection parameter negotiation. */


#define SEC_PARAM_TIMEOUT                    30                                         /**< Timeout for Pairing Request or Security Request (in seconds). */
#define SEC_PARAM_BOND                       1                                          /**< Perform bonding. */
#define SEC_PARAM_MITM                       0                                          /**< Man In The Middle protection not required. */
#define SEC_PARAM_IO_CAPABILITIES            BLE_GAP_IO_CAPS_NONE                       /**< No I/O capabilities. */
#define SEC_PARAM_OOB                        0                                          /**< Out Of Band data not available. */
#define SEC_PARAM_MIN_KEY_SIZE               7                                          /**< Minimum encryption key size. */
#define SEC_PARAM_MAX_KEY_SIZE               16                                         /**< Maximum encrypt*/




 
static ble_gap_adv_params_t                  m_adv_params;                              /**< Parameters to be passed to the stack when starting advertising. */
ble_bas_t                                    bas;                                       /**< Structure used to identify the battery service. */
static ble_hrs_t                             m_hrs;                                     /**< Structure used to identify the heart rate service. */
static volatile uint16_t                     m_cur_heart_rate;                          /**< Current heart rate value. */
                                                                                       
//static app_timer_id_t                        m_battery_timer_id;                        /**< Battery timer. */
//static app_timer_id_t                        m_heart_rate_timer_id;                     /**< Heart rate measurement timer. */
static bool                                  m_memory_access_in_progress = false;       /**< Flag to keep track of ongoing operations on persistent memory. */
//static dm_application_instance_t             m_app_handle;                              /**< Application identifier allocated by device manager */
static void ble_evt_dispatch(ble_evt_t * p_ble_evt);


static void sys_evt_dispatch(uint32_t sys_evt);












#define UART_TX_BUF_SIZE                256                                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE                256                                         /**< UART RX buffer size. */
#define LOG_RX_PIN_NUMBER               23
#define LOG_TX_PIN_NUMBER               24
#define MAX_DATA_LEN 500


static uint8_t uart_rx_data_array[MAX_DATA_LEN];
static uint8_t m_uart_rx_data_array[MAX_DATA_LEN];
static uint16_t m_uart_data_array_index;
static uint16_t mm_uart_data_array_index;


#define UNUSED_VARIABLE(X)  ((void)(X))
#define UNUSED_PARAMETER(X) UNUSED_VARIABLE(X)
#define UNUSED_RETURN_VALUE(X) UNUSED_VARIABLE(X)
uint8_t rx_cmd_data = 0;
volatile uint8_t  start_test_flag = 0;
void uart_event_handle(app_uart_evt_t * p_event)
{
    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
            UNUSED_VARIABLE(app_uart_get(&rx_cmd_data));
   m_uart_rx_data_array[mm_uart_data_array_index++] = rx_cmd_data;
if(m_uart_rx_data_array[mm_uart_data_array_index-8]=='A'&&m_uart_rx_data_array[mm_uart_data_array_index-7]=='T'&&m_uart_rx_data_array[mm_uart_data_array_index-2]=='T')
{
start_test_flag = m_uart_rx_data_array[mm_uart_data_array_index-1];
}
if(MAX_DATA_LEN==m_uart_data_array_index)
                    mm_uart_data_array_index = 0;
            break;
        case APP_UART_FIFO_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_code);
            break;


        default:
            break;
    }
}






static void m_uart_init(void)
{
    uint32_t                     err_code;
    const app_uart_comm_params_t comm_params =
    {
        LOG_RX_PIN_NUMBER,
        LOG_TX_PIN_NUMBER,
        RTS_PIN_NUMBER,
        CTS_PIN_NUMBER,
        APP_UART_FLOW_CONTROL_DISABLED,
        false,
        UART_BAUDRATE_BAUDRATE_Baud115200
    };


app_uart_close(0);

app_uart_flush();
nrf_delay_ms(2);
    APP_UART_FIFO_INIT( &comm_params,
                       UART_RX_BUF_SIZE,
                       UART_TX_BUF_SIZE,
                       uart_event_handle,
                       APP_IRQ_PRIORITY_LOW,
                       err_code);
    APP_ERROR_CHECK(err_code);
}


#define PCCTL_PIN                29
#define UART_TX_BUF_SIZE                256                                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE                256                                         /**< UART RX buffer size. */
#define GPRS_TX_PIN  4
#define GPRS_RX_PIN               5
#define GPRS_POWER_ON     nrf_gpio_cfg_output(PCCTL_PIN);nrf_gpio_pin_set(PCCTL_PIN)
#define GPRS_POWER_OFF nrf_gpio_pin_clear(PCCTL_PIN)
static uint8_t server[]       = "AT+CIPSTART=\"TCP\",\"14.215.177.38\",80\r\n";
uint8_t M_imsi[20]={0};
uint8_t M_imei[20]={0};
uint8_t M_csq[4]={0};
uint8_t TCP_CONNECT[20] = {0};




void gprs_event_handle(app_uart_evt_t * p_event)
{
uint8_t temp = 0;
    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
             app_uart_get(&temp);
             uart_rx_data_array[m_uart_data_array_index++] = temp;
             //m_data_array_index++
NRF_LOG_PRINTF("%c",temp);
             if(MAX_DATA_LEN==m_uart_data_array_index)
                    m_uart_data_array_index = 0;
            break;
        case APP_UART_FIFO_ERROR:
            APP_ERROR_HANDLER(p_event->data.error_code);
            break;


        default:
            break;
    }
}


static void m_gprs_init(void)
{
    uint32_t                     err_code;
    const app_uart_comm_params_t comm_params =
    {
        GPRS_RX_PIN,
        GPRS_TX_PIN,
        RTS_PIN_NUMBER,
        CTS_PIN_NUMBER,
        APP_UART_FLOW_CONTROL_DISABLED,
        false,
        UART_BAUDRATE_BAUDRATE_Baud115200
    };


app_uart_close(0);


app_uart_flush();
nrf_delay_ms(2);
    APP_UART_FIFO_INIT( &comm_params,
                       UART_RX_BUF_SIZE,
                       UART_TX_BUF_SIZE,
                       gprs_event_handle,
                       APP_IRQ_PRIORITY_LOW,
                       err_code);
    APP_ERROR_CHECK(err_code);
}


typedef uint32_t ret_code_t;
//typedef struct
//{
//    uint16_t        line_num;    /**< The line number where the error occurred. */
//    uint8_t const * p_file_name; /**< The file in which the error occurred. */
//    uint32_t        err_code;    /**< The error code representing the error that occurred. */
//} error_info_t;




  __weak void app_error_fault_handler(uint32_t id, uint32_t pc, uint32_t info);


void app_error_handler(ret_code_t error_code, uint32_t line_num, const uint8_t * p_file_name)
{
    error_info_t error_info =
    {
        .line_num    = line_num,
        .p_file_name = p_file_name,
        .err_code    = error_code,
    };
    app_error_fault_handler(0x00004000+1, 0, (uint32_t)(&error_info));


    UNUSED_VARIABLE(error_info);
}






void nrf_delay_ms(uint32_t volatile number_of_ms)
{
    while(number_of_ms != 0)
    {
        number_of_ms--;
        nrf_delay_us(999);
    }
}


void print_log(const uint8_t *pstring)
{
      while(*pstring)
      {
          while(app_uart_put(*pstring++) != NRF_SUCCESS);
            
      }
}


void clear_rx_buffer(uint8_t *buf,uint16_t *index)
{
      memset(buf,0,MAX_DATA_LEN);
      *index = 0;
}


void send_at_cmd(const uint8_t *pstring)
{
      while(*pstring)
      {
          while(app_uart_put(*pstring++) != NRF_SUCCESS);
            
      }


}


void get_IMSI()
{
clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);   
send_at_cmd("AT+CIMI\r\n");
nrf_delay_ms(2000);
memset(M_imsi,0,20);
memcpy(M_imsi,&uart_rx_data_array[10],15);
nrf_delay_ms(1000);
}




void get_IMEI()
{
clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);   
send_at_cmd("AT+GSN\r\n");
nrf_delay_ms(2000);
memset(M_imei,0,20);
memcpy(M_imei,&uart_rx_data_array[9],17);
nrf_delay_ms(1000);
}


void Wait_CREG(void)
{
uint8_t i = 0;
clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
while(i == 0)        
{
clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);       
send_at_cmd("AT+CGREG?\r\n");
nrf_delay_ms(2000);  


for(uint8_t k=0;k<m_uart_data_array_index;k++)      
{
 if(uart_rx_data_array[k] == ':')
 {
 if((uart_rx_data_array[k+4] == '1')||(uart_rx_data_array[k+4] == '5'))
 {
 i = 1;
 //UART1_SendLR();
 break;
 }
 }
}
     }
}


void check_csq()
{
uint8_t i = 0;
clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
while(i == 0)        
{
clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
nrf_delay_ms(2000); 
send_at_cmd("AT+CSQ\r\n");
nrf_delay_ms(2000);  


for(uint8_t k=0;k<m_uart_data_array_index;k++)      
{
 if(uart_rx_data_array[k] == ':')
 {
memcpy(M_csq,&uart_rx_data_array[k+2],2);
// M_csq[0]=uart_rx_data_array[k+2];
// M_csq[1]=uart_rx_data_array[k+3];
// M_csq[2]='\0';
if(M_csq[1]==',')M_csq[1]='\0';
if(atoi((char*)M_csq)>=16)
//  if(((uart_rx_data_array[k+2] == '1')&&(uart_rx_data_array[k+3] >= '6'))||(uart_rx_data_array[k+2] >= '2'))
 {
 i = 1;
 //UART1_SendLR();
 break;
 }
 }
}
     }
}


bool find(uint8_t *s)
{

if(strstr((char*)uart_rx_data_array,(char*)s)!=NULL)
return true;


else
return false;
}


void AT_CMD_Handler(uint8_t *p_atcmd,uint8_t *s,uint32_t wait_time)
{
int i = 0;
      bool pass = false;
      clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
      while(!pass)
      {
          if(!find(s))
          {
                clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
                send_at_cmd(p_atcmd);
                nrf_delay_ms(wait_time);
for(int k = 0;k < 50 ; k++){
if(uart_rx_data_array[k] == 'E' && uart_rx_data_array[k+1] == 'R' ){
goto error;
}
if(uart_rx_data_array[k] == 'e' && uart_rx_data_array[k+1] == 'r'){
goto error;
}
}
if(i > 20){
goto error;
}
          }
          else
          {
                pass = true;
          }

i++;
          
      }


if(!pass){
error:
m_uart_init();
print_log("error");
nrf_delay_ms(100);
print_log("\r\n");
m_gprs_init();
return ;
}
     // clear_rx_buffer();
}




void AT_CMD_Handler2(uint8_t *p_atcmd,uint8_t *s,uint32_t wait_time)
{

int i = 0;
      bool pass = false;
      clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
      while(!pass)
      {

          if(!find(s))
          {
                clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
                send_at_cmd(p_atcmd);
                nrf_delay_ms(wait_time);




//
// if(uart_rx_data_array[k] == 'E' && uart_rx_data_array[k+1] == 'R' ){
//
// goto error;
// }
//
if(uart_rx_data_array[16] == 'O' && uart_rx_data_array[17] == 'K' ){

return ;
}


if(i > 20){

goto error;

}

          }
          else
          {
                pass = true;
          }

i++;
          
      }


if(!pass){
error:
m_uart_init();
print_log("error");
nrf_delay_ms(100);
print_log("\r\n");
m_gprs_init();
return ;
}
     // clear_rx_buffer();
}




void AT_CMD_Handler1(uint8_t *p_atcmd,uint8_t *s,uint32_t wait_time)
{

int i = 0;
      bool pass = false;
      clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);


      while(!pass)
      {
          if(!find(s))
          {
                clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);
                send_at_cmd(p_atcmd);
                nrf_delay_ms(wait_time);


for(int k = 0;k < 50 ; k++){

if(uart_rx_data_array[k] == 'E' && uart_rx_data_array[k+1] == 'R' ){

goto error;
}

}

if(i > 20){

goto error;

}




          }
          else
          {
if(uart_rx_data_array[23] == '1'){

m_uart_init();
print_log("GNSS Link OK");
nrf_delay_ms(100);
print_log("\r\n");
m_gprs_init();

}else{

m_uart_init();
print_log("GNSS Link error");
nrf_delay_ms(100);
print_log("\r\n");
m_gprs_init();


}
if(uart_rx_data_array[25] == '1'){

m_uart_init();
print_log("Location OK");
nrf_delay_ms(100);
print_log("\r\n");
m_gprs_init();

}else{

m_uart_init();
print_log("Location error");
nrf_delay_ms(100);
print_log("\r\n");
m_gprs_init();


}


                pass = true;
          }

i++;
          
      }


if(!pass){
error:
m_uart_init();
print_log("error");
nrf_delay_ms(100);
print_log("\r\n");
m_gprs_init();
return ;
}
     // clear_rx_buffer();
}








void Get_LocalIP()
{
        //uint8_t i = 0;
        clear_rx_buffer(uart_rx_data_array,&m_uart_data_array_index);      
        send_at_cmd("AT+CIFSR\r\n");
        nrf_delay_ms(2000);  
}


//void connect_server(void)
//{  
//// AT_CMD_Handler("ATE1\r\n","OK",1000);
////
//// AT_CMD_Handler("AT+CIPSHUT\r\n","SHUT OK",1000);
//// AT_CMD_Handler("AT+CGATT=1\r\n","OK",1000);
// AT_CMD_Handler("AT+CGATT?\r\n","+CGATT: 1",1000);
// AT_CMD_Handler("AT+CSTT = \"CMNET\"\r\n","OK",2000);
// AT_CMD_Handler("AT+CIICR\r\n","OK",2000);
// Get_LocalIP();
//
// //AT_CMD_Handler("AT+CIPCSGP=1,\"CMNET\"","OK",2);
// AT_CMD_Handler("AT+CSTT\r\n","OK",2000);
// AT_CMD_Handler("AT+CIICR\r\n","OK",2000);
// //AT_CMD_Handler("AT+CGATT?\r\n","OK",2);
//    Get_LocalIP();
// AT_CMD_Handler("AT+CIPHEAD=1\r\n","OK",1000);
// AT_CMD_Handler(server,"CONNECT OK",4000);
// AT_CMD_Handler("AT+CIPSHUT\r\n","SHUT OK",1000);
//// AT_CMD_Handler("AT+CIPSEND\r\n",">",2000);
//}




void connect_server(void)
{  
AT_CMD_Handler("ATE1\r\n","OK",1000);

AT_CMD_Handler("AT+CIPSHUT\r\n","SHUT OK",1000);
AT_CMD_Handler("AT+CGATT=1\r\n","OK",1000);
AT_CMD_Handler("AT+CGATT?\r\n","+CGATT: 1",1000);
//AT_CMD_Handler("AT+CIPCSGP=1,\"CMNET\"","OK",2);
AT_CMD_Handler("AT+CSTT\r\n","OK",2000);
AT_CMD_Handler("AT+CIICR\r\n","OK",2000);
//AT_CMD_Handler("AT+CGATT?\r\n","OK",2);
    Get_LocalIP();
AT_CMD_Handler("AT+CIPHEAD=1\r\n","OK",1000);
AT_CMD_Handler(server,"CONNECT OK",4000);
memcpy(TCP_CONNECT,&uart_rx_data_array[45],15);
nrf_delay_ms(10);
AT_CMD_Handler("AT+CIPSHUT\r\n","SHUT OK",1000);
// AT_CMD_Handler("AT+CIPSEND\r\n",">",2000);
}






void GPS_server(void)
{  
// AT_CMD_Handler("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"\r\n","OK",1000);
// AT_CMD_Handler("AT+SAPBR=3,1,\"APN\",\"3GNET\"\r\n","OK",1000);
// AT_CMD_Handler("AT+SAPBR=1,1\r\n","OK",1000);
// AT_CMD_Handler("AT+SAPBR=2,1\r\n","OK",1000);
//
// AT_CMD_Handler("AT+CNTPCID=1\r\n","OK",1000);
// AT_CMD_Handler("AT+CNTP?\r\n","OK",1000);


// AT_CMD_Handler("AT+CNTP\r\n","OK",1000);
// AT_CMD_Handler("AT+CCLK?\r\n","OK",1000);
// AT_CMD_Handler("AT+CLBS=1,1\r\n","OK",1000);
//
// AT_CMD_Handler("AT+FTPSERV=\"116.247.119.165\"\r\n","OK",1000);
// AT_CMD_Handler("AT+FTPUN=\"customer\"\r\n","OK",1000);
// AT_CMD_Handler("AT+FTPPW=\"111111\"\r\n","OK",1000);
// AT_CMD_Handler("AT+FTPGETNAME=\"MTK3.EPO\"\r\n","OK",1000);
// AT_CMD_Handler("AT+FTPGETPATH=\"/\"\r\n","OK",1000);
// AT_CMD_Handler("AT+FTPEXTGET=1\r\n","OK",1000);
// AT_CMD_Handler("AT+FTPEXTGET=4,\"epo\"\r\n","OK",3000);
// AT_CMD_Handler("AT+FSLS=C:\\User\\\r\n","OK",1000);
// AT_CMD_Handler("AT+CGNSCHK=3,1\r\n","OK",1000);
// AT_CMD_Handler("AT+CGNSPWR=1\r\n","OK",1000);
//
// AT_CMD_Handler("AT+CGNSAID=31,1,1\r\n","+CGNSAID: OK",1000);
// AT_CMD_Handler("AT+CGNSINF\r\n","1,1,20",2000);

AT_CMD_Handler2("AT+CGNSPWR=1\r\n","OK",1000);
AT_CMD_Handler1("AT+CGNSINF\r\n","+CGNSINF: 1,",1000);
}








void gprs_test()
{
uint32_t err_code;
GPRS_POWER_ON;
nrf_delay_ms(2000);

m_gprs_init();
nrf_delay_ms(1000);
// Wait_CREG();
get_IMEI();
m_uart_init();
nrf_delay_ms(100);
print_log("IMEI = ");
print_log(M_imei);
print_log("\r\n");
nrf_delay_ms(100);

m_gprs_init();
get_IMSI();
m_uart_init();
nrf_delay_ms(100);
print_log("IMSI = ");
print_log(M_imsi);
print_log("\r\n");
nrf_delay_ms(50);


m_gprs_init();
check_csq();
m_uart_init();
nrf_delay_ms(100);
print_log("CSQ = ");
print_log(M_csq);
print_log("\r\n");
nrf_delay_ms(100);

  m_gprs_init();
connect_server();
m_uart_init();
nrf_delay_ms(100);
print_log(TCP_CONNECT);
// print_log("\r\n");
nrf_delay_ms(100);

m_gprs_init();
nrf_delay_ms(1000);
GPS_server();
// gps_flag = true;

}




void uart_disable (void)
{
    NRF_UART0->ENABLE = (UART_ENABLE_ENABLE_Disabled << UART_ENABLE_ENABLE_Pos);
    NRF_UART0->TASKS_STOPTX = 1;
    NRF_UART0->TASKS_STOPRX = 1;
    NRF_UART0->POWER = 0;
}




static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
{
//    dm_ble_evt_handler(p_ble_evt);
    ble_hrs_on_ble_evt(&m_hrs, p_ble_evt);
    ble_bas_on_ble_evt(&bas, p_ble_evt);
    ble_conn_params_on_ble_evt(p_ble_evt);
//    on_ble_evt(p_ble_evt);
}


static void sys_evt_dispatch(uint32_t sys_evt)
{
    pstorage_sys_event_handler(sys_evt);
//    on_sys_evt(sys_evt);
}


static void ble_stack_init(void)
{
    uint32_t err_code;
    
    // Initialize the SoftDevice handler module.
    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);


    // Enable BLE stack 
    ble_enable_params_t ble_enable_params;
    memset(&ble_enable_params, 0, sizeof(ble_enable_params));
    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
    err_code = sd_ble_enable(&ble_enable_params);
    APP_ERROR_CHECK(err_code);


    // Register with the SoftDevice handler module for BLE events.
    err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
    APP_ERROR_CHECK(err_code);
    
    // Register with the SoftDevice handler module for BLE events.
    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
    APP_ERROR_CHECK(err_code);
}




static void gap_params_init(void)
{
    uint32_t                err_code;
    ble_gap_conn_params_t   gap_conn_params;
    ble_gap_conn_sec_mode_t sec_mode;


    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);


    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);


    err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_HEART_RATE_SENSOR_HEART_RATE_BELT);
    APP_ERROR_CHECK(err_code);


    memset(&gap_conn_params, 0, sizeof(gap_conn_params));


    gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
    gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
    gap_conn_params.slave_latency     = SLAVE_LATENCY;
    gap_conn_params.conn_sup_timeout  = CONN_SUP_TIMEOUT;


    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}




static void advertising_init(void)
{
    uint32_t      err_code;
    ble_advdata_t advdata;
    uint8_t       flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;


    ble_uuid_t adv_uuids[] =
    {
        {BLE_UUID_HEART_RATE_SERVICE,         BLE_UUID_TYPE_BLE},
        {BLE_UUID_BATTERY_SERVICE,            BLE_UUID_TYPE_BLE},
        {BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE}
    };


    // Build and set advertising data.
    memset(&advdata, 0, sizeof(advdata));


    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = true;
    advdata.flags.size              = sizeof(flags);
    advdata.flags.p_data            = &flags;
    advdata.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
    advdata.uuids_complete.p_uuids  = adv_uuids;


    err_code = ble_advdata_set(&advdata, NULL);
    APP_ERROR_CHECK(err_code);


    // Initialize advertising parameters (used when starting advertising).
    memset(&m_adv_params, 0, sizeof(m_adv_params));


    m_adv_params.type        = BLE_GAP_ADV_TYPE_ADV_IND;
    m_adv_params.p_peer_addr = NULL;                           // Undirected advertisement.
    m_adv_params.fp          = BLE_GAP_ADV_FP_ANY;
    m_adv_params.interval    = APP_ADV_INTERVAL;
    m_adv_params.timeout     = APP_ADV_TIMEOUT_IN_SECONDS;
}


static void services_init(void)
{
    uint32_t       err_code;
    ble_hrs_init_t hrs_init;
    ble_bas_init_t bas_init;
    ble_dis_init_t dis_init;
    uint8_t        body_sensor_location;


    // Initialize Heart Rate Service.
    body_sensor_location = BLE_HRS_BODY_SENSOR_LOCATION_FINGER;


    memset(&hrs_init, 0, sizeof(hrs_init));


    hrs_init.is_sensor_contact_supported = false;
    hrs_init.p_body_sensor_location      = &body_sensor_location;


    // Here the sec level for the Heart Rate Service can be changed/increased.
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&hrs_init.hrs_hrm_attr_md.cccd_write_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&hrs_init.hrs_hrm_attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&hrs_init.hrs_hrm_attr_md.write_perm);


    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&hrs_init.hrs_bsl_attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&hrs_init.hrs_bsl_attr_md.write_perm);


    err_code = ble_hrs_init(&m_hrs, &hrs_init);
    APP_ERROR_CHECK(err_code);


    // Initialize Battery Service.
    memset(&bas_init, 0, sizeof(bas_init));


    // Here the sec level for the Battery Service can be changed/increased.
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.cccd_write_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_char_attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&bas_init.battery_level_char_attr_md.write_perm);


    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&bas_init.battery_level_report_read_perm);


    bas_init.evt_handler          = NULL;
    bas_init.support_notification = true;
    bas_init.p_report_ref         = NULL;
    bas_init.initial_batt_level   = 100;


    err_code = ble_bas_init(&bas, &bas_init);
    APP_ERROR_CHECK(err_code);


    // Initialize Device Information Service
    memset(&dis_init, 0, sizeof(dis_init));


    ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, MANUFACTURER_NAME);


    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&dis_init.dis_attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&dis_init.dis_attr_md.write_perm);


    err_code = ble_dis_init(&dis_init);
    APP_ERROR_CHECK(err_code);
}




static void advertising_start(void)
{
    uint32_t err_code;


    err_code = sd_ble_gap_adv_start(&m_adv_params);
    APP_ERROR_CHECK(err_code);


//    led_start();
}






int main(void)
{


ble_stack_init();
  gap_params_init();
  advertising_init();
  services_init();

advertising_start();


// nrf_gpio_cfg_output(27);
// nrf_gpio_cfg_input(28, NRF_GPIO_PIN_PULLDOWN);
// nrf_gpio_cfg_sense_input(28, NRF_GPIO_PIN_PULLUP, NRF_GPIO_PIN_SENSE_LOW );
//
// gprs_test();
//
// m_uart_init();
// print_log("\r\n");
// print_log("GPS test STOP!\r\n");
// nrf_delay_ms(100);
//
//
// GPRS_POWER_OFF;
// uart_disable();
//
// nrf_gpio_cfg_output(2);
//// nrf_gpio_pin_set(2);
//// nrf_gpio_pin_write(2, 1);
//
// nrf_gpio_pin_clear(23);
// nrf_gpio_pin_clear(24);
// nrf_gpio_pin_clear(4);
// nrf_gpio_pin_clear(5);
//
//// nrf_gpio_pin_clear(2);
//




// nrf_gpio_cfg_input(2,  NRF_GPIO_PIN_PULLUP );
//
// nrf_gpio_cfg_input(23, NRF_GPIO_PIN_PULLDOWN);
// nrf_gpio_cfg_input(24, NRF_GPIO_PIN_PULLDOWN);
// nrf_gpio_cfg_input(4, NRF_GPIO_PIN_PULLDOWN);
// nrf_gpio_cfg_input(5, NRF_GPIO_PIN_PULLDOWN);
//
// nrf_gpio_cfg_input(29, NRF_GPIO_PIN_PULLDOWN);
//
//
//
// NRF_POWER->RAMON = POWER_RAMON_ONRAM0_RAM0On << POWER_RAMON_ONRAM0_Pos


//| POWER_RAMON_ONRAM1_RAM1On << POWER_RAMON_ONRAM1_Pos


//| POWER_RAMON_OFFRAM0_RAM0Off << POWER_RAMON_OFFRAM0_Pos


//| POWER_RAMON_OFFRAM1_RAM1Off << POWER_RAMON_OFFRAM1_Pos;




//while(1){


//NRF_POWER->SYSTEMOFF = 1;




//}




while(1){


}



}


bool find(uint8_t *s)
{

if(strstr((char*)uart_rx_data_array,(char*)s)!=NULL)
return true;


else
return false;
}




/**
 *@}
 **/
如何实现BLE 最大数据吞吐率并满足设计功耗要求? 我们开发BLE 设备多数都有两点要求:一是低功耗,电池供电需要持续工作数周甚至数个月;二是将BLE peripheral 产生的数据快速传送给central,传输数据功耗较高,提高传输速率缩短传输时间也有利于降低平均功耗。我们该如何设置广播参数与连接参数以达到我们要求的功耗呢?该如何设置连接参数与报文长度(PDU / MTU)以尽可能达到最大传输速率呢? 阅读详情

相关推荐

浅析NRF51822回调函数

C语言回调函数–初识回调函数 回调函数简介:   回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应。    回调运行机制 1、定义一个回调函数; 2、提供函数实现的一方在初始化的时候,...

qq_43572158的博客 936

nrf51822 --- 动态修改连接间隔

1.目的     在蓝牙连接上的时候动态修改连接间隔,已达到功耗平衡 2.分析    在实际应用的时候,有时候需要发送数据快一点,这个时候我们可以把连接间隔改小一点,这样发送数据快,但是功耗大,当把数据发完的时候,可把连接间隔改小一点,这样可以降低功耗,达到一个均衡.比如穿戴设备连接上的时候,可能需要快速把本地数据发给手机,这个时候就可以把连接间隔设置小点。传送完毕后间隔设置大点。这样功耗就

a369000753的博客 4768

NRF51822开发笔记-6.nRF51822裸机实验按键输入控制LED输出

NRF51822开发笔记-6.nRF51822裸机实验按键输入控制LED输出一、设计思路二、程序代码三、总结单个GPIO输入配置函数多个GPIO输入配置函数 一、设计思路 用一个按键控制LED0和LED1的轮询点亮 按键选择K1对应GPIO_16 LED0和LED1和之前实验一直,GPIO18和GPIO19 二、程序代码 1.初始化输入输出的GPIO 2.定义2个状态变量 3.while主循环...

硬件咖 476

nrf51822蓝牙学习笔记三

初始化流程代码、蓝牙流程、服务具体讲解

Moliam的博客 4176

实验六 存储器实验

只读存储器(ROM)是一种在正常工作时其存储的数据固定不变,其中的数据只能读出,不能写入,即使断电也能够保留数据,要想在只读存储器中存入或改变数据,必须具备特定的条件。当地址为00000101时,会分别在数据位宽为8,16,32的只读寄存器中找到地址为00000101所对应的十进制地址位置,也就是地址为5的数据,并将其分别以8位,16位,32位输出。因此,输出保持为0。因此,当异步清零信号为1时,无论其他输入信号是什么,触发器的输出都会被强制清零,输出为0。1)寄存器输入0011,使能端1,异步清零0。

wenmou1111的博客 3008

10X Genomics数据实战:手把手教你用Seurat处理单细胞PBMC数据(附完整代码)

本文详细介绍了如何使用Seurat处理10X Genomics的单细胞PBMC数据,从数据获取、质控到降维分析和细胞分群的全流程。通过实战代码演示,帮助研究者掌握单细胞RNA测序数据分析的核心技术,提升对细胞异质性的理解。

weixin_29053577的博客 257

nRF52832-Bluefruit52学习之蓝牙BLE开发(2)-- 蓝牙BLE主函数分析

nRF52832技术交流群:680723714 nRF52832-Bluefruit52核心板详细介绍: https://blog.youkuaiyun.com/solar_Lan/article/details/88688451 蓝牙 BLE 之主函数分析 工程...

solar_Lan的博客 8502

ROS自定义地图实战:从CAD到导航的完整流程

本文详细介绍了如何将CAD图纸或手绘草图高效转换为ROS机器人可直接使用的导航地图。通过解析PGM与YAML标准格式,提供从图像处理、尺度校准到集成AMCL与move_base导航栈的完整实战流程,帮助开发者跳过繁琐的SLAM建图,实现快速、精准的自定义地图部署。

weixin_29083475的博客 498

NRF51822 小黄车智能锁 逆向工程

笔者在夜跑时发现有人将拆下的小黄车智能锁丢弃在花园角落,于是萌生了拆解的想法。 拆开外壳后发现MCU是NRF51822 ,并且预留了Jlink调试接口,更萌生了逆向这个电路板的想法 下面是各个智能锁厂家提供的方案: 摩拜单车:STM32F1+GSM+GPS 使用芯片STM32F401 + NRF51802(BLE)+TD1030泰斗定位芯片+BQ25895(充电管理)+C3Hx(三轴传感器)+SIM800 Hellobike 使用MT2503联发科集成方案 MT2503 +25LQ12...

u013443294的博客 1263

反应动力学仿真软件:ChemkinPro_(11).敏感性分析

敏感性分析是化学反应动力学仿真中的一项重要技术,通过对模型参数的变化对模型输出的影响进行评估,可以帮助研究人员优化模型、验证实验数据和评估不确定性。ChemkinPro 提供了强大的敏感性分析功能,可以方便地进行参数选择、仿真设置和结果解读。通过实际案例研究,我们可以看到敏感性分析在燃烧、催化和环境化学等领域的广泛应用,为科学研究和工程应用提供了有力支持。

kkchenjj的博客 1312

Codex 实战 Skills:用 Skill 自动识别并提取 PDF/图片表格数据,效率提升 10 倍

本文介绍如何构建一个多模态文件解析 Skill,用于自动识别和提取 PDF/图片中的表格数据,提升 AI 智能体处理非结构化文档的效率。文章分析了传统方法的局限性,提出分层解析架构(预处理、检测、提取推理、后处理),推荐技术栈包括 pdfplumber、OpenCV 和多模态大模型。详细说明了 Skill 的元数据定义、数据模型设计(使用 Pydantic)和核心实现流程,通过混合策略实现从复杂文档到结构化 JSON/Markdown 的转换,使 AI 代理具备"阅读"多模态文档的能力。

yueyeguzhuo的专栏 313

nrf52840实现蓝牙BLE基本功能

nrf52840实现蓝牙BLE基本功能

m0_73231851的博客 1509

001、专栏导论:为什么我们需要MLIR与算子中间表示

五年前,大家还在争论“TVM还是XLA”。现在回头看,TVM的Relay IR和XLA的HLO都是特定领域的IR,它们解决了各自的问题,但缺乏通用性。MLIR的出现,本质上是因为硬件异构化已经到了一个临界点——CPU、GPU、NPU、DSP、FPGA,每个硬件都有自己的指令集和内存层次,没有一个统一的IR能同时高效表达所有硬件的计算模式。MLIR的“方言+渐进式lowering”模式,恰好提供了这种灵活性。你可以为每个硬件定制一套方言,然后共享公共的lowering路径。

Jack010169的博客 490

BLE-NRF51822教程4-串口BLE解析

本讲逐行代码解析官方串口BLE例程demo PS: 基于SDK5.1   主要分一下几个部分: 1 :Main函数的整体注释 2 :函数单独解析。 3 :接收串口数据并发送给对端设备 4 :接收手机数据并通过串口打印   Ps :第一和第二部分我在教程工程初始化流程中已经详细说明这里直接复制过来,做了一些修改以及添加了关于添加服务和添加特征值的讲解,如果之前看过可以直接看下 2函

技术无止境 7863

智能车浅谈 电磁组——环岛处理

第十七届全国大学生智能车电磁四轮部分经验分享

qq_41954556的博客 1万+

【NLP】第十章:位置编码Positional Encoding

前面讲RNN时一般都会有一个ht的输出,这个输出就是样本与样本之间的信息,而且RNN是时序循环的,所以RNN本身的结构,在物理上,就自带词的前后顺序信息的。比如词never,不管never本身的词向量是什么,只要你在序列中排第一个位置,你的位置向量就是[0,1,01],你排第三个位置,你的位置向量就是[0.9,-0,4,0.2,1.0]。也所以,你可以理解为:embedding后的词嵌入,PE按照每个样本在sequence中的位置,把embedding后的词嵌入给扭转后,才送入attention的。

因为热爱所以坚持 1918

二、nrf52832的蓝牙工程模板

蓝牙 1.nrf52832的蓝牙程序结构 1.配置log日志 2.配置APP定时器 (使用的是rtc1的软件定时器) 3.电源管理模块初始化 4.蓝牙协议栈初始化 5.GATT和GAP初始化 6.广播初始化 7.服务初始化 8.配置连接参数 9.开启广播 10.启动连接 蓝牙示例程序 相关资料可以参考官方sdk文件(头文件较多,建议直接使用官方例程修改) 1.文件路径:examples\ble_peripheral\ble

weixin_45823077的博客 893

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

从零开始的nrf52832蓝牙开发(9)--连接参数与MTU

1.连接参数更新 注意,连接参数一开始是主机设置的,连接参数更新是从机发起,主机决定要不要更改成从机请求的参数。 1.1主机端 很简单,只需要在蓝牙事件回调中添加,当从机请求更新连接参数,更新为从机发过来的参数即可: 1.2从机端 从机端如何发起连接参数更新? 只要使用 ble_conn_params_init 这个函数设置了连接参数,从机会在连接后自动发起连接参数更新。但是注意,这个函数内使用了nrf的定时器,所以必须先要初始化定时器: 其次,就是调用 ble_conn_para

飞临云的博客 3259

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

nrf51822程序的分析(二)

这部分接上一部分主要分析了NRF51822蓝牙协议栈中的一些代码

忧愁的awe的博客 2658

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

BLE-NRF51822教程2-工程初始化流程

代码讲解基于资料包里配套的 sdk5.1版本中的串口demo。高版本的sdk基本都是差不多的。 代码在路径xxxxx\keil\ARM\Device\Nordic\nrf51822\Board\pca10001\s110\experimental中 一:main函数整体注释: int main(void) { //初始化LED指示灯,用来指示广播和连接状态 leds_init(); ...

飞天鱼 924

[嵌入式框架][nrf51822][SDK12.3] BLE分层设计 DFU OTA 透传(NUS) 电量 设备信息 BLE_HID

简化后只有700+,仅保留协议栈事件处理,白名单,对等管理器,连接状态。目的使其减轻头文件定义,业务功能调整。三、 参数统一头文件管理。

嵌入式单片机实验室 1079

nRF51822定时器设置

一、nRF51822的时钟系统 nRF51822有两种时钟源:1、高频时钟HFCLK;2、低频时钟LFCLK。这两种时钟只有当系统处于System ON模式的情况下才可用。 低频时钟源 系统有三种低频时钟源:1、32.768kHz晶体振荡器;2、32.768kHz RC振荡器;3、32.768kHz合成时钟(从HFCLK合成的32.768kHz时钟)

jet007_007的博客 1万+

BLE 参数设置记录

APP_ADV_INTERVAL:广播间隔 APP_ADV_TIMEOUT_IN_SECONDS:广播超时时间,超时后会产生消息BLE_GAP_EVT_TIMEOUT。当其为0时,没有超时时间 advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE时有用 BLE_GAP_ADV_FLAGS_LE_ONLY_LIMIT

fhh20061362的专栏 1952

NRF51822蓝牙初学笔记1.2之广播

1.1、蓝牙的广播在蓝牙开发中占有重要地位,广播频率直接影响到功耗问题和连接快慢,传输数据的快慢问题。现在来看一下广播的初始化。 下面那是源码 : static void advertising_init(void) { uint32_t err_code; ble_advdata_t advdata; ble_adv_mode...

一头小笨驴的博客 1787

nrf51822蓝牙笔记之连接参数更新

The Peripheral Preferred Connection Parameters (ppcp) contains e.g. the MIN_CONN_INTERVAL and MAX_CONN_INTERVAL values which is set into the GAP service with call to functionsd_ble_gap_ppcp_set(). If

一颗偏执的心 6296
上一篇: nrf51822配对请求
下一篇: NRF51822 CAN MCP2515 MCP2562
kernel_my
博客等级 码龄11年 7粉丝 4原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值