void runInit(void) {
float acc[3], mag[3];
float pres;
int i;
memset((void *)&runData, 0, sizeof(runData));
runData.runFlag = CoCreateFlag(1, 0); // auto reset
runTaskStack = aqStackInit(RUN_TASK_SIZE, "RUN");
runData.runTask = CoCreateTask(runTaskCode, (void *)0, RUN_PRIORITY, &runTaskStack[RUN_TASK_SIZE-1], RUN_TASK_SIZE);
acc[0] = IMU_ACCX;
acc[1] = IMU_ACCY;
acc[2] = IMU_ACCZ;
mag[0] = IMU_MAGX;
mag[1] = IMU_MAGY;
mag[2] = IMU_MAGZ;
pres = AQ_PRESSURE;
// initialize sensor history
for (i = 0; i < RUN_SENSOR_HIST; i++) {
runData.accHist[0][i] = acc[0];
runData.accHist[1][i] = acc[1];
runData.accHist[2][i] = acc[2];
runData.magHist[0][i] = mag[0];
runData.magHist[1][i] = mag[1];
runData.magHist[2][i] = mag[2];
runData.presHist[i] = pres;
runData.sumAcc[0] += acc[0];
runData.sumAcc[1] += acc[1];
runData.sumAcc[2] += acc[2];
runData.sumMag[0] += mag[0];
runData.sumMag[1] += mag[1];
runData.sumMag[2] += mag[2];
runData.sumPres += pres;
}
runData.sensorHistIndex = 0;
runData.bestHacc = 1000.0f;
runData.accMask = 1000.0f;
// use altUkf altitude & vertical velocity estimates to start with
runData.altPos = &ALT_POS;
runData.altVel = &ALT_VEL;
#ifdef USE_MAVLINK
// configure px4flow sensor
// mavlinkSendParameter(81, 50, "BFLOW_V_THLD", 2500.0f);
// mavlinkSendParameter(81, 50, "BFLOW_F_THLD", 100.0f);
mavlinkSendParameter(81, 50, "BFLOW_GYRO_COM", 0.0f);
mavlinkSendParameter(81, 50, "USB_SEND_VIDEO", 0.0f);
#endif
}
void
queue_init(queue_t *q, uint8_t *buf, uint8_t size) {
ASSERT((q->flag = CoCreateFlag(1, 0)) != E_CREATE_FAIL);
q->p_bot = q->p_read = q->p_write = buf;
q->p_top = buf + size;
q->size = q->wakeup = size;
q->count = 0;
q->cb_func = NULL;
q->cb_arg = NULL;
}
// New hardware SPI driver for LCD
void initLcdSpi()
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_LCD, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_LCD_RST, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_LCD_NCS, ENABLE);
RCC->APB1ENR |= RCC_APB1ENR_SPI3EN ; // Enable clock
// APB1 clock / 2 = 133nS per clock
SPI3->CR1 = 0 ; // Clear any mode error
SPI3->CR1 = SPI_CR1_SSM | SPI_CR1_SSI | SPI_CR1_CPOL | SPI_CR1_CPHA ;
SPI3->CR2 = 0 ;
SPI3->CR1 |= SPI_CR1_MSTR ; // Make sure in case SSM/SSI needed to be set first
SPI3->CR1 |= SPI_CR1_SPE ;
configure_pins( PIN_LCD_NCS, PIN_OUTPUT | PIN_PORTA | PIN_PUSHPULL | PIN_OS25 | PIN_NO_PULLUP ) ;
configure_pins( PIN_LCD_RST, PIN_OUTPUT | PIN_PORTD | PIN_PUSHPULL | PIN_OS25 | PIN_NO_PULLUP ) ;
configure_pins( PIN_LCD_A0, PIN_OUTPUT | PIN_PORTC | PIN_PUSHPULL | PIN_OS25 | PIN_NO_PULLUP ) ;
configure_pins( PIN_LCD_MOSI|PIN_LCD_CLK, PIN_PORTC | PIN_PUSHPULL | PIN_OS50 | PIN_NO_PULLUP | PIN_PER_6 | PIN_PERIPHERAL ) ;
setupSPIdma() ;
LcdFlag = CoCreateFlag( TRUE, 0 ) ;
}
void CreateJoyFlags(void){
uint8_t i;
for(i=0;i<5;i++){
keyFlag[i]=CoCreateFlag(1,0);
}
}
serialPort_t *serialOpen(USART_TypeDef *USARTx, unsigned int baud, uint16_t flowControl, unsigned int rxBufSize, unsigned int txBufSize) {
DMA_InitTypeDef DMA_InitStructure;
serialPort_t *s = 0;
// Enable USART clocks/ports
#ifdef SERIAL_UART1_PORT
if (USARTx == USART1) {
s = serialUSART1(flowControl, rxBufSize, txBufSize);
}
#endif
#ifdef SERIAL_UART2_PORT
if (USARTx == USART2) {
s = serialUSART2(flowControl, rxBufSize, txBufSize);
}
#endif
#ifdef SERIAL_UART3_PORT
if (USARTx == USART3) {
s = serialUSART3(flowControl, rxBufSize, txBufSize);
}
#endif
#ifdef SERIAL_UART4_PORT
if (USARTx == UART4) {
s = serialUSART4(flowControl, rxBufSize, txBufSize);
}
#endif
#ifdef SERIAL_UART5_PORT
if (USARTx == UART5) {
s = serialUSART5(flowControl, rxBufSize, txBufSize);
}
#endif
#ifdef SERIAL_UART6_PORT
if (USARTx == USART6) {
s = serialUSART6(flowControl, rxBufSize, txBufSize);
}
#endif
s->waitFlag = CoCreateFlag(0, 0); // manual reset
s->USARTx = USARTx;
s->rxHead = s->rxTail = 0;
s->txHead = s->txTail = 0;
s->baudRate = baud;
s->flowControl = flowControl;
s->parity = USART_Parity_No;
s->stopBits = USART_StopBits_1;
serialOpenUART(s);
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)USARTx + 0x04;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
// Configure DMA for rx
if (s->rxDMAStream) {
DMA_DeInit(s->rxDMAStream);
DMA_InitStructure.DMA_Channel = s->rxDMAChannel;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)s->rxBuf;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_BufferSize = s->rxBufSize;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(s->rxDMAStream, &DMA_InitStructure);
DMA_ClearFlag(s->rxDMAStream, s->rxDmaFlags);
DMA_Cmd(s->rxDMAStream, ENABLE);
USART_DMACmd(USARTx, USART_DMAReq_Rx, ENABLE);
s->rxPos = DMA_GetCurrDataCounter(s->rxDMAStream);
}
// otherwise use ISR
else {
USART_ITConfig(USARTx, USART_IT_RXNE, ENABLE);
}
// Configure DMA for tx
if (s->txDMAStream) {
DMA_DeInit(s->txDMAStream);
DMA_InitStructure.DMA_Channel = s->txDMAChannel;
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
DMA_InitStructure.DMA_BufferSize = (s->txBufSize != 0) ? s->txBufSize : 16;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(s->txDMAStream, &DMA_InitStructure);
DMA_SetCurrDataCounter(s->txDMAStream, 0);
DMA_ITConfig(s->txDMAStream, DMA_IT_TC, ENABLE);
USART_DMACmd(USARTx, USART_DMAReq_Tx, ENABLE);
}
// otherwise use ISR
else {
USART_ITConfig(USARTx, USART_IT_TXE, ENABLE);
}
// use this port for STDIO if not already defined
if (serialSTDIO == 0)
serialSTDIO = s;
return s;
}
void btTask(void* pdata)
{
uint8_t byte;
btFlag = CoCreateFlag(true, false);
btTx.size = 0;
// Look for BT module baudrate, try 115200, and 9600
// Already initialised to g_eeGeneral.bt_baudrate
// 0 : 115200, 1 : 9600, 2 : 19200
uint32_t x = g_eeGeneral.btBaudrate;
btStatus = btPollDevice() ; // Do we get a response?
for (int y=0; y<2; y++) {
if (btStatus == 0) {
x += 1 ;
if (x > 2) {
x = 0 ;
}
btSetBaudrate(x) ;
CoTickDelay(1) ; // 2mS
btStatus = btPollDevice() ; // Do we get a response?
}
}
if (btStatus) {
btStatus = x + 1 ;
if ( x != g_eeGeneral.btBaudrate ) {
x = g_eeGeneral.btBaudrate ;
// Need to change Bt Baudrate
btChangeBaudrate( x ) ;
btStatus += (x+1) * 10 ;
btSetBaudrate( x ) ;
}
}
else {
btInit();
}
CoTickDelay(1) ;
btPollDevice(); // Do we get a response?
while (1) {
uint32_t x = CoWaitForSingleFlag(btFlag, 10); // Wait for data in Fifo
if (x == E_OK) {
// We have some data in the Fifo
while (btTxFifo.pop(byte)) {
btTxBuffer[btTx.size++] = byte;
if (btTx.size > 31) {
btSendBuffer();
}
}
}
else if (btTx.size) {
btSendBuffer();
}
}
}
void dIMUInit(void) {
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
#ifdef DIMU_HAVE_MPU6000
mpu6000PreInit();
#endif
#ifdef DIMU_HAVE_MAX21100
max21100PreInit();
#endif
#ifdef DIMU_HAVE_EEPROM
eepromPreInit();
#endif
#ifdef DIMU_HAVE_HMC5983
hmc5983PreInit();
#endif
#ifdef DIMU_HAVE_MS5611
ms5611PreInit();
#endif
#ifdef DIMU_HAVE_MPU6000
mpu6000Init();
#endif
#ifdef DIMU_HAVE_MAX21100
max21100Init();
#endif
#ifdef DIMU_HAVE_EEPROM
eepromInit();
// dIMUWriteCalib();
dIMUReadCalib();
#endif
#ifdef DIMU_HAVE_HMC5983
if (hmc5983Init() == 0)
AQ_NOTICE("DIMU: MAG sensor init failed!\n");
#endif
#ifdef DIMU_HAVE_MS5611
if (ms5611Init() == 0)
AQ_NOTICE("DIMU: PRES sensor init failed!\n");
#endif
dIMUTaskStack = aqStackInit(DIMU_STACK_SIZE, "DIMU");
dImuData.flag = CoCreateFlag(1, 0);
dImuData.task = CoCreateTask(dIMUTaskCode, (void *)0, DIMU_PRIORITY, &dIMUTaskStack[DIMU_STACK_SIZE-1], DIMU_STACK_SIZE);
// setup digital IMU timer
DIMU_EN;
// Time base configuration for 1MHz (us)
TIM_TimeBaseStructure.TIM_Period = 0xffff;
TIM_TimeBaseStructure.TIM_Prescaler = (DIMU_CLOCK / 1000000) - 1;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(DIMU_TIM, &TIM_TimeBaseStructure);
// reset
TIM_SetCounter(DIMU_TIM, 0);
// Output Compare for alarms
TIM_OCStructInit(&TIM_OCInitStructure);
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Inactive;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OC1Init(DIMU_TIM, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(DIMU_TIM, TIM_OCPreload_Disable);
TIM_OC2Init(DIMU_TIM, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(DIMU_TIM, TIM_OCPreload_Disable);
// Enable the global Interrupt
NVIC_InitStructure.NVIC_IRQChannel = DIMU_IRQ_CH;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// reset
TIM_SetCounter(DIMU_TIM, 0);
dIMUCancelAlarm1();
// go...
TIM_Cmd(DIMU_TIM, ENABLE);
#ifdef DIMU_HAVE_MPU6000
mpu6000Enable();
#endif
#ifdef DIMU_HAVE_MAX21100
max21100Enable();
#endif
#ifdef DIMU_HAVE_HMC5983
hmc5983Enable();
#endif
#ifdef DIMU_HAVE_MS5611
ms5611Enable();
#endif
// setup IMU timestep alarm
dImuData.nextPeriod = DIMU_TIM->CCR2 + DIMU_INNER_PERIOD;
DIMU_TIM->CCR2 = dImuData.nextPeriod;
DIMU_TIM->DIER |= TIM_IT_CC2;
#ifdef DIMU_HAVE_MPU6000
mpu6600InitialBias();
#endif
#ifdef DIMU_HAVE_MAX21100
max21100InitialBias();
#endif
#ifdef DIMU_HAVE_MS5611
ms5611InitialBias();
#endif
}
void adcInit(void) {
GPIO_InitTypeDef GPIO_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_InitTypeDef ADC_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
AQ_NOTICE("ADC init\n");
memset((void *)&adcData, 0, sizeof(adcData));
// energize mag's set/reset circuit
adcData.magSetReset = digitalInit(GPIOE, GPIO_Pin_10, 1);
// use auto-zero function of gyros
adcData.rateAutoZero = digitalInit(GPIOE, GPIO_Pin_8, 0);
// bring ACC's SELF TEST line low
adcData.accST = digitalInit(GPIOE, GPIO_Pin_12, 0);
// bring ACC's SCALE line low (ADXL3X5 requires this line be tied to GND or left floating)
adcData.accScale = digitalInit(GPIOC, GPIO_Pin_15, 0);
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5;
GPIO_Init(GPIOC, &GPIO_InitStructure);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 | RCC_APB2Periph_ADC3, ENABLE);
adcData.sample = ADC_SAMPLES - 1;
// Use STM32F4's Triple Regular Simultaneous Mode capable of ~ 6M samples per second
DMA_DeInit(ADC_DMA_STREAM);
DMA_InitStructure.DMA_Channel = ADC_DMA_CHANNEL;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)adcDMAData.adc123Raw1;
DMA_InitStructure.DMA_PeripheralBaseAddr = ((uint32_t)0x40012308);
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_BufferSize = ADC_CHANNELS * 3 * 2;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(ADC_DMA_STREAM, &DMA_InitStructure);
DMA_ITConfig(ADC_DMA_STREAM, DMA_IT_HT | DMA_IT_TC, ENABLE);
DMA_ClearITPendingBit(ADC_DMA_STREAM, ADC_DMA_FLAGS);
DMA_Cmd(ADC_DMA_STREAM, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = ADC_DMA_IRQ;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// ADC Common Init
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_CommonInitStructure.ADC_Mode = ADC_TripleMode_RegSimult;
ADC_CommonInitStructure.ADC_Prescaler = ADC_Prescaler_Div2;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
ADC_CommonInit(&ADC_CommonInitStructure);
// ADC1 configuration
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfConversion = 16;
ADC_Init(ADC1, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGX, 1, ADC_SAMPLE_TIME); // magX
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGX, 2, ADC_SAMPLE_TIME); // magX
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGX, 3, ADC_SAMPLE_TIME); // magX
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGX, 4, ADC_SAMPLE_TIME); // magX
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGY, 5, ADC_SAMPLE_TIME); // magY
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGY, 6, ADC_SAMPLE_TIME); // magY
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGY, 7, ADC_SAMPLE_TIME); // magY
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGY, 8, ADC_SAMPLE_TIME); // magY
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGZ, 9, ADC_SAMPLE_TIME); // magZ
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGZ, 10, ADC_SAMPLE_TIME); // magZ
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGZ, 11, ADC_SAMPLE_TIME); // magZ
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_MAGZ, 12, ADC_SAMPLE_TIME); // magZ
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_RATEX, 13, ADC_SAMPLE_TIME); // rateX
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_RATEX, 14, ADC_SAMPLE_TIME); // rateX
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_RATEX, 15, ADC_SAMPLE_TIME); // rateX
ADC_RegularChannelConfig(ADC1, ADC_CHANNEL_RATEX, 16, ADC_SAMPLE_TIME); // rateX
// Enable ADC1 DMA since ADC1 is the Master
ADC_DMACmd(ADC1, ENABLE);
// ADC2 configuration
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfConversion = 16;
ADC_Init(ADC2, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_RATEY, 1, ADC_SAMPLE_TIME); // rateY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_RATEY, 2, ADC_SAMPLE_TIME); // rateY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_RATEY, 3, ADC_SAMPLE_TIME); // rateY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_RATEY, 4, ADC_SAMPLE_TIME); // rateY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCX, 5, ADC_SAMPLE_TIME); // accX
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCX, 6, ADC_SAMPLE_TIME); // accX
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCX, 7, ADC_SAMPLE_TIME); // accX
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCX, 8, ADC_SAMPLE_TIME); // accX
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCY, 9, ADC_SAMPLE_TIME); // accY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCY, 10, ADC_SAMPLE_TIME); // accY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCY, 11, ADC_SAMPLE_TIME); // accY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCY, 12, ADC_SAMPLE_TIME); // accY
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCZ, 13, ADC_SAMPLE_TIME); // accZ
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCZ, 14, ADC_SAMPLE_TIME); // accZ
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCZ, 15, ADC_SAMPLE_TIME); // accZ
ADC_RegularChannelConfig(ADC2, ADC_CHANNEL_ACCZ, 16, ADC_SAMPLE_TIME); // accZ
// ADC3 configuration
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfConversion = 16;
ADC_Init(ADC3, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_RATEZ, 1, ADC_SAMPLE_TIME); // rateZ
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_RATEZ, 2, ADC_SAMPLE_TIME); // rateZ
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_RATEZ, 3, ADC_SAMPLE_TIME); // rateZ
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_RATEZ, 4, ADC_SAMPLE_TIME); // rateZ
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_TEMP1, 5, ADC_SAMPLE_TIME); // temp1
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_TEMP2, 6, ADC_SAMPLE_TIME); // temp2
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES1, 7, ADC_SAMPLE_TIME); // pressure1
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES1, 8, ADC_SAMPLE_TIME); // pressure1
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES1, 9, ADC_SAMPLE_TIME); // pressure1
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES1, 10, ADC_SAMPLE_TIME); // pressure1
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_VIN, 11, ADC_SAMPLE_TIME); // Vin
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_TEMP3, 12, ADC_SAMPLE_TIME); // temp3
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES2, 13, ADC_SAMPLE_TIME); // pressure2
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES2, 14, ADC_SAMPLE_TIME); // pressure2
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES2, 15, ADC_SAMPLE_TIME); // pressure2
ADC_RegularChannelConfig(ADC3, ADC_CHANNEL_PRES2, 16, ADC_SAMPLE_TIME); // pressure2
// Enable DMA request after last transfer (Multi-ADC mode)
ADC_MultiModeDMARequestAfterLastTransferCmd(ENABLE);
// Enable
ADC_Cmd(ADC1, ENABLE);
ADC_Cmd(ADC2, ENABLE);
ADC_Cmd(ADC3, ENABLE);
adcData.adcFlag = CoCreateFlag(1, 0);
adcTaskStack = aqStackInit(ADC_STACK_SIZE, "ADC");
adcData.adcTask = CoCreateTask(adcTaskCode, (void *)0, ADC_PRIORITY, &adcTaskStack[ADC_STACK_SIZE-1], ADC_STACK_SIZE);
// Start ADC1 Software Conversion
ADC_SoftwareStartConv(ADC1);
yield(100);
// set initial temperatures
adcData.temp1 = adcIDGVoltsToTemp(adcData.voltages[ADC_VOLTS_TEMP1]);
adcData.temp2 = adcIDGVoltsToTemp(adcData.voltages[ADC_VOLTS_TEMP2]);
adcData.temp3 = adcT1VoltsToTemp(adcData.voltages[ADC_VOLTS_TEMP3]);
analogData.vIn = adcVsenseToVin(adcData.voltages[ADC_VOLTS_VIN]);
adcCalibOffsets();
}
/**
*******************************************************************************
* @brief Initialization task
* @param[in] pdata A pointer to parameter passed to task.
* @param[out] None
* @retval None
*
* @details This task is called to initial hardware and created tasks.
*******************************************************************************
*/
void task_init(void *pdata)
{
uart_printf (" [OK]. \n\r\n\r");
uart_printf ("\r \"task_init\" task enter. \n\r\n\r ");
pdata = pdata;
/* Initiate Time buffer for LCD display */
chart[0] = time[2]/10 + '0';
chart[1] = time[2]%10 + '0';
chart[3] = time[1]/10 + '0';
chart[4] = time[1]%10 + '0';
chart[6] = time[0]/10 + '0';
chart[7] = time[0]%10 + '0';
uart_printf ("\r Create the \"mut_uart\" mutex... ");
mut_uart = CoCreateMutex();
if(mut_uart != E_CREATE_FAIL)
uart_printf (" [OK]. \n");
else
uart_printf (" [Fail]. \n");
uart_printf ("\r Create the \"mut_lcd\" mutex... ");
mut_lcd = CoCreateMutex();
if(mut_lcd != E_CREATE_FAIL)
uart_printf (" [OK]. \n");
else
uart_printf (" [Fail]. \n");
uart_printf ("\r Create the \"button_sel_flg\" flag... ");
/*!< Manual reset flag,initial state:0 */
button_sel_flg = CoCreateFlag(Co_FALSE,0);
if(button_sel_flg != E_CREATE_FAIL)
uart_printf (" [OK]. \n");
else
uart_printf (" [Fail]. \n");
uart_printf ("\r Create the \"button_add_flag\" flag...");
/*!< Manual reset flag,initial state:0 */
button_add_flg = CoCreateFlag(Co_FALSE,0);
if(button_add_flg != E_CREATE_FAIL)
uart_printf (" [OK]. \n\n");
else
uart_printf (" [Fail]. \n\n");
uart_printf ("\r Create the \"lcd_blink_flg\" flag... ");
lcd_blink_flg = CoCreateFlag(Co_FALSE,0); /*!< Manual reset flag,initial state:0 */
if(lcd_blink_flg != E_CREATE_FAIL)
uart_printf (" [OK]. \n");
else
uart_printf (" [Fail]. \n");
uart_printf ("\r Create the \"time_display_flg\" flag...");
/*!< Manual reset flag,initial state:0 */
time_display_flg = CoCreateFlag(Co_FALSE,0);
if(time_display_flg != E_CREATE_FAIL)
uart_printf (" [OK]. \n");
else
uart_printf (" [Fail]. \n");
/*!< Set flag to allow "time_display_flg" task run. */
CoSetFlag(time_display_flg);
uart_printf ("\r Create the first mailbox... ");
mbox0 = CoCreateMbox(EVENT_SORT_TYPE_FIFO);
if(mbox0 == E_CREATE_FAIL)
uart_printf (" [Fail]. \n\n");
else
uart_printf (" [OK]. \n\n");
/* Configure Peripheral */
uart_printf ("\r Initial hardware in Board : \n\r");
uart_printf ("\r ADC initial... ");
ADC_Configuration ();
uart_printf (" [OK]. \n");
uart_printf ("\r RTC initial... ");
RTC_Configuration ();
uart_printf (" [OK]. \n");
uart_printf ("\r GPIO initial... ");
GPIO_Configuration ();
uart_printf (" [OK]. \n");
uart_printf ("\r External interrupt initial... ");
EXIT_Configuration ();
uart_printf (" [OK]. \n");
uart_printf ("\r LCD initial... ");
LCD_Configuration ();
uart_printf (" [OK]. \n\n");
/* Create Tasks */
CoCreateTask( lcd_display_adc,
(void *)0 ,
LCD_DISPLAY_PRI ,
&lcd_display_adc_Stk[TASK_STK_SIZE-1] ,
TASK_STK_SIZE
);
CoCreateTask( uart_print ,
(void *)0 ,
UART_PRINT_PRI ,
&uart_print_Stk[TASK_STK_SIZE-1],
TASK_STK_SIZE
);
CoCreateTask( led_blink ,
(void *)0 ,
LCD_BLINK_PRI ,
&led_display_Stk[TASK_STK_SIZE-1],
TASK_STK_SIZE
);
time_display_id = CoCreateTask( time_display,
(void *)0,
TIME_DISRPLAY_PRI,
&time_display_Stk[TASK_STK_SIZE - 1],
TASK_STK_SIZE
);
CoCreateTask( time_set ,
(void *)0 ,
TIME_SET_PRI ,
&time_set_Stk[TASK_STK_SIZE-1],
TASK_STK_SIZE
);
CoExitTask(); /*!< Delete 'task_init' task. */
}
