uartPort_t *serialUART5(uint32_t baudRate, portMode_t mode, portOptions_t options) { uartPort_t *s; static volatile uint8_t rx5Buffer[UART5_RX_BUFFER_SIZE]; static volatile uint8_t tx5Buffer[UART5_TX_BUFFER_SIZE]; NVIC_InitTypeDef NVIC_InitStructure; s = &uartPort5; s->port.vTable = uartVTable; s->port.baudRate = baudRate; s->port.rxBufferSize = UART5_RX_BUFFER_SIZE; s->port.txBufferSize = UART5_TX_BUFFER_SIZE; s->port.rxBuffer = rx5Buffer; s->port.txBuffer = tx5Buffer; s->USARTx = UART5; RCC_ClockCmd(RCC_APB1(UART5), ENABLE); serialUARTInit(IOGetByTag(IO_TAG(UART5_TX_PIN)), IOGetByTag(IO_TAG(UART5_RX_PIN)), mode, options, GPIO_AF_5, 5); NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART5); NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART5); NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); return s; }
void pgResetFn_adcConfig(adcConfig_t *adcConfig) { adcConfig->device = ADC_DEV_TO_CFG(adcDeviceByInstance(ADC_INSTANCE)); #ifdef VBAT_ADC_PIN adcConfig->vbat.enabled = true; adcConfig->vbat.ioTag = IO_TAG(VBAT_ADC_PIN); #endif #ifdef EXTERNAL1_ADC_PIN adcConfig->external1.enabled = true; adcConfig->external1.ioTag = IO_TAG(EXTERNAL1_ADC_PIN); #endif #ifdef CURRENT_METER_ADC_PIN adcConfig->current.enabled = true; adcConfig->current.ioTag = IO_TAG(CURRENT_METER_ADC_PIN); #endif #ifdef RSSI_ADC_PIN adcConfig->rssi.enabled = true; adcConfig->rssi.ioTag = IO_TAG(RSSI_ADC_PIN); #endif }
void resetSonarConfig(sonarConfig_t *sonarConfig) { #if defined(SONAR_TRIGGER_PIN) && defined(SONAR_ECHO_PIN) sonarConfig->triggerTag = IO_TAG(SONAR_TRIGGER_PIN); sonarConfig->echoTag = IO_TAG(SONAR_ECHO_PIN); #else #error Sonar not defined for target #endif }
serialPort_t *usbVcpOpen(void) { vcpPort_t *s; IOInit(IOGetByTag(IO_TAG(PA11)), OWNER_USB, 0); IOInit(IOGetByTag(IO_TAG(PA12)), OWNER_USB, 0); #if defined(STM32F4) usbGenerateDisconnectPulse(); switch (usbDevConfig()->type) { #ifdef USE_USB_CDC_HID case COMPOSITE: USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_HID_CDC_cb, &USR_cb); break; #endif default: USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_CDC_cb, &USR_cb); break; } #elif defined(STM32F7) usbGenerateDisconnectPulse(); /* Init Device Library */ USBD_Init(&USBD_Device, &VCP_Desc, 0); /* Add Supported Class */ switch (usbDevConfig()->type) { #ifdef USE_USB_CDC_HID case COMPOSITE: USBD_RegisterClass(&USBD_Device, USBD_HID_CDC_CLASS); break; #endif default: USBD_RegisterClass(&USBD_Device, USBD_CDC_CLASS); break; } /* HID Interface doesn't have any callbacks... */ /* Add CDC Interface Class */ USBD_CDC_RegisterInterface(&USBD_Device, &USBD_CDC_fops); /* Start Device Process */ USBD_Start(&USBD_Device); #else Set_System(); Set_USBClock(); USB_Init(); USB_Interrupts_Config(); #endif s = &vcpPort; s->port.vTable = usbVTable; return (serialPort_t *)s; }
void i2cInit(I2CDevice device) { UNUSED(device); scl = IOGetByTag(IO_TAG(SOFT_I2C_SCL)); sda = IOGetByTag(IO_TAG(SOFT_I2C_SDA)); IOConfigGPIO(scl, IOCFG_OUT_OD); IOConfigGPIO(sda, IOCFG_OUT_OD); }
static inline void mma8451ConfigureInterrupt(void) { #ifdef MMA8451_INT_PIN IOInit(IOGetByTag(IO_TAG(MMA8451_INT_PIN)), OWNER_MPU_EXTI, 0); // TODO - maybe pullup / pulldown ? IOConfigGPIO(IOGetByTag(IO_TAG(MMA8451_INT_PIN)), IOCFG_IN_FLOATING); #endif i2cWrite(MPU_I2C_INSTANCE, MMA8452_ADDRESS, MMA8452_CTRL_REG3, MMA8452_CTRL_REG3_IPOL); // Interrupt polarity (active HIGH) i2cWrite(MPU_I2C_INSTANCE, MMA8452_ADDRESS, MMA8452_CTRL_REG4, MMA8452_CTRL_REG4_INT_EN_DRDY); // Enable DRDY interrupt (unused by this driver) i2cWrite(MPU_I2C_INSTANCE, MMA8452_ADDRESS, MMA8452_CTRL_REG5, 0); // DRDY routed to INT2 }
uartPort_t *serialUART3(uint32_t baudRate, portMode_t mode, portOptions_t options) { uartPort_t *s; static volatile uint8_t rx3Buffer[UART3_RX_BUFFER_SIZE]; static volatile uint8_t tx3Buffer[UART3_TX_BUFFER_SIZE]; s = &uartPort3; s->port.vTable = uartVTable; s->port.baudRate = baudRate; s->port.rxBufferSize = UART3_RX_BUFFER_SIZE; s->port.txBufferSize = UART3_TX_BUFFER_SIZE; s->port.rxBuffer = rx3Buffer; s->port.txBuffer = tx3Buffer; s->USARTx = USART3; #ifdef USE_UART3_RX_DMA s->rxDMAChannel = DMA1_Channel3; s->rxDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->RDR; #endif #ifdef USE_UART3_TX_DMA s->txDMAChannel = DMA1_Channel2; s->txDMAPeripheralBaseAddr = (uint32_t)&s->USARTx->TDR; #endif RCC_ClockCmd(RCC_APB1(USART3), ENABLE); #if defined(USE_UART3_TX_DMA) || defined(USE_UART3_RX_DMA) RCC_AHBClockCmd(RCC_AHB(DMA1), ENABLE); #endif serialUARTInit(IOGetByTag(IO_TAG(UART3_TX_PIN)), IOGetByTag(IO_TAG(UART3_RX_PIN)), mode, options, GPIO_AF_7, 3); #ifdef USE_UART3_TX_DMA // DMA TX Interrupt dmaSetHandler(DMA1_CH2_HANDLER, handleUsartTxDma, NVIC_PRIO_SERIALUART3_TXDMA, (uint32_t)&uartPort3); #endif #ifndef USE_UART3_RX_DMA NVIC_InitTypeDef NVIC_InitStructure; NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SERIALUART3_RXDMA); NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SERIALUART3_RXDMA); NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); #endif return s; }
void updateHardwareRevision(void) { if (hardwareRevision != BJF4_REV2) { return; } /* if flash exists on PB3 then Rev1 */ if (m25p16_init(IO_TAG(PB3))) { hardwareRevision = BJF4_REV1; } else { IOInit(IOGetByTag(IO_TAG(PB3)), OWNER_FREE, RESOURCE_NONE, 0); } }
ioTag_t selectMPUIntExtiConfigByHardwareRevision(void) { #ifdef AFROMINI return IO_TAG(PC13); #else if (hardwareRevision < NAZE32_REV5) { // MPU_INT output on rev4 PB13 return IO_TAG(PB13); } else { // MPU_INT output on rev5 PC13 return IO_TAG(PC13); } #endif }
// alternative defaults settings for BlueJayF4 targets void targetConfiguration(void) { if (hardwareRevision == BJF4_REV1 || hardwareRevision == BJF4_REV2) { gyroDeviceConfigMutable(0)->align = CW180_DEG; beeperDevConfigMutable()->ioTag = IO_TAG(BEEPER_OPT); } if (hardwareRevision == BJF4_MINI_REV3A || hardwareRevision == BJF4_REV1) { blackboxConfigMutable()->device = BLACKBOX_DEVICE_NONE; } if (hardwareRevision == BJF4_MINI_REV3A) { adcConfigMutable()->vbat.ioTag = IO_TAG(PA4); } }
uint8_t detectSpiDevice(void) { #ifdef NAZE_SPI_CS_PIN nazeSpiCsPin = IOGetByTag(IO_TAG(NAZE_SPI_CS_PIN)); #endif uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 }; uint8_t in[4]; uint32_t flash_id; // try autodetect flash chip delay(50); // short delay required after initialisation of SPI device instance. ENABLE_SPI_CS; spiTransfer(NAZE_SPI_INSTANCE, in, out, sizeof(out)); DISABLE_SPI_CS; flash_id = in[1] << 16 | in[2] << 8 | in[3]; if (flash_id == FLASH_M25P16_ID) return SPI_DEVICE_FLASH; // try autodetect MPU delay(50); ENABLE_SPI_CS; spiTransferByte(NAZE_SPI_INSTANCE, MPU_RA_WHO_AM_I | MPU6500_BIT_RESET); in[0] = spiTransferByte(NAZE_SPI_INSTANCE, 0xff); DISABLE_SPI_CS; if (in[0] == MPU6500_WHO_AM_I_CONST) return SPI_DEVICE_MPU; return SPI_DEVICE_NONE; }
void max7456Init(const vcdProfile_t *pVcdProfile) { #ifdef MAX7456_SPI_CS_PIN max7456CsPin = IOGetByTag(IO_TAG(MAX7456_SPI_CS_PIN)); #endif IOInit(max7456CsPin, OWNER_OSD_CS, 0); IOConfigGPIO(max7456CsPin, SPI_IO_CS_CFG); spiSetDivisor(MAX7456_SPI_INSTANCE, SPI_CLOCK_STANDARD); // force soft reset on Max7456 ENABLE_MAX7456; max7456Send(MAX7456ADD_VM0, MAX7456_RESET); DISABLE_MAX7456; // Setup values to write to registers videoSignalCfg = pVcdProfile->video_system; hosRegValue = 32 - pVcdProfile->h_offset; vosRegValue = 16 - pVcdProfile->v_offset; #ifdef MAX7456_DMA_CHANNEL_TX dmaSetHandler(MAX7456_DMA_IRQ_HANDLER_ID, max7456_dma_irq_handler, NVIC_PRIO_MAX7456_DMA, 0); #endif // Real init will be made later when driver detect idle. }
/** * Initialize the driver, must be called before any other routines. * * Attempts to detect a connected m25p16. If found, true is returned and device capacity can be fetched with * m25p16_getGeometry(). */ bool m25p16_init(ioTag_t csTag) { /* if we have already detected a flash device we can simply exit TODO: change the init param in favour of flash CFG when ParamGroups work is done then cs pin can be specified in hardware_revision.c or config.c (dependent on revision). */ if (geometry.sectors) { return true; } if (csTag) { m25p16CsPin = IOGetByTag(csTag); } else { #ifdef M25P16_CS_PIN m25p16CsPin = IOGetByTag(IO_TAG(M25P16_CS_PIN)); #else return false; #endif } IOInit(m25p16CsPin, OWNER_FLASH_CS, 0); IOConfigGPIO(m25p16CsPin, SPI_IO_CS_CFG); DISABLE_M25P16; #ifndef M25P16_SPI_SHARED //Maximum speed for standard READ command is 20mHz, other commands tolerate 25mHz spiSetDivisor(M25P16_SPI_INSTANCE, SPI_CLOCK_FAST); #endif return m25p16_readIdentification(); }
void sdcardInsertionDetectDeinit(void) { #ifdef SDCARD_DETECT_PIN sdCardDetectPin = IOGetByTag(IO_TAG(SDCARD_DETECT_PIN)); IOInit(sdCardDetectPin, OWNER_FREE, RESOURCE_NONE, 0); IOConfigGPIO(sdCardDetectPin, IOCFG_IN_FLOATING); #endif }
// alternative defaults settings for BlueJayF4 targets void targetConfiguration(master_t *config) { if (hardwareRevision == BJF4_REV1 || hardwareRevision == BJF4_REV2) { config->sensorAlignmentConfig.gyro_align = CW180_DEG; config->sensorAlignmentConfig.acc_align = CW180_DEG; config->beeperConfig.ioTag = IO_TAG(BEEPER_OPT); } }
void sdcardInsertionDetectInit(void) { #ifdef SDCARD_DETECT_PIN sdCardDetectPin = IOGetByTag(IO_TAG(SDCARD_DETECT_PIN)); IOInit(sdCardDetectPin, OWNER_SDCARD, RESOURCE_INPUT, 0); IOConfigGPIO(sdCardDetectPin, IOCFG_IPU); #endif }
void pgResetFn_compassConfig(compassConfig_t *compassConfig) { compassConfig->mag_align = ALIGN_DEFAULT; compassConfig->mag_declination = 0; compassConfig->mag_hardware = MAG_DEFAULT; // Generate a reasonable default for backward compatibility // Strategy is // 1. If SPI device is defined, it will take precedence, assuming it's onboard. // 2. I2C devices are will be handled by address = 0 (per device default). // 3. Slave I2C device on SPI gyro #if defined(USE_SPI) && (defined(USE_MAG_SPI_HMC5883) || defined(USE_MAG_SPI_AK8963)) compassConfig->mag_bustype = BUSTYPE_SPI; #ifdef USE_MAG_SPI_HMC5883 compassConfig->mag_spi_device = SPI_DEV_TO_CFG(spiDeviceByInstance(HMC5883_SPI_INSTANCE)); compassConfig->mag_spi_csn = IO_TAG(HMC5883_CS_PIN); #else compassConfig->mag_spi_device = SPI_DEV_TO_CFG(spiDeviceByInstance(AK8963_SPI_INSTANCE)); compassConfig->mag_spi_csn = IO_TAG(AK8963_CS_PIN); #endif compassConfig->mag_i2c_device = I2C_DEV_TO_CFG(I2CINVALID); compassConfig->mag_i2c_address = 0; #elif defined(USE_MAG_HMC5883) || defined(USE_MAG_AK8975) || (defined(USE_MAG_AK8963) && !(defined(USE_GYRO_SPI_MPU6500) || defined(USE_GYRO_SPI_MPU9250))) compassConfig->mag_bustype = BUSTYPE_I2C; compassConfig->mag_i2c_device = I2C_DEV_TO_CFG(MAG_I2C_INSTANCE); compassConfig->mag_i2c_address = 0; compassConfig->mag_spi_device = SPI_DEV_TO_CFG(SPIINVALID); compassConfig->mag_spi_csn = IO_TAG_NONE; #elif defined(USE_MAG_AK8963) && (defined(USE_GYRO_SPI_MPU6500) || defined(USE_GYRO_SPI_MPU9250)) compassConfig->mag_bustype = BUSTYPE_MPU_SLAVE; compassConfig->mag_i2c_device = I2C_DEV_TO_CFG(I2CINVALID); compassConfig->mag_i2c_address = 0; compassConfig->mag_spi_device = SPI_DEV_TO_CFG(SPIINVALID); compassConfig->mag_spi_csn = IO_TAG_NONE; #else compassConfig->mag_hardware = MAG_NONE; compassConfig->mag_bustype = BUSTYPE_NONE; compassConfig->mag_i2c_device = I2C_DEV_TO_CFG(I2CINVALID); compassConfig->mag_i2c_address = 0; compassConfig->mag_spi_device = SPI_DEV_TO_CFG(SPIINVALID); compassConfig->mag_spi_csn = IO_TAG_NONE; #endif compassConfig->interruptTag = COMPASS_INTERRUPT_TAG; }
void pgResetFn_flashConfig(flashConfig_t *flashConfig) { #ifdef M25P16_CS_PIN flashConfig->csTag = IO_TAG(M25P16_CS_PIN); #else flashConfig->csTag = IO_TAG_NONE; #endif flashConfig->spiDevice = SPI_DEV_TO_CFG(spiDeviceByInstance(M25P16_SPI_INSTANCE)); }
void usbCableDetectInit(void) { #ifdef USB_DETECT_PIN usbDetectPin = IOGetByTag(IO_TAG(USB_DETECT_PIN)); IOInit(usbDetectPin, OWNER_USB_DETECT, 0); IOConfigGPIO(usbDetectPin, IOCFG_OUT_PP); #endif }
void targetConfiguration(void) { pinioConfigMutable()->ioTag[0] = IO_TAG(OSD_CH_SWITCH); pinioConfigMutable()->config[0] = PINIO_CONFIG_MODE_OUT_PP; // Default state is LOW voltageSensorADCConfigMutable(VOLTAGE_SENSOR_ADC_VBAT)->vbatscale = VBAT_SCALE; barometerConfigMutable()->baro_hardware = 0; compassConfigMutable()->mag_hardware = 0; osdConfigMutable()->item_pos[OSD_MAIN_BATT_VOLTAGE] = OSD_POS(12, 1) | OSD_PROFILE_1_FLAG; }
void rxSpiDeviceInit(rx_spi_type_e spiType) { static bool hardwareInitialised = false; if (hardwareInitialised) { return; } #ifdef USE_RX_SOFTSPI if (spiType == RX_SPI_SOFTSPI) { useSoftSPI = true; softSpiInit(&softSPIDevice); } const SPIDevice rxSPIDevice = SOFT_SPIDEV_1; #else UNUSED(spiType); const SPIDevice rxSPIDevice = spiDeviceByInstance(RX_SPI_INSTANCE); IOInit(IOGetByTag(IO_TAG(RX_NSS_PIN)), OWNER_SPI, RESOURCE_SPI_CS, rxSPIDevice + 1); #endif // USE_RX_SOFTSPI #if defined(STM32F10X) RCC_AHBPeriphClockCmd(RX_NSS_GPIO_CLK_PERIPHERAL, ENABLE); RCC_AHBPeriphClockCmd(RX_CE_GPIO_CLK_PERIPHERAL, ENABLE); #endif #ifdef RX_CE_PIN // CE as OUTPUT IOInit(IOGetByTag(IO_TAG(RX_CE_PIN)), OWNER_RX_SPI, RESOURCE_RX_CE, rxSPIDevice + 1); #if defined(STM32F10X) IOConfigGPIO(IOGetByTag(IO_TAG(RX_CE_PIN)), SPI_IO_CS_CFG); #elif defined(STM32F3) || defined(STM32F4) IOConfigGPIOAF(IOGetByTag(IO_TAG(RX_CE_PIN)), SPI_IO_CS_CFG, 0); #endif RX_CE_LO(); #endif // RX_CE_PIN DISABLE_RX(); #ifdef RX_SPI_INSTANCE spiSetDivisor(RX_SPI_INSTANCE, SPI_CLOCK_STANDARD); #endif hardwareInitialised = true; }
serialPort_t *usbVcpOpen(void) { vcpPort_t *s; #ifdef STM32F4 IOInit(IOGetByTag(IO_TAG(PA11)), OWNER_USB, RESOURCE_INPUT, 0); IOInit(IOGetByTag(IO_TAG(PA12)), OWNER_USB, RESOURCE_OUTPUT, 0); USBD_Init(&USB_OTG_dev, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_CDC_cb, &USR_cb); #else Set_System(); Set_USBClock(); USB_Interrupts_Config(); USB_Init(); #endif s = &vcpPort; s->port.vTable = usbVTable; return (serialPort_t *)s; }
void resetBeeperConfig(beeperConfig_t *beeperConfig) { #ifdef BEEPER_INVERTED beeperConfig->isOD = false; beeperConfig->isInverted = true; #else beeperConfig->isOD = true; beeperConfig->isInverted = false; #endif beeperConfig->ioTag = IO_TAG(BEEPER); }
void detectHardwareRevision(void) { IO_t pin1 = IOGetByTag(IO_TAG(PB12)); IOInit(pin1, OWNER_SYSTEM, RESOURCE_INPUT, 1); IOConfigGPIO(pin1, IOCFG_IPU); IO_t pin2 = IOGetByTag(IO_TAG(PB13)); IOInit(pin2, OWNER_SYSTEM, RESOURCE_INPUT, 2); IOConfigGPIO(pin2, IOCFG_IPU); // Check hardware revision delayMicroseconds(10); // allow configuration to settle /* if both PB12 and 13 are tied to GND then it is Rev3A (mini) if only PB12 is tied to GND then it is a Rev3 (full size) */ if (!IORead(pin1)) { if (!IORead(pin2)) { hardwareRevision = BJF4_REV3A; } hardwareRevision = BJF4_REV3; } if (hardwareRevision == UNKNOWN) { hardwareRevision = BJF4_REV2; return; } /* enable the UART1 inversion PC9 TODO: once param groups are in place, inverter outputs can be moved to be simple IO outputs, and merely set them HI or LO in configuration. */ IO_t uart1invert = IOGetByTag(IO_TAG(PC9)); IOInit(uart1invert, OWNER_INVERTER, RESOURCE_OUTPUT, 2); IOConfigGPIO(uart1invert, IOCFG_AF_PP); IOLo(uart1invert); }
void usbGenerateDisconnectPulse(void) { /* Pull down PA12 to create USB disconnect pulse */ IO_t usbPin = IOGetByTag(IO_TAG(PA12)); IOConfigGPIO(usbPin, IOCFG_OUT_OD); IOLo(usbPin); delay(200); IOHi(usbPin); }
void targetPreInit(void) { switch (hardwareRevision) { case BJF4_REV3: case BJF4_MINI_REV3A: case BJF4_REV4: break; default: return; } IO_t inverter = IOGetByTag(IO_TAG(UART1_INVERTER)); IOInit(inverter, OWNER_INVERTER, 1); IOConfigGPIO(inverter, IOCFG_OUT_PP); bool high = false; serialPortConfig_t *portConfig = serialFindPortConfiguration(SERIAL_PORT_USART1); if (portConfig) { bool smartportEnabled = (portConfig->functionMask & FUNCTION_TELEMETRY_SMARTPORT); if (smartportEnabled && (telemetryConfig()->telemetry_inversion) && (feature(FEATURE_TELEMETRY))) { high = true; } } /* reverse this for rev4, as it does not use the XOR gate */ if (hardwareRevision == BJF4_REV4) { high = !high; } IOWrite(inverter, high); /* ensure the CS pin for the flash is pulled hi so any SD card initialisation does not impact the chip */ if (hardwareRevision == BJF4_REV3) { IO_t flashIo = IOGetByTag(IO_TAG(M25P16_CS_PIN)); IOConfigGPIO(flashIo, IOCFG_OUT_PP); IOHi(flashIo); IO_t sdcardIo = IOGetByTag(IO_TAG(SDCARD_SPI_CS_PIN)); IOConfigGPIO(sdcardIo, IOCFG_OUT_PP); IOHi(sdcardIo); } }
void initInverters(void) { #ifdef INVERTER_PIN_UART1 initInverter(IO_TAG(INVERTER_PIN_UART1)); #endif #ifdef INVERTER_PIN_UART2 initInverter(IO_TAG(INVERTER_PIN_UART2)); #endif #ifdef INVERTER_PIN_UART3 initInverter(IO_TAG(INVERTER_PIN_UART3)); #endif #ifdef INVERTER_PIN_USART4 initInverter(IO_TAG(INVERTER_PIN_USART4)); #endif #ifdef INVERTER_PIN_USART5 initInverter(IO_TAG(INVERTER_PIN_USART5)); #endif #ifdef INVERTER_PIN_UART6 initInverter(IO_TAG(INVERTER_PIN_UART6)); #endif }
bool mpu6000SpiDetect(void) { uint8_t in; uint8_t attemptsRemaining = 5; #ifdef MPU6000_CS_PIN mpuSpi6000CsPin = IOGetByTag(IO_TAG(MPU6000_CS_PIN)); #endif IOInit(mpuSpi6000CsPin, OWNER_MPU, RESOURCE_SPI_CS, 0); IOConfigGPIO(mpuSpi6000CsPin, SPI_IO_CS_CFG); spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON); mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET); do { delay(150); mpu6000ReadRegister(MPU_RA_WHO_AM_I, 1, &in); if (in == MPU6000_WHO_AM_I_CONST) { break; } if (!attemptsRemaining) { return false; } } while (attemptsRemaining--); mpu6000ReadRegister(MPU_RA_PRODUCT_ID, 1, &in); /* look for a product ID we recognise */ // verify product revision switch (in) { case MPU6000ES_REV_C4: case MPU6000ES_REV_C5: case MPU6000_REV_C4: case MPU6000_REV_C5: case MPU6000ES_REV_D6: case MPU6000ES_REV_D7: case MPU6000ES_REV_D8: case MPU6000_REV_D6: case MPU6000_REV_D7: case MPU6000_REV_D8: case MPU6000_REV_D9: case MPU6000_REV_D10: return true; } return false; }
/** * Start chip if available */ void rtc6705IOInit(void) { #ifdef RTC6705_POWER_PIN vtxPowerPin = IOGetByTag(IO_TAG(RTC6705_POWER_PIN)); IOInit(vtxPowerPin, OWNER_VTX, 0); DISABLE_VTX_POWER(); IOConfigGPIO(vtxPowerPin, IOCFG_OUT_PP); #endif #ifdef USE_RTC6705_CLK_HACK vtxCLKPin = IOGetByTag(IO_TAG(RTC6705_CLK_PIN)); // we assume the CLK pin will have been initialised by the SPI code. #endif vtxCSPin = IOGetByTag(IO_TAG(RTC6705_CS_PIN)); IOInit(vtxCSPin, OWNER_VTX, 0); DISABLE_RTC6705(); // GPIO bit is enabled so here so the output is not pulled low when the GPIO is set in output mode. // Note: It's critical to ensure that incorrect signals are not sent to the VTX. IOConfigGPIO(vtxCSPin, IOCFG_OUT_PP); }
void resetAdcConfig(adcConfig_t *adcConfig) { #ifdef VBAT_ADC_PIN adcConfig->vbat.enabled = true; adcConfig->vbat.ioTag = IO_TAG(VBAT_ADC_PIN); #endif #ifdef EXTERNAL1_ADC_PIN adcConfig->external1.enabled = true; adcConfig->external1.ioTag = IO_TAG(EXTERNAL1_ADC_PIN); #endif #ifdef CURRENT_METER_ADC_PIN adcConfig->currentMeter.enabled = true; adcConfig->currentMeter.ioTag = IO_TAG(CURRENT_METER_ADC_PIN); #endif #ifdef RSSI_ADC_PIN adcConfig->rssi.enabled = true; adcConfig->rssi.ioTag = IO_TAG(RSSI_ADC_PIN); #endif }