void gpioStart(void)
{
gpio_config_t gpio;
//set swd
GPIO_PinAFConfig(GPIOA, GPIO_PinSource13, GPIO_AF_SWJ);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource14, GPIO_AF_SWJ);
// Make all GPIO in by default to save power and reduce noise
gpio.pin = Pin_All & ~(Pin_13 | Pin_14 | Pin_15);
gpio.mode = Mode_AIN;
gpioInit(GPIOA, &gpio);
gpio.pin = Pin_All;
gpioInit(GPIOB, &gpio);
gpioInit(GPIOC, &gpio);
gpioInit(GPIOD, &gpio);
struct {
GPIO_TypeDef *gpio;
gpio_config_t cfg;
} gpio_setup[] = {
#ifdef LED0
{ .gpio = LED0_GPIO, .cfg = { LED0_PIN, Mode_Out_OD, Speed_50MHz } },
#endif
#ifdef LED1
{
.gpio = LED1_GPIO,
static void mpu6050GyroInit(void)
{
gpio_config_t gpio;
// MPU_INT output on rev4/5 hardware (PB13, PC13)
gpio.pin = Pin_13;
gpio.speed = Speed_2MHz;
gpio.mode = Mode_IN_FLOATING;
if (hse_value == 8000000)
gpioInit(GPIOB, &gpio);
else if (hse_value == 12000000)
gpioInit(GPIOC, &gpio);
i2cWrite(MPU6050_ADDRESS, MPU_RA_PWR_MGMT_1, 0x80); //PWR_MGMT_1 -- DEVICE_RESET 1
delay(5);
i2cWrite(MPU6050_ADDRESS, MPU_RA_SMPLRT_DIV, 0x00); //SMPLRT_DIV -- SMPLRT_DIV = 0 Sample Rate = Gyroscope Output Rate / (1 + SMPLRT_DIV)
i2cWrite(MPU6050_ADDRESS, MPU_RA_PWR_MGMT_1, 0x03); //PWR_MGMT_1 -- SLEEP 0; CYCLE 0; TEMP_DIS 0; CLKSEL 3 (PLL with Z Gyro reference)
i2cWrite(MPU6050_ADDRESS, MPU_RA_INT_PIN_CFG,
0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 << 3 | 0 << 2 | 1 << 1 | 0 << 0); // INT_PIN_CFG -- INT_LEVEL_HIGH, INT_OPEN_DIS, LATCH_INT_DIS, INT_RD_CLEAR_DIS, FSYNC_INT_LEVEL_HIGH, FSYNC_INT_DIS, I2C_BYPASS_EN, CLOCK_DIS
i2cWrite(MPU6050_ADDRESS, MPU_RA_CONFIG, mpuLowPassFilter); //CONFIG -- EXT_SYNC_SET 0 (disable input pin for data sync) ; default DLPF_CFG = 0 => ACC bandwidth = 260Hz GYRO bandwidth = 256Hz)
i2cWrite(MPU6050_ADDRESS, MPU_RA_GYRO_CONFIG, 0x18); //GYRO_CONFIG -- FS_SEL = 3: Full scale set to 2000 deg/sec
// ACC Init stuff. Moved into gyro init because the reset above would screw up accel config. Oops.
// Accel scale 8g (4096 LSB/g)
i2cWrite(MPU6050_ADDRESS, MPU_RA_ACCEL_CONFIG, 2 << 3);
}
void ledInit(bool alternative_led)
{
#if defined(LED0) || defined(LED1) || defined(LED2)
gpio_config_t cfg;
cfg.mode = Mode_Out_PP;
cfg.speed = Speed_2MHz;
#ifdef LED0
if (alternative_led) {
#ifdef LED0_PERIPHERAL_2
RCC_AHBPeriphClockCmd(LED0_PERIPHERAL_2, ENABLE);
led_config[0].gpio = LED0_GPIO_2;
led_config[0].pin = LED0_PIN_2;
#endif
} else {
RCC_AHBPeriphClockCmd(LED0_PERIPHERAL, ENABLE);
led_config[0].gpio = LED0_GPIO;
led_config[0].pin = LED0_PIN;
}
cfg.pin = led_config[0].pin;
LED0_OFF;
gpioInit(led_config[0].gpio, &cfg);
#endif
#ifdef LED1
if (alternative_led) {
#ifdef LED1_PERIPHERAL_2
RCC_AHBPeriphClockCmd(LED1_PERIPHERAL_2, ENABLE);
led_config[1].gpio = LED1_GPIO_2;
led_config[1].pin = LED1_PIN_2;
#endif
} else {
RCC_AHBPeriphClockCmd(LED1_PERIPHERAL, ENABLE);
led_config[1].gpio = LED1_GPIO;
led_config[1].pin = LED1_PIN;
}
cfg.pin = led_config[1].pin;
LED1_OFF;
gpioInit(led_config[1].gpio, &cfg);
#endif
#ifdef LED2
if (alternative_led) {
#ifdef LED2_PERIPHERAL_2
RCC_AHBPeriphClockCmd(LED2_PERIPHERAL_2, ENABLE);
led_config[2].gpio = LED2_GPIO_2;
led_config[2].pin = LED2_PIN_2;
#endif
} else {
RCC_AHBPeriphClockCmd(LED2_PERIPHERAL, ENABLE);
led_config[2].gpio = LED2_GPIO;
led_config[2].pin = LED2_PIN;
}
cfg.pin = led_config[2].pin;
LED2_OFF;
gpioInit(led_config[2].gpio, &cfg);
#endif
#else
UNUSED(alternative_led);
#endif
}
void hcsr04_init(const sonarHardware_t *initialSonarHardware)
{
gpio_config_t gpio;
EXTI_InitTypeDef EXTIInit;
sonarHardware = initialSonarHardware;
#ifdef STM32F10X
// enable AFIO for EXTI support
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
#endif
#ifdef STM32F303xC
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
/* Enable SYSCFG clock otherwise the EXTI irq handlers are not called */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
#endif
// trigger pin
gpio.pin = sonarHardware->trigger_pin;
gpio.mode = Mode_Out_PP;
gpio.speed = Speed_2MHz;
gpioInit(GPIOB, &gpio);
// echo pin
gpio.pin = sonarHardware->echo_pin;
gpio.mode = Mode_IN_FLOATING;
gpioInit(GPIOB, &gpio);
#ifdef STM32F10X
// setup external interrupt on echo pin
gpioExtiLineConfig(GPIO_PortSourceGPIOB, sonarHardware->exti_pin_source);
#endif
#ifdef STM32F303xC
gpioExtiLineConfig(EXTI_PortSourceGPIOB, sonarHardware->exti_pin_source);
#endif
EXTI_ClearITPendingBit(sonarHardware->exti_line);
EXTIInit.EXTI_Line = sonarHardware->exti_line;
EXTIInit.EXTI_Mode = EXTI_Mode_Interrupt;
EXTIInit.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTIInit.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTIInit);
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = sonarHardware->exti_irqn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SONAR_ECHO);
NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SONAR_ECHO);
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
lastMeasurementAt = millis() - 60; // force 1st measurement in hcsr04_get_distance()
}
static void mpu6050GyroInit(void)
{
uint8_t DLPFCFG;
gpio_config_t gpio;
// MPU_INT output on rev4/5 hardware (PB13, PC13)
gpio.pin = Pin_13;
gpio.speed = Speed_2MHz;
gpio.mode = Mode_IN_FLOATING;
if (hse_value == 8000000) gpioInit(GPIOB, &gpio);
else if (hse_value == 12000000) gpioInit(GPIOC, &gpio);
i2cWrite(MPU6050_ADDRESS, MPU_RA_PWR_MGMT_1, 0x80); //PWR_MGMT_1 -- DEVICE_RESET 1
delay(5);
i2cWrite(MPU6050_ADDRESS, MPU_RA_SMPLRT_DIV, 0x00); //SMPLRT_DIV -- SMPLRT_DIV = 0 Sample Rate = Gyroscope Output Rate / (1 + SMPLRT_DIV)
i2cWrite(MPU6050_ADDRESS, MPU_RA_PWR_MGMT_1, 0x03); //PWR_MGMT_1 -- SLEEP 0; CYCLE 0; TEMP_DIS 0; CLKSEL 3 (PLL with Z Gyro reference)
i2cWrite(MPU6050_ADDRESS, MPU_RA_INT_PIN_CFG, 0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 << 3 | 0 << 2 | 1 << 1 | 0 << 0); // INT_PIN_CFG -- INT_LEVEL_HIGH, INT_OPEN_DIS, LATCH_INT_DIS, INT_RD_CLEAR_DIS, FSYNC_INT_LEVEL_HIGH, FSYNC_INT_DIS, I2C_BYPASS_EN, CLOCK_DIS
/* DLPF_CFG 0: ACC 260Hz // GYRO 256Hz
DLPF_CFG 1: ACC 184Hz // GYRO 188Hz
DLPF_CFG 2: ACC 94Hz // GYRO 98Hz
DLPF_CFG 3: ACC 44Hz // GYRO 42Hz
DLPF_CFG 4: ACC 21Hz // GYRO 20Hz
DLPF_CFG 5: ACC 10Hz // GYRO 10Hz
DLPF_CFG 6: ACC 5Hz // GYRO 5Hz*/
switch (cfg.gy_lpf)
{
case 256:
DLPFCFG = 0;
break;
case 188:
DLPFCFG = 1;
break;
case 98:
DLPFCFG = 2;
break;
default:
case 42:
DLPFCFG = 3;
break;
case 20:
DLPFCFG = 4;
break;
case 10:
DLPFCFG = 5;
break;
case 5:
DLPFCFG = 6;
break;
}
i2cWrite(MPU6050_ADDRESS, MPU_RA_CONFIG, DLPFCFG); // CONFIG -- EXT_SYNC_SET 0 (disable input pin for data sync) ; default DLPF_CFG = 0 => ACC bandwidth = 260Hz GYRO bandwidth = 256Hz)
i2cWrite(MPU6050_ADDRESS, MPU_RA_GYRO_CONFIG, 0x18); // GYRO_CONFIG -- FS_SEL = 3: Full scale set to 2000 deg/sec
// i2cWrite(MPU6050_ADDRESS, MPU_RA_ACCEL_CONFIG, 2 << 3);// Accel scale 8g (4096 LSB/g)
i2cWrite(MPU6050_ADDRESS, MPU_RA_ACCEL_CONFIG, 1 << 3); // Accel scale 4g (8192 LSB/g)
}
void hcsr04_set_sonar_hardware(void)
{
#if !defined(UNIT_TEST)
#ifdef STM32F10X
// enable AFIO for EXTI support
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
#endif
#ifdef STM32F303xC
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
/* Enable SYSCFG clock otherwise the EXTI irq handlers are not called */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
#endif
gpio_config_t gpio;
// trigger pin
gpio.pin = sonarHcsr04Hardware.trigger_pin;
gpio.mode = Mode_Out_PP;
gpio.speed = Speed_2MHz;
gpioInit(sonarHcsr04Hardware.trigger_gpio, &gpio);
// echo pin
gpio.pin = sonarHcsr04Hardware.echo_pin;
gpio.mode = Mode_IN_FLOATING;
gpioInit(sonarHcsr04Hardware.echo_gpio, &gpio);
#ifdef STM32F10X
// setup external interrupt on echo pin
gpioExtiLineConfig(GPIO_PortSourceGPIOB, sonarHcsr04Hardware.exti_pin_source);
#endif
#ifdef STM32F303xC
gpioExtiLineConfig(EXTI_PortSourceGPIOB, sonarHcsr04Hardware.exti_pin_source);
#endif
EXTI_ClearITPendingBit(sonarHcsr04Hardware.exti_line);
EXTI_InitTypeDef EXTIInit;
EXTIInit.EXTI_Line = sonarHcsr04Hardware.exti_line;
EXTIInit.EXTI_Mode = EXTI_Mode_Interrupt;
EXTIInit.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTIInit.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTIInit);
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = sonarHcsr04Hardware.exti_irqn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_SONAR_ECHO);
NVIC_InitStructure.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_SONAR_ECHO);
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
#endif
}
void enableGPIOPowerUsageAndNoiseReductions(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, ENABLE);
gpio_config_t gpio;
gpio.mode = Mode_AIN;
gpio.pin = Pin_All;
gpioInit(GPIOA, &gpio);
gpioInit(GPIOB, &gpio);
gpioInit(GPIOC, &gpio);
}
void usartInitAllIOSignals(void)
{
#ifdef STM32F10X
// Set UART1 TX to output and high state to prevent a rs232 break condition on reset.
// See issue https://github.com/cleanflight/cleanflight/issues/1433
gpio_config_t gpio;
gpio.mode = Mode_Out_PP;
gpio.speed = Speed_2MHz;
gpio.pin = UART1_TX_PIN;
digitalHi(UART1_GPIO, gpio.pin);
gpioInit(UART1_GPIO, &gpio);
// Set TX of UART2 and UART3 to input with pull-up to prevent floating TX outputs.
gpio.mode = Mode_IPU;
#ifdef USE_UART2
gpio.pin = UART2_TX_PIN;
gpioInit(UART2_GPIO, &gpio);
#endif
#ifdef USE_UART3
gpio.pin = UART3_TX_PIN;
gpioInit(UART3_GPIO, &gpio);
#endif
#endif
#ifdef STM32F303
// Set TX for UART1, UART2 and UART3 to input with pull-up to prevent floating TX outputs.
gpio_config_t gpio;
gpio.mode = Mode_IPU;
gpio.speed = Speed_2MHz;
#ifdef USE_UART1
gpio.pin = UART1_TX_PIN;
gpioInit(UART1_GPIO, &gpio);
#endif
//#ifdef USE_UART2
// gpio.pin = UART2_TX_PIN;
// gpioInit(UART2_GPIO, &gpio);
//#endif
#ifdef USE_UART3
gpio.pin = UART3_TX_PIN;
gpioInit(UART3_GPIO, &gpio);
#endif
#endif
}
void hcsr04_init(sonar_config_t config)
{
gpio_config_t gpio;
EXTI_InitTypeDef EXTIInit;
// enable AFIO for EXTI support - already done is drv_system.c
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph, ENABLE);
switch(config) {
case sonar_pwm56:
trigger_pin = Pin_8; // PWM5 (PB8) - 5v tolerant
echo_pin = Pin_9; // PWM6 (PB9) - 5v tolerant
exti_line = EXTI_Line9;
exti_pin_source = GPIO_PinSource9;
exti_irqn = EXTI9_5_IRQn;
break;
case sonar_rc78:
trigger_pin = Pin_0; // RX7 (PB0) - only 3.3v ( add a 1K Ohms resistor )
echo_pin = Pin_1; // RX8 (PB1) - only 3.3v ( add a 1K Ohms resistor )
exti_line = EXTI_Line1;
exti_pin_source = GPIO_PinSource1;
exti_irqn = EXTI1_IRQn;
break;
}
// tp - trigger pin
gpio.pin = trigger_pin;
gpio.mode = Mode_Out_PP;
gpio.speed = Speed_2MHz;
gpioInit(GPIOB, &gpio);
// ep - echo pin
gpio.pin = echo_pin;
gpio.mode = Mode_IN_FLOATING;
gpioInit(GPIOB, &gpio);
// setup external interrupt on echo pin
gpioExtiLineConfig(GPIO_PortSourceGPIOB, exti_pin_source);
EXTI_ClearITPendingBit(exti_line);
EXTIInit.EXTI_Line = exti_line;
EXTIInit.EXTI_Mode = EXTI_Mode_Interrupt;
EXTIInit.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
EXTIInit.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTIInit);
NVIC_EnableIRQ(exti_irqn);
last_measurement = millis() - 60; // force 1st measurement in hcsr04_get_distance()
}
static void i2cUnstick(void)
{
GPIO_TypeDef *gpio;
gpio_config_t cfg;
uint16_t scl, sda;
int i;
// prepare pins
gpio = i2cHardwareMap[I2Cx_index].gpio;
scl = i2cHardwareMap[I2Cx_index].scl;
sda = i2cHardwareMap[I2Cx_index].sda;
digitalHi(gpio, scl | sda);
cfg.pin = scl | sda;
cfg.speed = Speed_2MHz;
cfg.mode = Mode_Out_OD;
gpioInit(gpio, &cfg);
for (i = 0; i < 8; i++) {
// Wait for any clock stretching to finish
while (!digitalIn(gpio, scl))
delayMicroseconds(10);
// Pull low
digitalLo(gpio, scl); // Set bus low
delayMicroseconds(10);
// Release high again
digitalHi(gpio, scl); // Set bus high
delayMicroseconds(10);
}
// Generate a start then stop condition
// SCL PB10
// SDA PB11
digitalLo(gpio, sda); // Set bus data low
delayMicroseconds(10);
digitalLo(gpio, scl); // Set bus scl low
delayMicroseconds(10);
digitalHi(gpio, scl); // Set bus scl high
delayMicroseconds(10);
digitalHi(gpio, sda); // Set bus sda high
// Init pins
cfg.pin = scl | sda;
cfg.speed = Speed_2MHz;
cfg.mode = Mode_AF_OD;
gpioInit(gpio, &cfg);
}
void setUp(void){
instantiateCPU();
gpioInit(0x0, 0xFFFF);
pcToLoad = malloc(sizeof(uint32_t));
}
void boardInit() {
// create queues for usart
usartRxQueue = xQueueCreate(256, sizeof(char));
usartTxQueue = xQueueCreate(256, sizeof(char));
// create a queue from commTask to kalmanTask
comm2kalmanQueue = xQueueCreate(1, sizeof(comm2kalmanMessage_t));
// create a queue from mpcTask to commTask
mpc2commQueue = xQueueCreate(1, sizeof(mpc2commMessage_t));
// create a queue from kalmanTask to mpcTask
kalman2mpcQueue = xQueueCreate(1, sizeof(kalman2mpcMessage_t));
// create a queue from kalmanTask to commTask
kalman2commQueue = xQueueCreate(1, sizeof(kalman2commMessage_t));
// create a queue from commTask to mpcTask
comm2mpcQueue = xQueueCreate(50, sizeof(comm2mpcMessage_t));
// create a queue from commTask to mpcTask
resetKalmanQueue = xQueueCreate(1, sizeof(resetKalmanMessage_t));
// queue for setting particular value of KF
setKalmanQueue = xQueueCreate(1, sizeof(resetKalmanMessage_t));
// set th clock and initialize the GPIO
gpioInit();
// set the UART
init_USART4(115200);
}
void gpioSetValue (uint32_t portNum, uint32_t bitPos, uint32_t bitVal)
{
if (!_gpioInitialised) gpioInit();
// Get the appropriate register (handled this way to optimise code size)
REG32 *gpiodata = &GPIO_GPIO0DATA;
switch (portNum)
{
case 0:
gpiodata = &GPIO_GPIO0DATA;
break;
case 1:
gpiodata = &GPIO_GPIO1DATA;
break;
case 2:
gpiodata = &GPIO_GPIO2DATA;
break;
case 3:
gpiodata = &GPIO_GPIO3DATA;
break;
}
// Toggle value
bitVal == 1 ? (*gpiodata |= (1 << bitPos)) : (*gpiodata &= ~(1 << bitPos));
}
int main()
{
while(true){
Reset();
systickInit();
gpioInit();
adcInit();
lcdInit();
tsInit();
welcomeScreen();
#ifdef DEBUG
ledInit();
#endif
spiInit();
while(!IsRebootRequired()){
if(IsSynchronizationRequired()){
AssertGoBusIRQ();
}
#ifdef DEBUG
GPIO_ToggleBits(GPIOC, GPIO_Pin_13);
delay(5);
#endif
}
}
}
void systemInit() {
cpuInit(); // Configure the CPU
systickInit(CFG_SYSTICK_DELAY_IN_MS); // Start systick timer
gpioInit(); // Enable GPIO
pmuInit(); // Configure power management
step_timer_init();
// Initialise USB CDC
#ifdef CFG_USBCDC
lastTick = systickGetTicks(); // Used to control output/printf timing
CDC_Init(); // Initialise VCOM
USB_Init(); // USB Initialization
USB_Connect(TRUE); // USB Connect
// Wait until USB is configured or timeout occurs
uint32_t usbTimeout = 0;
while (usbTimeout < CFG_USBCDC_INITTIMEOUT / 10) {
if (USB_Configuration)
break;
systickDelay(10); // Wait 10ms
usbTimeout++;
}
#endif
// Printf can now be used with UART or USBCDC
}
uint32_t gpioGetValue (uint32_t portNum, uint32_t bitPos)
{
if (!_gpioInitialised) gpioInit();
uint32_t value = 0;
switch (portNum)
{
case 0:
value = (GPIO_GPIO0DATA & (1 << bitPos)) ? 1 : 0;
break;
case 1:
value = (GPIO_GPIO1DATA & (1 << bitPos)) ? 1 : 0;
break;
case 2:
value = (GPIO_GPIO2DATA & (1 << bitPos)) ? 1 : 0;
break;
case 3:
value = (GPIO_GPIO3DATA & (1 << bitPos)) ? 1 : 0;
break;
default:
break;
}
return value;
}
void gpioSetDir (uint32_t portNum, uint32_t bitPos, gpioDirection_t dir)
{
if (!_gpioInitialised) gpioInit();
// Get the appropriate register (handled this way to optimise code size)
REG32 *gpiodir = &GPIO_GPIO0DIR;
switch (portNum)
{
case 0:
gpiodir = &GPIO_GPIO0DIR;
break;
case 1:
gpiodir = &GPIO_GPIO1DIR;
break;
case 2:
gpiodir = &GPIO_GPIO2DIR;
break;
case 3:
gpiodir = &GPIO_GPIO3DIR;
break;
}
// Toggle dir
dir == gpioDirection_Output ? (*gpiodir |= (1 << bitPos)) : (*gpiodir &= ~(1 << bitPos));
}
/******************************************************************************
* Initialize gpio
*****************************************************************************/
static int __init gpio_mod_init(void){
int ret;
dev_t dev;
DPRINT("\ngpio_mod_init\n");
gpioInit();
dev = MKDEV(GPIO_MAJOR, 0);
ret = register_chrdev_region(dev, NUM_GPIO_DEVICES, "gpio");
if(ret){
printk("gpio: failed to register char device\n");
return ret;
}
gpio_cdev = cdev_alloc();
cdev_init(gpio_cdev, &gpio_fops);
gpio_cdev->owner = THIS_MODULE;
gpio_cdev->ops = &gpio_fops;
ret = cdev_add(gpio_cdev, dev, NUM_GPIO_DEVICES);
if(ret){
printk("gpio: Error adding\n");
}
return ret;
}
//MAIN
int main(void)
{
printf("Hello World!\r\n"); //confirm dingus program has started
//INITS
SystemInit();
gpioInit();
timInit();
TIM_ITConfig(TIM6, TIM_IT_Update, DISABLE); //DISABLE INTERRUPTS FOR AUDIO INITS
EVAL_AUDIO_Init(OUTPUT_DEVICE_AUTO, 100, SAMPLE_FREQ); //should default to headphones, full volume, 48kHz
EVAL_AUDIO_Play((uint16_t*) audio_buffer, BUFF); //add once there's audio to hear
TIM_ITConfig(TIM6, TIM_IT_Update, ENABLE); //ENABLE INTERRUPTS AFTER
printf("Ready!\n"); //print when everythin' is done
voiceInit(&voice, 1.f, 1.f);
//YEAH BABY
while(1)
{
printf("\nP\nI\nZ\nZ\nA\n"); //confirm in loop with pizza spelling contest
delay(80000);
}
}
void mpuIntExtiInit(void)
{
gpio_config_t gpio;
static bool mpuExtiInitDone = false;
if (mpuExtiInitDone || !mpuIntExtiConfig) {
return;
}
#ifdef STM32F303
if (mpuIntExtiConfig->gpioAHBPeripherals) {
RCC_AHBPeriphClockCmd(mpuIntExtiConfig->gpioAHBPeripherals, ENABLE);
}
#endif
#ifdef STM32F10X
if (mpuIntExtiConfig->gpioAPB2Peripherals) {
RCC_APB2PeriphClockCmd(mpuIntExtiConfig->gpioAPB2Peripherals, ENABLE);
}
#endif
gpio.pin = mpuIntExtiConfig->gpioPin;
gpio.speed = Speed_2MHz;
gpio.mode = Mode_IN_FLOATING;
gpioInit(mpuIntExtiConfig->gpioPort, &gpio);
configureMPUDataReadyInterruptHandling();
mpuExtiInitDone = true;
}
static void mpu6050GyroInit(sensor_align_e align)
{
gpio_config_t gpio;
// MPU_INT output on rev5 hardware (PC13). rev4 was on PB13, conflicts with SPI devices
if (hw_revision >= NAZE32_REV5) {
gpio.pin = Pin_13;
gpio.speed = Speed_2MHz;
gpio.mode = Mode_IN_FLOATING;
gpioInit(GPIOC, &gpio);
}
i2cWrite(MPU6050_ADDRESS, MPU_RA_PWR_MGMT_1, 0x80); //PWR_MGMT_1 -- DEVICE_RESET 1
delay(100);
i2cWrite(MPU6050_ADDRESS, MPU_RA_SMPLRT_DIV, 0x00); //SMPLRT_DIV -- SMPLRT_DIV = 0 Sample Rate = Gyroscope Output Rate / (1 + SMPLRT_DIV)
i2cWrite(MPU6050_ADDRESS, MPU_RA_PWR_MGMT_1, 0x03); //PWR_MGMT_1 -- SLEEP 0; CYCLE 0; TEMP_DIS 0; CLKSEL 3 (PLL with Z Gyro reference)
i2cWrite(MPU6050_ADDRESS, MPU_RA_INT_PIN_CFG, 0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 << 3 | 0 << 2 | 1 << 1 | 0 << 0); // INT_PIN_CFG -- INT_LEVEL_HIGH, INT_OPEN_DIS, LATCH_INT_DIS, INT_RD_CLEAR_DIS, FSYNC_INT_LEVEL_HIGH, FSYNC_INT_DIS, I2C_BYPASS_EN, CLOCK_DIS
i2cWrite(MPU6050_ADDRESS, MPU_RA_CONFIG, mpuLowPassFilter); //CONFIG -- EXT_SYNC_SET 0 (disable input pin for data sync) ; default DLPF_CFG = 0 => ACC bandwidth = 260Hz GYRO bandwidth = 256Hz)
i2cWrite(MPU6050_ADDRESS, MPU_RA_GYRO_CONFIG, INV_FSR_2000DPS << 3);
// ACC Init stuff. Moved into gyro init because the reset above would screw up accel config. Oops.
// Accel scale 8g (4096 LSB/g)
i2cWrite(MPU6050_ADDRESS, MPU_RA_ACCEL_CONFIG, INV_FSR_8G << 3);
if (align > 0)
gyroAlign = align;
}
static void gpio_set_mode(GPIO_TypeDef* gpio, uint16_t pin, GPIO_Mode mode) {
gpio_config_t cfg;
cfg.pin = pin;
cfg.mode = mode;
cfg.speed = Speed_10MHz;
gpioInit(gpio, &cfg);
}
inline void gpioSetValue (const uint32_t portNum, const uint32_t bitPos, const uint32_t bitVal)
{
if (!_gpioInitialised) gpioInit();
// Take advantage of the fact the GPIO registers are bit-banded
(*(pREG32 ((GPIO_GPIO0_BASE + (portNum << 16)) + ((1 << bitPos) << 2)))) = bitVal ? 0xFFF : 0;
}
void initSensors(void){
// TODO: init the GPS here
fd = init_I2C();
init_compass(fd);
gpioInit();
gpsRet = init_GPS();
}
int main(int argc, char *argv[]) {
int i,j,k,portFD;
unsigned char data[1024];
gettimeofday(&tStart,NULL);
output(1,"HP iPAQ 214 BT chip GPIO twiddling util v1.1\n----------------------------------\n");
#ifndef NOIO
gpioInit(1);
#else
output(1,"TESTING MODE - NOT USING IO\n");
#endif
if(argc > 1 && strcmp(argv[1],"on")==0){
portFD=openPort();
if(portFD == -1){ return 0; }
output(1,"Shutting down chip first...\n");
#ifndef NOIO
shutdownChip();
tcflush(portFD, TCIOFLUSH); //flush buffers again
#endif
output(1,"Waiting 2 secs.\n");
sleep(2);
output(1,"Bringing up chip...\n");
bringUpChip();
output(1,"Resetting chip...\n");
#ifndef NOIO
sendReset(portFD);
#endif
output(1,"Turning LED on.\n");
#ifndef NOIO
gpioSet(3,1);
#endif
output(1,"closing port..."); fflush(stdout);
close(portFD);
output(1,"done\n");
}else if(argc > 1 && strcmp(argv[1],"off")==0){
output(1,"Shutting down chip...\n");
#ifndef NOIO
shutdownChip();
gpioSet(3,0); //turn LED off
#endif
}else
printf("usage %s on/off\n",argv[0]);
#ifndef NOIO
gpioCleanup();
#endif
return 0;
}
/**
* \brief CSL Audio Class main function
*
* \param None
*
* \return None
*/
void main(void)
{
CSL_Status status;
Uint32 gpioIoDir;
// Disable trace to reduce MHz load
//TRC_disable(TRC_GBLTARG);
/* Clock gate all peripherals */
CSL_SYSCTRL_REGS->PCGCR1 = 0x7FFF;
CSL_SYSCTRL_REGS->PCGCR2 = 0x007F;
#if defined(USE_I2S0_PB) || defined(USE_I2S0_REC)
/* SP0 Mode 1 (I2S0 and GP[5:4]) */
CSL_FINST(CSL_SYSCTRL_REGS->EBSR, SYS_EBSR_SP0MODE, MODE1);
#else
/* SP0 Mode 2 (GP[5:0]) -- GPIO02/GPIO04 for debug */
CSL_FINST(CSL_SYSCTRL_REGS->EBSR, SYS_EBSR_SP0MODE, MODE2);
#endif
#if defined(USE_I2S1_PB) || defined(USE_I2S1_REC)
/* SP1 Mode 1 (I2S1 and GP[11:10]) */
CSL_FINST(CSL_SYSCTRL_REGS->EBSR, SYS_EBSR_SP1MODE, MODE1);
#else
/* SP1 Mode 2 (GP[11:6]) */
CSL_FINST(CSL_SYSCTRL_REGS->EBSR, SYS_EBSR_SP1MODE, MODE2); /* need GPIO10 for AIC3204 reset */
#endif
/* PP Mode 1 (SPI, GPIO[17:12], UART, and I2S2) -- note this allows UART */
CSL_FINST(CSL_SYSCTRL_REGS->EBSR, SYS_EBSR_PPMODE, MODE1);
/* Reset C5515 -- ungates all peripherals */
C5515_reset();
/* Initialize DSP PLL */
status = pll_sample();
if (status != CSL_SOK)
{
LOG_printf(&trace, "ERROR: Unable to initialize PLL");
}
/* Clear pending timer interrupts */
CSL_SYSCTRL_REGS->TIAFR = 0x7;
#if !defined(USE_I2S0_PB) && !defined(USE_I2S0_REC)
/* GPIO02 and GPIO04 for debug */
/* GPIO10 for AIC3204 reset */
gpioIoDir = (((Uint32)CSL_GPIO_DIR_OUTPUT)<<CSL_GPIO_PIN2) |
(((Uint32)CSL_GPIO_DIR_OUTPUT)<<CSL_GPIO_PIN4) |
(((Uint32)CSL_GPIO_DIR_OUTPUT)<<CSL_GPIO_PIN10);
#else
/* GPIO10 for AIC3204 reset */
gpioIoDir = (((Uint32)CSL_GPIO_DIR_OUTPUT)<<CSL_GPIO_PIN10)
#endif
status = gpioInit(gpioIoDir, 0x00000000, 0x00000000);
if (status != GPIOCTRL_SOK)
{
LOG_printf(&trace, "ERROR: Unable to initialize GPIO");
}
/* Enable the USB LDO */
*(volatile ioport unsigned int *)(0x7004) |= 0x0001;
}
void fpga_spiinitgpio(uint32_t DSP_FPGA_CSGPIO)
{
gpioInit();
gpioSetDirection(DSP_FPGA_CSGPIO,GPIO_OUT);
gpioSetOutput(DSP_FPGA_CSGPIO);
}
static void pwmGPIOConfig(GPIO_TypeDef *gpio, uint32_t pin, GPIO_Mode mode)
{
gpio_config_t cfg;
cfg.pin = pin;
cfg.mode = mode;
cfg.speed = Speed_2MHz;
gpioInit(gpio, &cfg);
}
/*************************************************************************
Initialization of the I2C bus interface. Need to be called only once
*************************************************************************/
void lib_i2c_init(void)
{
gpio_config_t gpio;
gpio.pin = Pin_10 | Pin_11;
gpio.speed = Speed_2MHz;
gpio.mode = Mode_Out_OD;
gpioInit(GPIOB, &gpio);
}
void i2cInit(I2CDevice index)
{
gpio_config_t gpio;
gpio.pin = I2C_PINS;
gpio.speed = Speed_2MHz;
gpio.mode = Mode_Out_OD;
gpioInit(I2C_GPIO, &gpio);
}
