void SX1276IoInit(void) { struct hal_spi_settings spi_settings; int rc; #if MYNEWT_VAL(SX1276_HAS_ANT_SW) rc = hal_gpio_init_out(SX1276_RXTX, 0); assert(rc == 0); #endif rc = hal_gpio_init_out(RADIO_NSS, 1); assert(rc == 0); hal_spi_disable(RADIO_SPI_IDX); spi_settings.data_order = HAL_SPI_MSB_FIRST; spi_settings.data_mode = HAL_SPI_MODE0; spi_settings.baudrate = MYNEWT_VAL(SX1276_SPI_BAUDRATE); spi_settings.word_size = HAL_SPI_WORD_SIZE_8BIT; rc = hal_spi_config(RADIO_SPI_IDX, &spi_settings); assert(rc == 0); rc = hal_spi_enable(RADIO_SPI_IDX); assert(rc == 0); }
sint8 nm_bus_init(void *pvinit) { struct hal_spi_settings cfg = { 0 }; /* * Add code to configure spi. */ if (!winc1500_spi_inited) { if (hal_gpio_init_out(WINC1500_SPI_SSN, 1)) { return M2M_ERR_BUS_FAIL; } cfg.data_mode = HAL_SPI_MODE0; cfg.data_order = HAL_SPI_MSB_FIRST; cfg.word_size = HAL_SPI_WORD_SIZE_8BIT; cfg.baudrate = WINC1500_SPI_SPEED; if (hal_spi_config(BSP_WINC1500_SPI_PORT, &cfg)) { return M2M_ERR_BUS_FAIL; } winc1500_spi_inited = 1; if (hal_spi_enable(BSP_WINC1500_SPI_PORT)) { return M2M_ERR_BUS_FAIL; } } nm_bsp_reset(); nm_bsp_sleep(1); return M2M_SUCCESS; }
void hal_spi_init(void) { hal_spi_init_rcc(); hal_spi_init_gpio(); hal_spi_init_mode(); hal_spi_init_dma(); hal_spi_enable(); }
/** * tlc5972 open * * Device open funtion. * * @param odev Pointer to OS device structure * @param wait The amount of time to wait to open (if needed). * @param arg device open arg (not used) * * @return int 0:success; error code otherwise */ static int tlc5971_open(struct os_dev *odev, uint32_t wait, void *arg) { int rc; int spi_num; struct tlc5971_dev *dev; struct hal_spi_settings spi_cfg; dev = (struct tlc5971_dev *)odev; /* Configure the spi and enable it */ spi_cfg.baudrate = dev->tlc_itf.tpi_spi_freq; spi_cfg.data_mode = HAL_SPI_MODE0; spi_cfg.data_order = HAL_SPI_MSB_FIRST; spi_cfg.word_size = HAL_SPI_WORD_SIZE_8BIT; spi_num = dev->tlc_itf.tpi_spi_num; hal_spi_disable(spi_num); rc = hal_spi_config(spi_num, &spi_cfg); if (rc) { return rc; } hal_spi_enable(spi_num); dev->is_enabled = true; return 0; }
static int lis2dw12_sensor_read(struct sensor *sensor, sensor_type_t type, sensor_data_func_t data_func, void *data_arg, uint32_t timeout) { int rc; const struct lis2dw12_cfg *cfg; struct lis2dw12 *lis2dw12; struct sensor_itf *itf; /* If the read isn't looking for accel data, don't do anything. */ if (!(type & SENSOR_TYPE_ACCELEROMETER)) { rc = SYS_EINVAL; goto err; } itf = SENSOR_GET_ITF(sensor); if (itf->si_type == SENSOR_ITF_SPI) { rc = hal_spi_disable(sensor->s_itf.si_num); if (rc) { goto err; } rc = hal_spi_config(sensor->s_itf.si_num, &spi_lis2dw12_settings); if (rc == EINVAL) { /* If spi is already enabled, for nrf52, it returns -1, We should not * fail if the spi is already enabled */ goto err; } rc = hal_spi_enable(sensor->s_itf.si_num); if (rc) { goto err; } } lis2dw12 = (struct lis2dw12 *)SENSOR_GET_DEVICE(sensor); cfg = &lis2dw12->cfg; if (cfg->read_mode == LIS2DW12_READ_M_POLL) { rc = lis2dw12_poll_read(sensor, type, data_func, data_arg, timeout); } else { rc = lis2dw12_stream_read(sensor, type, data_func, data_arg, timeout); } err: return rc; }
void task1_handler(void *arg) { int rc; /* Set the led pin for the E407 devboard */ g_led_pin = LED_BLINK_PIN; hal_gpio_init_out(g_led_pin, 1); spi_cb_arg = &spi_cb_obj; sblinky_spi_cfg(SPI_SLAVE_ID); hal_spi_enable(SPI_SLAVE_ID); /* Make the default character 0x77 */ hal_spi_slave_set_def_tx_val(SPI_SLAVE_ID, 0x77); /* * Fill buffer with 0x77 for first transfer. This should be a 0xdeadbeef * transfer from master to start things off */ memset(g_spi_tx_buf, 0x77, 32); rc = hal_spi_txrx_noblock(SPI_SLAVE_ID, g_spi_tx_buf, g_spi_rx_buf, 32); while (1) { /* Wait for semaphore from ISR */ os_sem_pend(&g_test_sem, OS_TIMEOUT_NEVER); if (g_spi_xfr_num == 0) { /* Since we dont know what master will send, we fill 0x88 */ memset(g_spi_tx_buf, 0x88, 32); rc = hal_spi_txrx_noblock(SPI_SLAVE_ID, g_spi_tx_buf, g_spi_rx_buf, 32); assert(rc == 0); } else { /* transmit back what we just received */ memcpy(prev_buf, g_spi_tx_buf, 32); memset(g_spi_tx_buf, 0xaa, 32); memcpy(g_spi_tx_buf, g_spi_rx_buf, spi_cb_obj.txlen); rc = hal_spi_txrx_noblock(SPI_SLAVE_ID, g_spi_tx_buf, g_spi_rx_buf, 32); assert(rc == 0); } ++g_spi_xfr_num; /* Toggle the LED */ hal_gpio_toggle(g_led_pin); } }
void task1_handler(void *arg) { int i; int rc; uint16_t rxval; uint8_t last_val; uint8_t spi_nb_cntr; uint8_t spi_b_cntr; /* Set the led pin for the E407 devboard */ g_led_pin = LED_BLINK_PIN; hal_gpio_init_out(g_led_pin, 1); /* Use SS pin for testing */ hal_gpio_init_out(SPI_SS_PIN, 1); sblinky_spi_cfg(0); hal_spi_set_txrx_cb(0, NULL, NULL); hal_spi_enable(0); /* * Send some bytes in a non-blocking manner to SPI using tx val. The * slave should send back 0x77. */ g_spi_tx_buf[0] = 0xde; g_spi_tx_buf[1] = 0xad; g_spi_tx_buf[2] = 0xbe; g_spi_tx_buf[3] = 0xef; hal_gpio_write(SPI_SS_PIN, 0); for (i = 0; i < 4; ++i) { rxval = hal_spi_tx_val(0, g_spi_tx_buf[i]); assert(rxval == 0x77); g_spi_rx_buf[i] = (uint8_t)rxval; } hal_gpio_write(SPI_SS_PIN, 1); ++g_spi_xfr_num; /* Set up the callback to use when non-blocking API used */ hal_spi_disable(0); spi_cb_arg = &spi_cb_obj; spi_cb_obj.txlen = 32; hal_spi_set_txrx_cb(0, sblinky_spi_irqm_handler, spi_cb_arg); hal_spi_enable(0); spi_nb_cntr = 0; spi_b_cntr = 0; while (1) { /* Wait one second */ os_time_delay(OS_TICKS_PER_SEC); /* Toggle the LED */ hal_gpio_toggle(g_led_pin); /* Get random length to send */ g_last_tx_len = spi_cb_obj.txlen; spi_cb_obj.txlen = (rand() & 0x1F) + 1; memcpy(g_spi_last_tx_buf, g_spi_tx_buf, g_last_tx_len); last_val = g_spi_last_tx_buf[g_last_tx_len - 1]; for (i= 0; i < spi_cb_obj.txlen; ++i) { g_spi_tx_buf[i] = (uint8_t)(last_val + i); } if (g_spi_xfr_num & 1) { /* Send non-blocking */ ++spi_nb_cntr; assert(hal_gpio_read(SPI_SS_PIN) == 1); hal_gpio_write(SPI_SS_PIN, 0); #if 0 if (spi_nb_cntr == 7) { g_spi_null_rx = 1; rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, NULL, 32); } else { g_spi_null_rx = 0; rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, g_spi_rx_buf, 32); } assert(!rc); #else g_spi_null_rx = 0; rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, g_spi_rx_buf, spi_cb_obj.txlen); assert(!rc); console_printf("a transmitted: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_tx_buf[i]); } console_printf("\n"); console_printf("received: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_rx_buf[i]); } console_printf("\n"); #endif } else { /* Send blocking */ ++spi_b_cntr; assert(hal_gpio_read(SPI_SS_PIN) == 1); hal_gpio_write(SPI_SS_PIN, 0); #if 0 if (spi_b_cntr == 7) { g_spi_null_rx = 1; rc = hal_spi_txrx(0, g_spi_tx_buf, NULL, 32); spi_b_cntr = 0; } else { g_spi_null_rx = 0; rc = hal_spi_txrx(0, g_spi_tx_buf, g_spi_rx_buf, 32); } assert(!rc); hal_gpio_write(SPI_SS_PIN, 1); spitest_validate_last(spi_cb_obj.txlen); #else rc = hal_spi_txrx(0, g_spi_tx_buf, g_spi_rx_buf, spi_cb_obj.txlen); assert(!rc); hal_gpio_write(SPI_SS_PIN, 1); console_printf("b transmitted: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_tx_buf[i]); } console_printf("\n"); console_printf("received: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_rx_buf[i]); } console_printf("\n"); spitest_validate_last(spi_cb_obj.txlen); ++g_spi_xfr_num; #endif } } }
/** * Configure the sensor * * @param ptr to sensor driver * @param ptr to sensor driver config */ int lis2dw12_config(struct lis2dw12 *lis2dw12, struct lis2dw12_cfg *cfg) { int rc; struct sensor_itf *itf; uint8_t chip_id; struct sensor *sensor; itf = SENSOR_GET_ITF(&(lis2dw12->sensor)); sensor = &(lis2dw12->sensor); if (itf->si_type == SENSOR_ITF_SPI) { rc = hal_spi_disable(sensor->s_itf.si_num); if (rc) { goto err; } rc = hal_spi_config(sensor->s_itf.si_num, &spi_lis2dw12_settings); if (rc == EINVAL) { /* If spi is already enabled, for nrf52, it returns -1, We should not * fail if the spi is already enabled */ goto err; } rc = hal_spi_enable(sensor->s_itf.si_num); if (rc) { goto err; } } rc = lis2dw12_get_chip_id(itf, &chip_id); if (rc) { goto err; } if (chip_id != LIS2DW12_ID) { rc = SYS_EINVAL; goto err; } rc = lis2dw12_reset(itf); if (rc) { goto err; } rc = lis2dw12_write8(itf, LIS2DW12_REG_CTRL_REG3, LIS2DW12_CTRL_REG3_LIR); if (rc) { goto err; } rc = lis2dw12_set_offsets(itf, cfg->offset_x, cfg->offset_y, cfg->offset_z, cfg->offset_weight); if (rc) { goto err; } lis2dw12->cfg.offset_x = cfg->offset_x; lis2dw12->cfg.offset_y = cfg->offset_y; lis2dw12->cfg.offset_z = cfg->offset_z; lis2dw12->cfg.offset_weight = cfg->offset_weight; rc = lis2dw12_set_offset_enable(itf, cfg->offset_en); if (rc) { goto err; } lis2dw12->cfg.offset_en = cfg->offset_en; rc = lis2dw12_set_filter_cfg(itf, LIS2DW12_FILTER_BW_ODR_DIV_2, 0); if (rc) { goto err; } rc = lis2dw12_set_full_scale(itf, cfg->fs); if (rc) { goto err; } lis2dw12->cfg.fs = cfg->fs; rc = lis2dw12_set_rate(itf, cfg->rate); if (rc) { goto err; } lis2dw12->cfg.rate = cfg->rate; rc = lis2dw12_set_self_test(itf, LIS2DW12_ST_MODE_DISABLE); if (rc) { goto err; } rc = lis2dw12_set_power_mode(itf, LIS2DW12_PM_HIGH_PERF); if (rc) { goto err; } rc = lis2dw12_set_low_noise(itf, 1); if (rc) { goto err; } rc = lis2dw12_set_fifo_cfg(itf, cfg->fifo_mode, cfg->fifo_threshold); if (rc) { goto err; } lis2dw12->cfg.fifo_mode = cfg->fifo_mode; lis2dw12->cfg.fifo_threshold = cfg->fifo_threshold; rc = lis2dw12_set_int_enable(itf, cfg->int_enable); if (rc) { goto err; } lis2dw12->cfg.int_enable = cfg->int_enable; rc = lis2dw12_set_int1_pin_cfg(itf, cfg->int1_pin_cfg); if (rc) { goto err; } lis2dw12->cfg.int1_pin_cfg = cfg->int1_pin_cfg; rc = lis2dw12_set_int2_pin_cfg(itf, cfg->int2_pin_cfg); if (rc) { goto err; } lis2dw12->cfg.int2_pin_cfg = cfg->int2_pin_cfg; rc = lis2dw12_set_tap_cfg(itf, &cfg->tap_cfg); if (rc) { goto err; } lis2dw12->cfg.tap_cfg = cfg->tap_cfg; rc = sensor_set_type_mask(&(lis2dw12->sensor), cfg->mask); if (rc) { goto err; } lis2dw12->cfg.stream_read_interrupt = cfg->stream_read_interrupt; lis2dw12->cfg.read_mode = cfg->read_mode; lis2dw12->cfg.mask = cfg->mask; return 0; err: return rc; }
/** * Expects to be called back through os_dev_create(). * * @param The device object associated with this accelerometer * @param Argument passed to OS device init, unused * * @return 0 on success, non-zero error on failure. */ int lis2dw12_init(struct os_dev *dev, void *arg) { struct lis2dw12 *lis2dw12; struct sensor *sensor; int rc; if (!arg || !dev) { rc = SYS_ENODEV; goto err; } lis2dw12 = (struct lis2dw12 *) dev; lis2dw12->cfg.mask = SENSOR_TYPE_ALL; log_register(dev->od_name, &_log, &log_console_handler, NULL, LOG_SYSLEVEL); sensor = &lis2dw12->sensor; /* Initialise the stats entry */ rc = stats_init( STATS_HDR(g_lis2dw12stats), STATS_SIZE_INIT_PARMS(g_lis2dw12stats, STATS_SIZE_32), STATS_NAME_INIT_PARMS(lis2dw12_stat_section)); SYSINIT_PANIC_ASSERT(rc == 0); /* Register the entry with the stats registry */ rc = stats_register(dev->od_name, STATS_HDR(g_lis2dw12stats)); SYSINIT_PANIC_ASSERT(rc == 0); rc = sensor_init(sensor, dev); if (rc) { goto err; } /* Add the light driver */ rc = sensor_set_driver(sensor, SENSOR_TYPE_ACCELEROMETER, (struct sensor_driver *) &g_lis2dw12_sensor_driver); if (rc) { goto err; } /* Set the interface */ rc = sensor_set_interface(sensor, arg); if (rc) { goto err; } rc = sensor_mgr_register(sensor); if (rc) { goto err; } if (sensor->s_itf.si_type == SENSOR_ITF_SPI) { rc = hal_spi_disable(sensor->s_itf.si_num); if (rc) { goto err; } rc = hal_spi_config(sensor->s_itf.si_num, &spi_lis2dw12_settings); if (rc == EINVAL) { /* If spi is already enabled, for nrf52, it returns -1, We should not * fail if the spi is already enabled */ goto err; } rc = hal_spi_enable(sensor->s_itf.si_num); if (rc) { goto err; } rc = hal_gpio_init_out(sensor->s_itf.si_cs_pin, 1); if (rc) { goto err; } } init_interrupt(&lis2dw12->intr, lis2dw12->sensor.s_itf.si_ints); lis2dw12->pdd.notify_ctx.snec_sensor = sensor; lis2dw12->pdd.registered_mask = 0; lis2dw12->pdd.interrupt = NULL; rc = init_intpin(lis2dw12, lis2dw12_int_irq_handler, sensor); if (rc) { return rc; } return 0; err: return rc; }
/** * Expects to be called back through os_dev_create(). * * @param The device object associated with this accelerometer * @param Argument passed to OS device init, unused * * @return 0 on success, non-zero error on failure. */ int adxl345_init(struct os_dev *dev, void *arg) { struct adxl345 *adxl; struct sensor *sensor; int rc; if (!arg || !dev) { return SYS_ENODEV; } adxl = (struct adxl345 *) dev; adxl->cfg.mask = SENSOR_TYPE_ALL; log_register(dev->od_name, &_log, &log_console_handler, NULL, LOG_SYSLEVEL); sensor = &adxl->sensor; /* Initialise the stats entry */ rc = stats_init( STATS_HDR(g_adxl345stats), STATS_SIZE_INIT_PARMS(g_adxl345stats, STATS_SIZE_32), STATS_NAME_INIT_PARMS(adxl345_stat_section)); SYSINIT_PANIC_ASSERT(rc == 0); /* Register the entry with the stats registry */ rc = stats_register(dev->od_name, STATS_HDR(g_adxl345stats)); SYSINIT_PANIC_ASSERT(rc == 0); rc = sensor_init(sensor, dev); if (rc) { return rc; } /* Add the accelerometer/gyroscope driver */ rc = sensor_set_driver(sensor, SENSOR_TYPE_ACCELEROMETER, (struct sensor_driver *) &adxl345_sensor_driver); if (rc) { return rc; } rc = sensor_set_interface(sensor, arg); if (rc) { return rc; } rc = sensor_mgr_register(sensor); if (rc) { return rc; } if (sensor->s_itf.si_type == SENSOR_ITF_SPI) { rc = hal_spi_config(sensor->s_itf.si_num, &spi_adxl345_settings); if (rc == EINVAL) { return rc; } rc = hal_spi_enable(sensor->s_itf.si_num); if (rc) { return rc; } rc = hal_gpio_init_out(sensor->s_itf.si_cs_pin, 1); if (rc) { return rc; } } #if MYNEWT_VAL(ADXL345_INT_ENABLE) adxl->pdd.read_ctx.srec_sensor = sensor; adxl->pdd.notify_ctx.snec_sensor = sensor; rc = init_intpin(adxl, interrupt_handler, sensor); if (rc != 0) { return rc; } #endif return 0; }