Hello: I used analog IIC write MPU6050. Again after power download programs, mpu6050 can run up there ACK response. But the debug will not run. Simulation IIC because no ACK response. It has been waiting for ACK. I do not know what it is? Then I replaced twi_hw_master.c can run, you can debug. However, Bluetooth does not run? These issues weird? Hope to get your help. The following code analog IIC , #include "board.h" #include "lcd.h" #include "i2c.h"
#define false 0 #define true 1
#define SCL_GPIO_PIN 24 #define SDA_GPIO_PIN 25
#define SCL_H do { NRF_GPIO->OUTSET = (1UL << SCL_GPIO_PIN); } while(0) /*!< Pulls SCL line high / #define SCL_L do { NRF_GPIO->OUTCLR = (1UL << SCL_GPIO_PIN); } while(0) /!< Pulls SCL line low / #define SDA_H do { NRF_GPIO->OUTSET = (1UL << SDA_GPIO_PIN); } while(0) /!< Pulls SDA line high / #define SDA_L do { NRF_GPIO->OUTCLR = (1UL << SDA_GPIO_PIN); } while(0) /!< Pulls SDA line low / #define SDA_INPUT do { NRF_GPIO->DIRCLR = (1UL << SDA_GPIO_PIN); } while(0) /!< Configures SDA pin as input / #define SDA_OUTPUT do { NRF_GPIO->DIRSET = (1UL << SDA_GPIO_PIN); } while(0) /!< Configures SDA pin as output / #define SCL_OUTPUT do { NRF_GPIO->DIRSET = (1UL << SCL_GPIO_PIN); } while(0) /!< Configures SCL pin as output */
/*lint -e415 -e845 -save "Out of bounds access" /
#define TWI_SDA_STANDARD0_NODRIVE1() do {
NRF_GPIO->PIN_CNF[SDA_GPIO_PIN] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)
|(GPIO_PIN_CNF_DRIVE_S0H1 << GPIO_PIN_CNF_DRIVE_Pos)
|(GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos)
|(GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos)
|(GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos);
} while (0) /!< Configures SDA pin to Standard-0, No-drive 1 */
#define TWI_SCL_STANDARD0_NODRIVE1() do {
NRF_GPIO->PIN_CNF[SCL_GPIO_PIN] = (GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos)
|(GPIO_PIN_CNF_DRIVE_S0H1 << GPIO_PIN_CNF_DRIVE_Pos)
|(GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos)
|(GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos)
|(GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos);
} while (0) /*!< Configures SCL pin to Standard-0, No-drive 1 */
#define SDA_read ((NRF_GPIO->IN >> SDA_GPIO_PIN) & 0x1UL) /*!< Reads current state of SDA / #define SCL_read ((NRF_GPIO->IN >> SCL_GPIO_PIN) & 0x1UL) /!< Reads current state of SCL */
static void I2C_delay(void) { unsigned char i = 20; while (i) i--; }
static int32_t I2C_Start(void) { SDA_H; I2C_delay(); SCL_H; I2C_delay(); SDA_L; I2C_delay(); SCL_L; I2C_delay(); }
static void I2C_Stop(void) { SCL_L; I2C_delay(); SDA_L; I2C_delay(); SCL_H; I2C_delay(); SDA_H; I2C_delay(); }
static void I2C_Ack(void) { SCL_L; I2C_delay(); SDA_L; I2C_delay(); SCL_H; I2C_delay(); SCL_L; I2C_delay(); }
static void I2C_NoAck(void) { SCL_L; I2C_delay(); SDA_H; I2C_delay(); SCL_H; I2C_delay(); SCL_L; I2C_delay(); }
static int32_t I2C_WaitAck(void) { SCL_L; I2C_delay(); SDA_INPUT; I2C_delay(); SCL_H;
I2C_delay();
if (SDA_read) {
SCL_L;
SDA_OUTPUT;
return false;
}
SCL_L;
SDA_OUTPUT;
I2C_delay();
return true;
}
static void I2C_SendByte(uint8_t byte) { uint8_t i = 8; while (i--) { SCL_L; I2C_delay(); if (byte & 0x80) { SDA_H; SDA_OUTPUT; } else { SDA_L; SDA_OUTPUT; } byte <<= 1; I2C_delay(); SCL_H; I2C_delay(); } SCL_L; }
static uint8_t I2C_ReceiveByte(void) { uint8_t i = 8; uint8_t byte = 0; SDA_H; I2C_delay(); SDA_INPUT; I2C_delay(); while (i--) { byte <<= 1; SCL_L; I2C_delay(); SCL_H; I2C_delay(); if (SDA_read) { byte |= 0x01; } } SCL_L; SDA_OUTPUT; return byte; }
void i2cInit(void) {
}
int32_t i2cWriteBuffer(uint8_t addr, uint8_t reg, uint8_t len, uint8_t * data) { int i; I2C_Start(); I2C_SendByte(addr << 1 | I2C_Direction_Transmitter); if (!I2C_WaitAck()) { I2C_Stop(); return false; } I2C_SendByte(reg); I2C_WaitAck(); for (i = 0; i < len; i++) { I2C_SendByte(data[i]); if (!I2C_WaitAck()) { I2C_Stop(); return false; } } I2C_Stop(); return true; }
int32_t i2cWrite(uint8_t addr, uint8_t reg, uint8_t data) { I2C_Start(); I2C_SendByte(addr << 1 | I2C_Direction_Transmitter); if (!I2C_WaitAck()) { I2C_Stop(); return false; } I2C_SendByte(reg); I2C_WaitAck(); I2C_SendByte(data); I2C_WaitAck(); I2C_Stop(); return true; }
int32_t i2cRead(uint8_t addr, uint8_t reg, uint8_t len, uint8_t *buf) { I2C_Start(); I2C_SendByte(addr << 1 | I2C_Direction_Transmitter); if (!I2C_WaitAck()) { I2C_Stop(); return false; } I2C_SendByte(reg); I2C_WaitAck(); I2C_Start(); I2C_SendByte(addr << 1 | I2C_Direction_Receiver); I2C_WaitAck(); while (len) { *buf = I2C_ReceiveByte(); if (len == 1) I2C_NoAck(); else I2C_Ack(); buf++; len--; } I2C_Stop(); return true; }
uint16_t i2cGetErrorCounter(void) { // TODO maybe fix this, but since this is test code, doesn't matter. return 0; }
Bluetooth does not work program . Here is the code：
#include <stdint.h> #include <string.h> #include <math.h> #include "nordic_common.h" #include "nrf.h" #include "nrf51_bitfields.h" #include "ble_hci.h" #include "ble_advdata.h" #include "ble_conn_params.h" #include "softdevice_handler.h" #include "app_timer.h" #include "app_button.h" #include "ble_nus.h" #include "simple_uart.h" #include "boards.h" #include "ble_error_log.h" #include "ble_debug_assert_handler.h" #include "twi_master.h" #include "mpu6050.h" #include "lcd.h" #include "sensor.h" #include "attitude.h" #include "inv_mpu_dmp_motion_driver.h" #include "inv_mpu.h"
#define WAKEUP_BUTTON_PIN BUTTON_0 /**< Button used to wake up the application. */
#define ADVERTISING_LED_PIN_NO LED_0 /< LED to indicate advertising state. */ #define CONNECTED_LED_PIN_NO LED_1 /< LED to indicate connected state. */
#define DEVICE_NAME "Nordic_UART" /**< Name of device. Will be included in the advertising data. */
#define APP_ADV_INTERVAL 64 /< The advertising interval (in units of 0.625 ms. This value corresponds to 40 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 3 /< Maximum number of simultaneously created timers. */ #define APP_TIMER_OP_QUEUE_SIZE 4 /**< Size of timer operation queues. */
#define MPU6050_INIT_INTERVAL APP_TIMER_TICKS(1000, APP_TIMER_PRESCALER)/< Battery level measurement interval (ticks). */ #define MPU6050_GET_INTERVAL APP_TIMER_TICKS(1000, APP_TIMER_PRESCALER)/< Heart rate measurement interval (ticks). */
#define MIN_CONN_INTERVAL 16 /< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */ #define MAX_CONN_INTERVAL 60 /< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */ #define SLAVE_LATENCY 0 /< slave latency. */ #define CONN_SUP_TIMEOUT 400 /< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */ #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(20000, APP_TIMER_PRESCALER) /< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (20 seconds). */ #define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER) /< Time between each call to sd_ble_gap_conn_param_update after the first call (5 seconds). */ #define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */
#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 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 encryption key size. */
#define START_STRING "Start...\n" /**< The string that will be sent over the UART when the application starts. */
#define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
static ble_gap_sec_params_t m_sec_params; /< Security requirements for this application. */ static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /< Handle of the current connection. */ static ble_nus_t m_nus; /**< Structure to identify the Nordic UART Service. */
static app_timer_id_t mpu6050_init_timer_id; /**< Battery timer. */ static app_timer_id_t mpu6050_get_timer_id;
/**@brief Error handler function, which is called when an error has occurred. *
-
@warning This handler is an example only and does not fit a final product. You need to analyze
-
how your product is supposed to react in case of error. -
@param[in] error_code Error code supplied to the handler.
-
@param[in] line_num Line number where the handler is called.
-
@param[in] p_file_name Pointer to the file name. */ void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name) { // This call can be used for debug purposes during application development. // @note CAUTION: Activating this code will write the stack to flash on an error. // This function should NOT be used in a final product. // It is intended STRICTLY for development/debugging purposes. // The flash write will happen EVEN if the radio is active, thus interrupting // any communication. // Use with care. Un-comment the line below to use. // ble_debug_assert_handler(error_code, line_num, p_file_name);
// On assert, the system can only recover with a reset. // NVIC_SystemReset(); }
/**@brief Assert macro callback function. *
- @details This function will be called in case of an assert in the SoftDevice.
- @warning This handler is an example only and does not fit a final product. You need to
-
analyze how your product is supposed to react in case of Assert. - @warning On assert from the SoftDevice, the system can only recover on reset.
- @param[in] line_num Line number of the failing ASSERT call.
- @param[in] file_name File name of the failing ASSERT call. */ void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name) { app_error_handler(DEAD_BEEF, line_num, p_file_name); }
/**@brief Function for the LEDs initialization. *
- @details Initializes all LEDs used by this application. */ static void leds_init(void) { nrf_gpio_cfg_output(ADVERTISING_LED_PIN_NO); nrf_gpio_cfg_output(CONNECTED_LED_PIN_NO);
}
static void mpu6050_init_timeout_handler(void * p_context) { uint32_t err_code;
UNUSED_PARAMETER(p_context);
err_code = app_timer_stop(mpu6050_init_timer_id);
APP_ERROR_CHECK(err_code);
while(1)//*************************
{
if(mpu6050_dmp_init() == 0) //****
{
break;//*************************
}
}//********************************
sensor_init();//*******************
attitude_init();//*****************
err_code = app_timer_start(mpu6050_get_timer_id, MPU6050_GET_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
}
static void mpu6050_get_timeout_handler(void * p_context) { int16_t angle_x,angle_y,angle_z;
UNUSED_PARAMETER(p_context);
sensor_checkEvent();
if (sensor_getDataStatus())
{
angle_y = sensor_getPitch();
angle_x = sensor_getRoll();
angle_z = sensor_getYaw();
}
}
/**@brief Function for Timer initialization. *
-
@details Initializes the timer module. */ static void timers_init(void) { uint32_t err_code;
// Initialize timer module APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_MAX_TIMERS, APP_TIMER_OP_QUEUE_SIZE, false);
// Create timerserr_code = app_timer_create(&mpu6050_init_timer_id, APP_TIMER_MODE_REPEATED, mpu6050_init_timeout_handler); APP_ERROR_CHECK(err_code);
err_code = app_timer_create(&mpu6050_get_timer_id, APP_TIMER_MODE_REPEATED, mpu6050_get_timeout_handler); APP_ERROR_CHECK(err_code);
}
/**@brief Function for the GAP initialization. *
- @details This function will setup all the necessary GAP (Generic Access Profile)
-
parameters of the device. It also sets the permissions and appearance.
*/ 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);
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);
}
/**@brief Function for the Advertising functionality initialization. *
- @details Encodes the required advertising data and passes it to the stack.
-
Also builds a structure to be passed to the stack when starting advertising.
*/ static void advertising_init(void) { uint32_t err_code; ble_advdata_t advdata; ble_advdata_t scanrsp; uint8_t flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
ble_uuid_t adv_uuids[] = {{BLE_UUID_NUS_SERVICE, m_nus.uuid_type}};
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.include_appearance = false;
advdata.flags.size = sizeof(flags);
advdata.flags.p_data = &flags;
memset(&scanrsp, 0, sizeof(scanrsp));
scanrsp.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
scanrsp.uuids_complete.p_uuids = adv_uuids;
err_code = ble_advdata_set(&advdata, &scanrsp);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling the data from the Nordic UART Service. *
- @details This function will process the data received from the Nordic UART BLE Service and send
-
it to the UART module.
*/ /@snippet [Handling the data received over BLE] */ void nus_data_handler(ble_nus_t * p_nus, uint8_t * p_data, uint16_t length) { for (int i = 0; i < length; i++) { simple_uart_put(p_data[i]); } simple_uart_put('\n'); } /@snippet [Handling the data received over BLE] */
/**@brief Function for initializing services that will be used by the application. */ static void services_init(void) { uint32_t err_code; ble_nus_init_t nus_init;
memset(&nus_init, 0, sizeof(nus_init));
nus_init.data_handler = nus_data_handler;
err_code = ble_nus_init(&m_nus, &nus_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing security parameters.
*/
static void sec_params_init(void)
{
m_sec_params.timeout = SEC_PARAM_TIMEOUT;
m_sec_params.bond = SEC_PARAM_BOND;
m_sec_params.mitm = SEC_PARAM_MITM;
m_sec_params.io_caps = SEC_PARAM_IO_CAPABILITIES;
m_sec_params.oob = SEC_PARAM_OOB;
m_sec_params.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
m_sec_params.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
}
/**@brief Function for handling an event from the Connection Parameters Module. *
-
@details This function will be called for all events in the Connection Parameters Module
-
which are passed to the application. -
@note All this function does is to disconnect. This could have been done by simply setting
-
the disconnect_on_fail config parameter, but instead we use the event handler -
mechanism to demonstrate its use. -
@param[in] p_evt Event received from the Connection Parameters Module. */ static void on_conn_params_evt(ble_conn_params_evt_t * p_evt) { uint32_t err_code;
if(p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED) { err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE); APP_ERROR_CHECK(err_code); } }
/**@brief Function for handling errors from the Connection Parameters module. *
- @param[in] nrf_error Error code containing information about what went wrong. */ static void conn_params_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); }
/**@brief Function for initializing the Connection Parameters module. */ static void conn_params_init(void) { uint32_t err_code; ble_conn_params_init_t cp_init;
memset(&cp_init, 0, sizeof(cp_init));
cp_init.p_conn_params = NULL;
cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT;
cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID;
cp_init.disconnect_on_fail = false;
cp_init.evt_handler = on_conn_params_evt;
cp_init.error_handler = conn_params_error_handler;
err_code = ble_conn_params_init(&cp_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for starting advertising. */ static void advertising_start(void) { uint32_t err_code; ble_gap_adv_params_t adv_params;
// Start advertising
memset(&adv_params, 0, sizeof(adv_params));
adv_params.type = BLE_GAP_ADV_TYPE_ADV_IND;
adv_params.p_peer_addr = NULL;
adv_params.fp = BLE_GAP_ADV_FP_ANY;
adv_params.interval = APP_ADV_INTERVAL;
adv_params.timeout = APP_ADV_TIMEOUT_IN_SECONDS;
err_code = sd_ble_gap_adv_start(&adv_params);
APP_ERROR_CHECK(err_code);
nrf_gpio_pin_set(ADVERTISING_LED_PIN_NO);
}
/**@brief Function for the Application's S110 SoftDevice event handler. *
-
@param[in] p_ble_evt S110 SoftDevice event. */ static void on_ble_evt(ble_evt_t * p_ble_evt) { uint32_t err_code; static ble_gap_evt_auth_status_t m_auth_status; ble_gap_enc_info_t * p_enc_info;
switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: nrf_gpio_pin_set(CONNECTED_LED_PIN_NO); nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO); m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
break; case BLE_GAP_EVT_DISCONNECTED: nrf_gpio_pin_clear(CONNECTED_LED_PIN_NO); m_conn_handle = BLE_CONN_HANDLE_INVALID; advertising_start(); break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_SUCCESS, &m_sec_params); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0); APP_ERROR_CHECK(err_code); break; case BLE_GAP_EVT_AUTH_STATUS: m_auth_status = p_ble_evt->evt.gap_evt.params.auth_status; break; case BLE_GAP_EVT_SEC_INFO_REQUEST: p_enc_info = &m_auth_status.periph_keys.enc_info; if (p_enc_info->div == p_ble_evt->evt.gap_evt.params.sec_info_request.div) { err_code = sd_ble_gap_sec_info_reply(m_conn_handle, p_enc_info, NULL); APP_ERROR_CHECK(err_code); } else { // No keys found for this device err_code = sd_ble_gap_sec_info_reply(m_conn_handle, NULL, NULL); APP_ERROR_CHECK(err_code); } break; case BLE_GAP_EVT_TIMEOUT: if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISEMENT) { nrf_gpio_pin_clear(ADVERTISING_LED_PIN_NO); // Configure buttons with sense level low as wakeup source. nrf_gpio_cfg_sense_input(WAKEUP_BUTTON_PIN, BUTTON_PULL, NRF_GPIO_PIN_SENSE_LOW); // Go to system-off mode (this function will not return; wakeup will cause a reset) err_code = sd_power_system_off(); APP_ERROR_CHECK(err_code); } break; default: // No implementation needed. break;} }
/**@brief Function for dispatching a S110 SoftDevice event to all modules with a S110
-
SoftDevice event handler. - @details This function is called from the S110 SoftDevice event interrupt handler after a
-
S110 SoftDevice event has been received. - @param[in] p_ble_evt S110 SoftDevice event. */ static void ble_evt_dispatch(ble_evt_t * p_ble_evt) { ble_conn_params_on_ble_evt(p_ble_evt); ble_nus_on_ble_evt(&m_nus, p_ble_evt); on_ble_evt(p_ble_evt); }
/**@brief Function for the S110 SoftDevice initialization. *
-
@details This function initializes the S110 SoftDevice and the BLE event interrupt. */ static void ble_stack_init(void) { // Initialize SoftDevice. SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);
// Subscribe for BLE events. uint32_t err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch); APP_ERROR_CHECK(err_code); }
/**@brief Function for configuring the buttons.
*/
static void buttons_init(void)
{
nrf_gpio_cfg_sense_input(WAKEUP_BUTTON_PIN,
BUTTON_PULL,
NRF_GPIO_PIN_SENSE_LOW);
}
/**@brief Function for placing the application in low power state while waiting for events. */ static void power_manage(void) { uint32_t err_code = sd_app_evt_wait(); APP_ERROR_CHECK(err_code); }
/@brief Function for initializing the UART module. */ static void uart_init(void) { /@snippet [UART Initialization] */ simple_uart_config(RTS_PIN_NUMBER, TX_PIN_NUMBER, CTS_PIN_NUMBER, RX_PIN_NUMBER, HWFC);
NRF_UART0->INTENSET = UART_INTENSET_RXDRDY_Enabled << UART_INTENSET_RXDRDY_Pos;
NVIC_SetPriority(UART0_IRQn, APP_IRQ_PRIORITY_LOW);
NVIC_EnableIRQ(UART0_IRQn);
/**@snippet [UART Initialization] */
}
/**@brief Function for handling UART interrupts. *
- @details This function will receive a single character from the UART and append it to a string.
-
The string will be be sent over BLE when the last character received was a 'new line' -
i.e '\n' (hex 0x0D) or if the string has reached a length of @ref NUS_MAX_DATA_LENGTH.
*/ void UART0_IRQHandler(void) { static uint8_t data_array[BLE_NUS_MAX_DATA_LEN]; static uint8_t index = 0; uint32_t err_code;
/**@snippet [Handling the data received over UART] */
data_array[index] = simple_uart_get();
index++;
if ((data_array[index - 1] == '\n') || (index >= (BLE_NUS_MAX_DATA_LEN - 1)))
{
err_code = ble_nus_send_string(&m_nus, data_array, index + 1);
if (err_code != NRF_ERROR_INVALID_STATE)
{
APP_ERROR_CHECK(err_code);
}
index = 0;
}
/**@snippet [Handling the data received over UART] */
}
/**@brief Function for starting the application timers. */ static void application_timers_start(void) { uint32_t err_code;
// Start application timers
err_code = app_timer_start(mpu6050_init_timer_id, MPU6050_INIT_INTERVAL, NULL);
APP_ERROR_CHECK(err_code);
// err_code = app_timer_start(mpu6050_get_timer_id, MPU6050_GET_INTERVAL, NULL); // APP_ERROR_CHECK(err_code);
}
/@brief Application main function. / int main(void) { // Initialize leds_init(); twi_master_init();//************ // ResetLcd();//**********************
timers_init();
buttons_init();
uart_init();
ble_stack_init();
gap_params_init();
services_init();
advertising_init();
conn_params_init();
sec_params_init();
simple_uart_putstring(START_STRING);
advertising_start();
application_timers_start();
// while(1)//************************* // { // if(mpu6050_dmp_init() == 0) //**** // { // break;//************************* // } // }//******************************** // sensor_init();//******************* // attitude_init();//***************** // Enter main loop for (;;) { power_manage(); } }
/**
- @} */