/* * Bytes start with START bit (0) followed by 8 data bits and then the * STOP bit (1). STOP bit should be configurable. Data bits are sent LSB first. */ static void uart_bitbang_tx_timer(void *arg) { struct uart_bitbang *ub = (struct uart_bitbang *)arg; uint32_t next = 0; int data; if (!ub->ub_txing || ub->ub_tx.bits > 9) { if (ub->ub_tx.bits > 9) { if (ub->ub_tx_done) { ub->ub_tx_done(ub->ub_func_arg); } } data = ub->ub_tx_func(ub->ub_func_arg); if (data < 0) { ub->ub_txing = 0; return; } else { ub->ub_tx.byte = data; } /* * Start bit */ hal_gpio_write(ub->ub_tx.pin, 0); ub->ub_tx.start = cputime_get32(); next = ub->ub_tx.start + ub->ub_bittime; ub->ub_txing = 1; ub->ub_tx.bits = 0; } else { if (ub->ub_tx.bits++ < 8) { hal_gpio_write(ub->ub_tx.pin, ub->ub_tx.byte & 0x01); ub->ub_tx.byte = ub->ub_tx.byte >> 1; next = ub->ub_tx.start + (ub->ub_bittime * (ub->ub_tx.bits + 1)); } else {
static sint8 nm_spi_rw(uint8 *pu8Mosi, uint8 *pu8Miso, uint16 u16Sz) { int rc = M2M_SUCCESS; uint8_t tx = 0; uint8_t rx; /* chip select */ hal_gpio_write(WINC1500_SPI_SSN, 0); while (u16Sz) { if (pu8Mosi) { tx = *pu8Mosi; pu8Mosi++; } //rx = hal_spi_tx_val(BSP_WINC1500_SPI_PORT, tx); rc = hal_spi_txrx(BSP_WINC1500_SPI_PORT, &tx, &rx, 1); if (rc != 0) { rc = M2M_ERR_BUS_FAIL; break; } if (pu8Miso) { *pu8Miso = rx; pu8Miso++; } u16Sz--; } /* chip deselect */ hal_gpio_write(WINC1500_SPI_SSN, 1); return rc; }
void SX1276SetAntSw(uint8_t rxTx) { // 1: TX, 0: RX if (rxTx != 0) { hal_gpio_write(SX1276_RXTX, 1); } else { hal_gpio_write(SX1276_RXTX, 0); } }
/** * gpio toggle * * Toggles the specified pin * * @param pin Pin number to toggle * * @return current pin state int 0: low, 1: high */ int hal_gpio_toggle(int pin) { int pin_state = (hal_gpio_read(pin) == 0); hal_gpio_write(pin, pin_state); return pin_state; }
void sblinky_spi_irqm_handler(void *arg, int len) { int i; struct sblinky_spi_cb_arg *cb; hal_gpio_write(SPI_SS_PIN, 1); assert(arg == spi_cb_arg); if (spi_cb_arg) { cb = (struct sblinky_spi_cb_arg *)arg; assert(len == cb->txlen); ++cb->transfers; } /* Make sure we get back the data we expect! */ if (g_spi_xfr_num == 1) { /* The first time we expect entire buffer to be filled with 0x88 */ for (i = 0; i < len; ++i) { if (g_spi_rx_buf[i] != 0x88) { assert(0); } } /* copy current tx buf to last */ memcpy(g_spi_last_tx_buf, g_spi_tx_buf, len); } else { /* Check that we received what we last sent */ spitest_validate_last(len); } ++g_spi_xfr_num; }
int hal_gpio_init_out(int pin, int val) { if (pin >= HAL_GPIO_NUM_PINS) { return -1; } hal_gpio[pin].dir = OUTPUT; hal_gpio_write(pin,val); return 0; }
/** * Read multiple bytes starting from specified register over SPI * * @param The sensor interface * @param The register address start reading from * @param Pointer to where the register value should be written * @param Number of bytes to read * * @return 0 on success, non-zero on failure */ int adxl345_spi_readlen(struct sensor_itf *itf, uint8_t reg, uint8_t *buffer, uint8_t len) { int i; uint16_t retval; int rc = 0; /* Select the device */ hal_gpio_write(itf->si_cs_pin, 0); /* Send the address */ retval = hal_spi_tx_val(itf->si_num, reg | ADXL345_SPI_READ_CMD_BIT | ADXL345_SPI_MULTIBYTE_CMD_BIT); if (retval == 0xFFFF) { rc = SYS_EINVAL; ADXL345_LOG(ERROR, "SPI_%u register write failed addr:0x%02X\n", itf->si_num, reg); STATS_INC(g_adxl345stats, read_errors); goto err; } for (i = 0; i < len; i++) { /* Read data */ retval = hal_spi_tx_val(itf->si_num, 0); if (retval == 0xFFFF) { rc = SYS_EINVAL; ADXL345_LOG(ERROR, "SPI_%u read failed addr:0x%02X\n", itf->si_num, reg); STATS_INC(g_adxl345stats, read_errors); goto err; } buffer[i] = retval; } err: /* De-select the device */ hal_gpio_write(itf->si_cs_pin, 1); return rc; }
/** * Reads a single byte from the specified register using SPI * * @param The register address to read from * @param Pointer to where the register value should be written * * @return 0 on success, non-zero error on failure. */ int adxl345_spi_read8(struct sensor_itf *itf, uint8_t reg, uint8_t *value) { uint16_t retval; int rc = 0; /* Select the device */ hal_gpio_write(itf->si_cs_pin, 0); /* Send the address */ retval = hal_spi_tx_val(itf->si_num, reg | ADXL345_SPI_READ_CMD_BIT); if (retval == 0xFFFF) { rc = SYS_EINVAL; ADXL345_LOG(ERROR, "SPI_%u register write failed addr:0x%02X\n", itf->si_num, reg); STATS_INC(g_adxl345stats, read_errors); goto err; } /* Read data */ retval = hal_spi_tx_val(itf->si_num, 0); if (retval == 0xFFFF) { rc = SYS_EINVAL; ADXL345_LOG(ERROR, "SPI_%u read failed addr:0x%02X\n", itf->si_num, reg); STATS_INC(g_adxl345stats, read_errors); goto err; } *value = retval; err: /* De-select the device */ hal_gpio_write(itf->si_cs_pin, 1); return rc; }
int bq24040_disable(struct bq24040 *bq24040) { /* Don't disable if already disabled */ if (!bq24040->b_is_enabled) { return 0; } if (bq24040->b_cfg.bc_ts_pin->bp_pin_num != -1) { hal_gpio_write(bq24040->b_cfg.bc_ts_pin->bp_pin_num, 0); bq24040->b_is_enabled = false; return 0; } return SYS_EINVAL; }
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 } } }
void hal_gpio_clear(int pin) { hal_gpio_write(pin, 0); }
void hal_gpio_set(int pin) { hal_gpio_write(pin, 1); }
/** * Writes a single byte to the specified register using i2c * * @param The sensor interface * @param The register address to write to * @param The value to write * * @return 0 on success, non-zero error on failure. */ int lis2dw12_i2c_write8(struct sensor_itf *itf, uint8_t reg, uint8_t value) { int rc; uint8_t payload[2] = { reg, value }; struct hal_i2c_master_data data_struct = { .address = itf->si_addr, .len = 2, .buffer = payload }; rc = hal_i2c_master_write(itf->si_num, &data_struct, OS_TICKS_PER_SEC / 10, 1); if (rc) { LIS2DW12_ERR("Failed to write to 0x%02X:0x%02X with value 0x%02X\n", itf->si_addr, reg, value); STATS_INC(g_lis2dw12stats, read_errors); } return rc; } /** * Read multiple bytes starting from specified register over i2c * * @param The sensor interface * @param The register address start reading from * @param Pointer to where the register value should be written * @param Number of bytes to read * * @return 0 on success, non-zero error on failure. */ int lis2dw12_i2c_readlen(struct sensor_itf *itf, uint8_t reg, uint8_t *buffer, uint8_t len) { int rc; struct hal_i2c_master_data data_struct = { .address = itf->si_addr, .len = 1, .buffer = ® }; /* Register write */ rc = hal_i2c_master_write(itf->si_num, &data_struct, OS_TICKS_PER_SEC / 10, 1); if (rc) { LIS2DW12_ERR("I2C access failed at address 0x%02X\n", itf->si_addr); STATS_INC(g_lis2dw12stats, write_errors); return rc; } /* Read data */ data_struct.len = len; data_struct.buffer = buffer; rc = hal_i2c_master_read(itf->si_num, &data_struct, OS_TICKS_PER_SEC / 10, 1); if (rc) { LIS2DW12_ERR("Failed to read from 0x%02X:0x%02X\n", itf->si_addr, reg); STATS_INC(g_lis2dw12stats, read_errors); } return rc; } /** * Writes a single byte to the specified register using SPI * * @param The sensor interface * @param The register address to write to * @param The value to write * * @return 0 on success, non-zero error on failure. */ int lis2dw12_spi_write8(struct sensor_itf *itf, uint8_t reg, uint8_t value) { int rc; /* Select the device */ hal_gpio_write(itf->si_cs_pin, 0); /* Send the address */ rc = hal_spi_tx_val(itf->si_num, reg & ~LIS2DW12_SPI_READ_CMD_BIT); if (rc == 0xFFFF) { rc = SYS_EINVAL; LIS2DW12_ERR("SPI_%u register write failed addr:0x%02X\n", itf->si_num, reg); STATS_INC(g_lis2dw12stats, write_errors); goto err; } /* Read data */ rc = hal_spi_tx_val(itf->si_num, value); if (rc == 0xFFFF) { rc = SYS_EINVAL; LIS2DW12_ERR("SPI_%u write failed addr:0x%02X:0x%02X\n", itf->si_num, reg); STATS_INC(g_lis2dw12stats, write_errors); goto err; } rc = 0; err: /* De-select the device */ hal_gpio_write(itf->si_cs_pin, 1); return rc; }
static inline void spiflash_cs_deactivate(struct spiflash_dev *dev) { hal_gpio_write(dev->ss_pin, 1); }