int DS_Init(void) { // Are we in verbose mode? verbose = CommandLine_Exists("-verbose"); initMixer(); initedOk = true; return true; }
void systemInit(void) { // Init cycle counter cycleCounterInit(); // SysTick SysTick_Config(SystemCoreClock / 1000); /////////////////////////////////// checkFirstTime(false); readEEPROM(); if (eepromConfig.receiverType == SPEKTRUM) checkSpektrumBind(); checkResetType(); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority initMixer(); ledInit(); cliInit(); BLUE_LED_ON; delay(20000); // 20 sec total delay for sensor stabilization - probably not long enough..... adcInit(); batteryInit(); gpsInit(); i2cInit(I2C1); i2cInit(I2C2); pwmEscInit(eepromConfig.escPwmRate); pwmServoInit(eepromConfig.servoPwmRate); rxInit(); spiInit(SPI2); spiInit(SPI3); telemetryInit(); timingFunctionsInit(); initFirstOrderFilter(); initGPS(); initMax7456(); initPID(); GREEN_LED_ON; initMPU6000(); initMag(HMC5883L_I2C); initPressure(MS5611_I2C); }
static void initSoundWindow(void) { PicHandle pict; ControlRef disp; BYTE data[5]; short i; for (i=0;i<5;i++) { data[i] = *(cfg[i]); } initMixer(data); init14(np2cfg.vol14); snd26 = np2cfg.snd26opt; uncheckAllPopupMenuItems('26io', 2, soundWin); uncheckAllPopupMenuItems('26in', 4, soundWin); uncheckAllPopupMenuItems('26rm', 5, soundWin); set26s(snd26, '26io', '26in', '26rm'); disp = getControlRefByID('BMP ', 0, soundWin); setbmp(dipswbmp_getsnd26(snd26), &pict); SetControlData(disp, kControlNoPart, kControlPictureHandleTag, sizeof(PicHandle), &pict); snd86 = np2cfg.snd86opt; uncheckAllPopupMenuItems('86io', 2, soundWin); uncheckAllPopupMenuItems('86in', 4, soundWin); uncheckAllPopupMenuItems('86id', 8, soundWin); set86s(); disp = getControlRefByID('BMP ', 1, soundWin); setbmp(dipswbmp_getsnd86(snd86), &pict); SetControlData(disp, kControlNoPart, kControlPictureHandleTag, sizeof(PicHandle), &pict); spb = np2cfg.spbopt; spbvrc = np2cfg.spb_vrc; // ver0.30 uncheckAllPopupMenuItems('spio', 2, soundWin); uncheckAllPopupMenuItems('spin', 4, soundWin); uncheckAllPopupMenuItems('sprm', 5, soundWin); setSPB(); setControlValue('splv', 0, np2cfg.spb_vrl); setControlValue('sprv', 0, np2cfg.spb_x); disp = getControlRefByID('BMP ', 2, soundWin); setbmp(dipswbmp_getsndspb(spb, spbvrc), &pict); SetControlData(disp, kControlNoPart, kControlPictureHandleTag, sizeof(PicHandle), &pict); initJoyPad(); }
void mixerCLI() { float tempFloat; uint8_t index; uint8_t rows, columns; uint8_t mixerQuery = 'x'; uint8_t validQuery = false; cliBusy = true; cliPortPrint("\nEntering Mixer CLI....\n\n"); while(true) { cliPortPrint("Mixer CLI -> "); while ((cliPortAvailable() == false) && (validQuery == false)); if (validQuery == false) mixerQuery = cliPortRead(); cliPortPrint("\n"); switch(mixerQuery) { /////////////////////////// case 'a': // Mixer Configuration cliPortPrint("\nMixer Configuration: "); switch (eepromConfig.mixerConfiguration) { case MIXERTYPE_TRI: cliPortPrint(" MIXERTYPE TRI\n"); break; case MIXERTYPE_QUADX: cliPortPrint("MIXERTYPE QUAD X\n"); break; case MIXERTYPE_HEX6X: cliPortPrint(" MIXERTYPE HEX X\n"); break; case MIXERTYPE_FREE: cliPortPrint(" MIXERTYPE FREE\n"); break; } cliPortPrintF("Number of Motors: %1d\n", numberMotor); cliPortPrintF("ESC PWM Rate: %3ld\n", eepromConfig.escPwmRate); cliPortPrintF("Servo PWM Rate: %3ld\n", eepromConfig.servoPwmRate); if (eepromConfig.yawDirection == 1.0f) cliPortPrintF("Yaw Direction: Normal\n\n"); else if (eepromConfig.yawDirection == -1.0f) cliPortPrintF("Yaw Direction: Reverse\n\n"); else cliPortPrintF("Yaw Direction: Undefined\n\n"); if (eepromConfig.mixerConfiguration == MIXERTYPE_TRI) { cliPortPrintF("TriCopter Yaw Servo PWM Rate: %3ld\n", eepromConfig.triYawServoPwmRate); cliPortPrintF("TriCopter Yaw Servo Min PWM: %4ld\n", (uint16_t)eepromConfig.triYawServoMin); cliPortPrintF("TriCopter Yaw Servo Mid PWM: %4ld\n", (uint16_t)eepromConfig.triYawServoMid); cliPortPrintF("TriCopter Yaw Servo Max PWM: %4ld\n\n", (uint16_t)eepromConfig.triYawServoMax); cliPortPrintF("Tricopter Yaw Cmd Time Constant: %5.3f\n\n", eepromConfig.triCopterYawCmd500HzLowPassTau); } if (eepromConfig.mixerConfiguration == MIXERTYPE_FREE) { cliPortPrintF("\nNumber of Free Mixer Motors: %1d\n Roll Pitch Yaw\n\n", eepromConfig.freeMixMotors); for ( index = 0; index < eepromConfig.freeMixMotors; index++ ) { cliPortPrintF("Motor%1d %6.3f %6.3f %6.3f\n", index, eepromConfig.freeMix[index][ROLL ], eepromConfig.freeMix[index][PITCH], eepromConfig.freeMix[index][YAW ]); } cliPortPrint("\n"); } validQuery = false; break; /////////////////////////// case 'x': cliPortPrint("\nExiting Mixer CLI....\n\n"); cliBusy = false; return; break; /////////////////////////// case 'A': // Read Mixer Configuration eepromConfig.mixerConfiguration = (uint8_t)readFloatCLI(); initMixer(); pwmEscInit(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'B': // Read ESC and Servo PWM Update Rates eepromConfig.escPwmRate = (uint16_t)readFloatCLI(); eepromConfig.servoPwmRate = (uint16_t)readFloatCLI(); pwmEscInit(); pwmServoInit(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'D': // Read yaw direction tempFloat = readFloatCLI(); if (tempFloat >= 0.0) tempFloat = 1.0; else tempFloat = -1.0; eepromConfig.yawDirection = tempFloat; mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'E': // Read TriCopter Servo PWM Rate if (eepromConfig.mixerConfiguration == MIXERTYPE_TRI) { eepromConfig.triYawServoPwmRate = (uint16_t)readFloatCLI(); pwmEscInit(); } else { tempFloat = readFloatCLI(); cliPortPrintF("\nTriCopter Mixing not Selected....\n\n"); } mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'F': // Read TriCopter Servo Min Point if (eepromConfig.mixerConfiguration == MIXERTYPE_TRI) { eepromConfig.triYawServoMin = readFloatCLI(); pwmEscWrite(7, (uint16_t)eepromConfig.triYawServoMin); } else { tempFloat = readFloatCLI(); cliPortPrintF("\nTriCopter Mixing not Selected....\n\n"); } mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'G': // Read TriCopter Servo Mid Point if (eepromConfig.mixerConfiguration == MIXERTYPE_TRI) { eepromConfig.triYawServoMid = readFloatCLI(); pwmEscWrite(7, (uint16_t)eepromConfig.triYawServoMid); } else { tempFloat = readFloatCLI(); cliPortPrintF("\nTriCopter Mixing not Selected....\n\n"); } mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'H': // Read TriCopter Servo Max Point if (eepromConfig.mixerConfiguration == MIXERTYPE_TRI) { eepromConfig.triYawServoMax = readFloatCLI(); pwmEscWrite(7, (uint16_t)eepromConfig.triYawServoMax); } else { tempFloat = readFloatCLI(); cliPortPrintF("\nTriCopter Mixing not Selected....\n\n"); } mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'I': // Read TriCopter Yaw Command Time Constant if (eepromConfig.mixerConfiguration == MIXERTYPE_TRI) { eepromConfig.triCopterYawCmd500HzLowPassTau = readFloatCLI(); initFirstOrderFilter(); } else { tempFloat = readFloatCLI(); cliPortPrintF("\nTriCopter Mixing not Selected....\n\n"); } mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'J': // Read Free Mix Motor Number if (eepromConfig.mixerConfiguration == MIXERTYPE_FREE) { eepromConfig.freeMixMotors = (uint8_t)readFloatCLI(); initMixer(); } else { tempFloat = readFloatCLI(); cliPortPrintF("\nFree Mix not Selected....\n\n"); } mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'K': // Read Free Mix Matrix Element if (eepromConfig.mixerConfiguration == MIXERTYPE_FREE) { rows = (uint8_t)readFloatCLI() - 1; columns = (uint8_t)readFloatCLI() - 1; eepromConfig.freeMix[rows][columns] = readFloatCLI(); } else { tempFloat = readFloatCLI(); tempFloat = readFloatCLI(); tempFloat = readFloatCLI(); cliPortPrintF("\nFree Mix not Selected....\n\n"); } mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'W': // Write EEPROM Parameters cliPortPrint("\nWriting EEPROM Parameters....\n\n"); writeEEPROM(); validQuery = false; break; /////////////////////////// case '?': cliPortPrint("\n"); cliPortPrint("'a' Mixer Configuration Data 'A' Set Mixer Configuration A0 thru 3, see aq32Plus.h\n"); cliPortPrint(" 'B' Set PWM Rates BESC;Servo\n"); cliPortPrint(" 'D' Set Yaw Direction D1 or D-1\n"); if (eepromConfig.mixerConfiguration == MIXERTYPE_TRI) { cliPortPrint(" 'E' Set TriCopter Servo PWM Rate ERate\n"); cliPortPrint(" 'F' Set TriCopter Servo Min Point FMin\n"); cliPortPrint(" 'G' Set TriCopter Servo Mid Point GMid\n"); cliPortPrint(" 'H' Set TriCopter Servo Max Point HMax\n"); cliPortPrint(" 'I' Set TriCopter Yaw Cmd Time Constant ITimeConstant\n"); } if (eepromConfig.mixerConfiguration == MIXERTYPE_FREE) { cliPortPrint(" 'J' Set Number of FreeMix Motors JNumb\n"); cliPortPrint(" 'K' Set FreeMix Matrix Element KRow;Col;Value\n"); } cliPortPrint(" 'W' Write EEPROM Parameters\n"); cliPortPrint("'x' Exit Mixer CLI '?' Command Summary\n\n"); break; /////////////////////////// } } }
static pascal OSStatus cfWinproc(EventHandlerCallRef myHandler, EventRef event, void* userData) { OSStatus err = eventNotHandledErr; HICommand cmd; BYTE defaultmix[5] = {64, 64, 64, 64, 64}; BYTE b; if (GetEventClass(event)==kEventClassCommand && GetEventKind(event)==kEventCommandProcess ) { GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &cmd); switch (cmd.commandID) { case 'vDEF': initMixer(defaultmix); break; case '26io': setjmper(&snd26, (getMenuValue == 1)?0x10:0x00, 0x10); break; case '26in': setjmper(&snd26, getsnd26int(cmd.commandID), 0xc0); break; case '26rm': setjmper(&snd26, getMenuValue, 0x07); break; case '26DF': snd26 = 0xd1; set26s(snd26, '26io', '26in', '26rm'); break; case '86io': setjmper(&snd86, (getMenuValue == 0)?0x01:0x00, 0x01); break; case '86it': setjmper(&snd86, (getControlValue(cmd.commandID, 0))?0x10:0x00, 0x10); break; case '86in': setjmper(&snd86, getsnd86int(), 0x0c); break; case '86id': setjmper(&snd86, (~getMenuValue & 7) << 5, 0xe0); break; case '86rm': setjmper(&snd86, (getControlValue(cmd.commandID, 0))?0x02:0x00, 0x02); break; case '86DF': snd86 = 0x7f; set86s(); break; case 'spio': setjmper(&spb, (getMenuValue == 1)?0x10:0x00, 0x10); break; case 'spin': setjmper(&spb, getsnd26int(cmd.commandID), 0xc0); break; case 'sprm': setjmper(&spb, getMenuValue, 0x07); break; case 'spvl': case 'spvr': b = getspbVRch(); if ((spbvrc ^ b) & 3) { spbvrc = b; } break; case 'spDF': spb = 0xd1; spbvrc = 0; setSPB(); break; case kHICommandOK: changeSoundOpt(); endLoop(soundWin); err=noErr; break; case kHICommandCancel: revertTemporal(); endLoop(soundWin); err=noErr; break; case JOYPAD_UP: case JOYPAD_DOWN: case JOYPAD_LEFT: case JOYPAD_RIGHT: case JOYPAD_ABUTTON: case JOYPAD_BBUTTON: err=setupJoyConfig(cmd.commandID); break; default: break; } } (void)myHandler; (void)userData; return err; }
ModelItemSample *recordSample() { /***** allocate memory for the new sample */ ModelItemSample *new_sample = (ModelItemSample *)malloc(sizeof(ModelItemSample)); char *tmp_string; time_t timer; /***** used to get the current time, which will become */ time(&timer); /***** the main part of the new utterance's ID */ /***** initialize the audio device */ if (initMixer() == MIXER_ERR) /***** if mixer error, return nothing */ { free(new_sample); return NULL; } if (igain_level > 0) setIGainLevel(igain_level); /***** set IGain and Mic level according */ setMicLevel(mic_level); /***** to configuration */ if (initAudio() == AUDIO_ERR) /***** if audio error, return nothing */ { free(new_sample); return NULL; } /***** connect to microphone, get utterance, disconnect */ openAudio(); new_sample->wav_data = getUtterance(&new_sample->wav_length); closeAudio(); if (new_sample->wav_data == NULL) /***** if nothing was recorded, return nothing */ { new_sample->wav_length = 0; new_sample->has_wav = 0; free(new_sample); return NULL; } else /***** flag says that this sample utterance also contains its original * wave data, not only the preprocessed feature vectors *****/ new_sample->has_wav = 1; /***** preprocess the wave data */ new_sample->data = preprocessUtterance(new_sample->wav_data, new_sample->wav_length, &new_sample->length); if (new_sample->data == NULL) /***** if preprocessing failed, return nothing */ { new_sample->length = 0; free(new_sample->wav_data); free(new_sample); return NULL; } /***** set ID */ tmp_string = ctime(&timer); /***** get current time */ /***** set sample ID looks like: [Thu Feb 10 12:10:53 2000] */ new_sample->id = malloc(strlen(tmp_string)+2); new_sample->id[0] = '['; strcpy(new_sample->id+1, tmp_string); new_sample->id[strlen(tmp_string)] = ']'; new_sample->next = NULL; /***** next sample pointer is NULL */ { int i; for (i = 0; i < 3; i++) new_sample->matrix[i] = NULL; } modified = 1; /***** speaker model has been modified now */ return(new_sample); }
void systemInit(void) { GPIO_InitTypeDef GPIO_InitStructure; // Turn on clocks for stuff we use RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE); RCC_ClearFlag(); // Make all GPIO in by default to save power and reduce noise GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_Init(GPIOC, &GPIO_InitStructure); // Turn off JTAG port 'cause we're using the GPIO for leds GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); // Init cycle counter cycleCounterInit(); // SysTick SysTick_Config(SystemCoreClock / 1000); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority checkFirstTime(false); readEEPROM(); ledInit(); LED0_ON; initMixer(); pwmOutputConfig.escPwmRate = eepromConfig.escPwmRate; pwmOutputConfig.servoPwmRate = eepromConfig.servoPwmRate; cliInit(115200); i2cInit(I2C2); pwmOutputInit(&pwmOutputConfig); rxInit(); delay(20000); // 20 sec delay for sensor stabilization - probably not long enough..... LED1_ON; initAccel(); initGyro(); initMag(); initPressure(); initPID(); }
void systemInit(void) { GPIO_InitTypeDef GPIO_InitStructure; uint8_t i; gpio_config_t gpio_cfg[] = { {LED0_GPIO, LED0_PIN, GPIO_Mode_Out_PP}, // PB3 (LED) {LED1_GPIO, LED1_PIN, GPIO_Mode_Out_PP}, // PB4 (LED) }; uint8_t gpio_count = sizeof(gpio_cfg) / sizeof(gpio_cfg[0]); // Turn on clocks for stuff we use RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE); RCC_ClearFlag(); // Make all GPIO in by default to save power and reduce noise GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_Init(GPIOC, &GPIO_InitStructure); // Turn off JTAG port 'cause we're using the GPIO for leds GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); // Configure gpio for (i = 0; i < gpio_count; i++) { GPIO_InitStructure.GPIO_Pin = gpio_cfg[i].pin; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = gpio_cfg[i].mode; GPIO_Init(gpio_cfg[i].gpio, &GPIO_InitStructure); } // Init cycle counter cycleCounterInit(); // SysTick SysTick_Config(SystemCoreClock / 1000); LED0_OFF; LED1_OFF; NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority checkFirstTime(false, false); readEEPROM(); initMixer(); pwmOutputConfig.escPwmRate = systemConfig.escPwmRate; pwmOutputConfig.servoPwmRate = systemConfig.servoPwmRate; //i2cInit(SENSOR_I2C); pwmInputInit(); pwmOutputInit(&pwmOutputConfig); uartInit(115200); //delay(10000); // 10 sec delay for sensor stabilization - probably not long enough..... //initAccel(); //initGyro(); //initMag(); adcInit(); //initPressure(); // no pressure sensor initPID(); }
int selectMixer() { int top = 0, current = 0; /***** selection menu related variables */ int max_view = 9; int retval = 0; /***** return value */ int request_finish = 0; /***** leave current dialog, if request_finish is set to 1 */ int width = 45, height = 15, i, j; /***** ncurses related variables */ WINDOW *mixerscr = popupWindow (width, height); while (!request_finish) { wattrset (mixerscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */ /***** * draw a box around the dialog window * and empty it. *****/ werase (mixerscr); box (mixerscr, 0, 0); for (i = 1; i < width-1; i++) for (j = 1; j < height-1; j++) mvwaddch(mixerscr, j, i, ' '); /***** dialog header */ mvwaddstr(mixerscr, 1, 2, "Select Mixer Device:"); mvwaddseparator(mixerscr, 2, width); /***** selection area */ for (i = 0; i < MIN2(mixer_devices->count, max_view); i++) { setHighlight(mixerscr, ok, i == current); mvwaddstr(mixerscr, 4+i, 4, "/dev/"); waddstr(mixerscr, mixer_devices->name[top+i]); } wattroff(mixerscr, A_REVERSE); /***** * show up/down arrow to the left, if more items are available * than can be displayed *****/ if (top > 0) { mvwaddch(mixerscr,4, 2, ACS_UARROW); mvwaddch(mixerscr,4+1, 2, ACS_VLINE); } if (mixer_devices->count > max_view && top+max_view <= mixer_devices->count-1) { mvwaddch(mixerscr,4+max_view-2, 2, ACS_VLINE); mvwaddch(mixerscr,4+max_view-1, 2, ACS_DARROW); } wmove(mixerscr, 1, 23); /***** set cursor to an appropriate location */ wrefresh (mixerscr); /***** refresh the dialog */ /* process the command keystroke */ switch(getch()) { case KEY_UP: /***** cursor up */ if (current > 0) current--; else top = (top > 0 ? top-1 : 0); break; case KEY_DOWN: /***** cursor down */ if (top+current < mixer_devices->count-1) { if (current < max_view-1) current++; else top++; } break; case ESCAPE: /***** press Escape to leave dialog */ retval = MIXER_ERR; request_finish = 1; break; case ENTER: /***** make selection with Enter or Space bar */ case BLANK: setMixer(mixer_devices->name[top+current]); /***** set mixer device to highlighted item */ retval = initMixer(); /***** retval is ok, if initMixer() returned ok */ request_finish = 1; /***** leave dialog */ break; } } delwin(mixerscr); /***** delete ncurses dialog window */ return(retval); }
void systemInit(void) { RCC_ClocksTypeDef rccClocks; /////////////////////////////////// // Init cycle counter cycleCounterInit(); // SysTick SysTick_Config(SystemCoreClock / 1000); // Turn on peripherial clcoks RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM10, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM11, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); /////////////////////////////////// checkFirstTime(false); readEEPROM(); if (eepromConfig.receiverType == SPEKTRUM) checkSpektrumBind(); checkResetType(); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority /////////////////////////////////// gpsPortClearBuffer = &uart2ClearBuffer; gpsPortNumCharsAvailable = &uart2NumCharsAvailable; gpsPortPrintBinary = &uart2PrintBinary; gpsPortRead = &uart2Read; telemPortAvailable = &uart1Available; telemPortPrint = &uart1Print; telemPortPrintF = &uart1PrintF; telemPortRead = &uart1Read; /////////////////////////////////// initMixer(); usbInit(); ledInit(); uart1Init(); uart2Init(); BLUE_LED_ON; /////////////////////////////////// delay(10000); // 10 seconds of 20 second delay for sensor stabilization checkUsbActive(); #ifdef __VERSION__ cliPortPrintF("\ngcc version " __VERSION__ "\n"); #endif cliPortPrintF("\nAQ32Plus Firmware V%s, Build Date " __DATE__ " "__TIME__" \n", __AQ32PLUS_VERSION); if ((RCC->CR & RCC_CR_HSERDY) != RESET) { cliPortPrint("\nRunning on external HSE clock....\n"); } else { cliPortPrint("\nERROR: Running on internal HSI clock....\n"); } RCC_GetClocksFreq(&rccClocks); cliPortPrintF("\nHCLK-> %3d MHz\n", rccClocks.HCLK_Frequency / 1000000); cliPortPrintF( "PCLK1-> %3d MHz\n", rccClocks.PCLK1_Frequency / 1000000); cliPortPrintF( "PCLK2-> %3d MHz\n", rccClocks.PCLK2_Frequency / 1000000); cliPortPrintF( "SYSCLK-> %3d MHz\n\n", rccClocks.SYSCLK_Frequency / 1000000); initUBLOX(); delay(10000); // Remaining 10 seconds of 20 second delay for sensor stabilization - probably not long enough.. /////////////////////////////////// adcInit(); i2cInit(I2C1); i2cInit(I2C2); pwmServoInit(); rxInit(); spiInit(SPI2); spiInit(SPI3); timingFunctionsInit(); batteryInit(); initFirstOrderFilter(); initMavlink(); initMax7456(); initPID(); GREEN_LED_ON; initMPU6000(); initMag(); initPressure(); }
ALSAMixer::ALSAMixer(const char *sndcard) { int err; LOGI(" Init ALSAMIXER for SNDCARD : %s",sndcard); mixerMasterProp = ALSA_PROP(AudioSystem::DEVICE_OUT_ALL, "master", "PCM", "Capture"); mixerProp = { ALSA_PROP(AudioSystem::DEVICE_OUT_EARPIECE, "earpiece", "Earpiece", "Capture"), ALSA_PROP(AudioSystem::DEVICE_OUT_SPEAKER, "speaker", "Speaker", ""), ALSA_PROP(AudioSystem::DEVICE_OUT_WIRED_HEADSET, "headset", "Headphone", "Capture"), ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_SCO, "bluetooth.sco", "Bluetooth", "Bluetooth Capture"), ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP, "bluetooth.a2dp", "Bluetooth A2DP", "Bluetooth A2DP Capture"), ALSA_PROP(static_cast<AudioSystem::audio_devices>(0), "", NULL, NULL) }; initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], sndcard); initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], sndcard); snd_mixer_selem_id_t *sid; snd_mixer_selem_id_alloca(&sid); for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) { mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t; property_get (mixerMasterProp[i].propName, info->name, mixerMasterProp[i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found"); for (int j = 0; mixerProp[j][i].device; j++) { mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t; property_get (mixerProp[j][i].propName, info->name, mixerProp[j][i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found"); } } LOGV("mixer initialized."); }
void systemInit(void) { // Init cycle counter cycleCounterInit(); // SysTick SysTick_Config(SystemCoreClock / 1000); // Turn on peripherial clocks RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // USART1 RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE); // ADC2 RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); // PWM Servo Out 1 & 2 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); // PWM ESC Out 3 & 4 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); // PWM ESC Out 5,6,7, & 8 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE); // 500 Hz dt Counter RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE); // 100 Hz dt Counter RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM15, ENABLE); // PWM ESC Out 1 & 2 RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM16, ENABLE); // PPM RX RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM17, ENABLE); // Spektrum Frame Sync RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); // Telemetry RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); // Spektrum RX /////////////////////////////////////////////////////////////////////////// checkFirstTime(false); readEEPROM(); if (eepromConfig.receiverType == SPEKTRUM) checkSpektrumBind(); checkResetType(); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority initMixer(); cliInit(); gpioInit(); telemetryInit(); adcInit(); LED0_OFF; delay(20000); // 20 sec total delay for sensor stabilization - probably not long enough..... LED0_ON; batteryInit(); pwmServoInit(eepromConfig.servoPwmRate); if (eepromConfig.receiverType == SPEKTRUM) spektrumInit(); else ppmRxInit(); spiInit(SPI2); timingFunctionsInit(); initFirstOrderFilter(); initPID(); initMPU6000(); initMag(); initPressure(); }
ALSAMixer::ALSAMixer() { int err; initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidOut"); initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidIn"); snd_mixer_selem_id_t *sid; snd_mixer_selem_id_alloca(&sid); for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) { mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t; property_get (mixerMasterProp[i].propName, info->name, mixerMasterProp[i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found"); for (int j = 0; mixerProp[j][i].device; j++) { mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t; property_get (mixerProp[j][i].propName, info->name, mixerProp[j][i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found"); } } #ifdef AUDIO_MODEM_TI ALSAControl control("hw:00"); status_t error; #if 0//(WORKAROUND_AVOID_VOICE_VOLUME_SATURATION == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee LOGV("Workaround: Voice call max volume limited to: %d", WORKAROUND_MAX_VOICE_VOLUME); #endif #if 0//(WORKAROUND_SET_VOICE_VOLUME_MIN == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee LOGV("Workaround: Voice call min volume limited to: %d", WORKAROUND_MIN_VOICE_VOLUME); #endif for (int i = 0; inCallVolumeProp[i].device; i++) { mixer_incall_vol_info_t *info = inCallVolumeProp[i].mInfo = new mixer_incall_vol_info_t; property_get (inCallVolumeProp[i].propName, info->name, inCallVolumeProp[i].propDefault); error = control.get(info->name, info->volume, 0); error = control.getmin(info->name, info->min); error = control.getmax(info->name, info->max); #if 0//(WORKAROUND_AVOID_VOICE_VOLUME_SATURATION == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee info->max = WORKAROUND_MAX_VOICE_VOLUME; #endif #if 0//(WORKAROUND_SET_VOICE_VOLUME_MIN == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee info->min = WORKAROUND_MIN_VOICE_VOLUME; #endif if (error < 0) { LOGV("Mixer: In Call Volume '%s': not found", info->name); } else { LOGV("Mixer: In Call Volume '%s': vol. %d min. %d max. %d", info->name, info->volume, info->min, info->max); } } #endif LOGV("mixer initialized."); }
void mixerCLI() { float tempFloat; uint8_t mixerQuery = 'x'; uint8_t validQuery = false; cliBusy = true; cliPrint("\nEntering Mixer CLI....\n\n"); while(true) { cliPrint("Mixer CLI -> "); while ((cliAvailable() == false) && (validQuery == false)); if (validQuery == false) mixerQuery = cliRead(); cliPrint("\n"); switch(mixerQuery) { /////////////////////////// case 'a': // Mixer Configuration cliPrint("\nMixer Configuration: "); switch (eepromConfig.mixerConfiguration) { case MIXERTYPE_QUADX: cliPrint("MIXERTYPE QUAD X\n"); break; case MIXERTYPE_HEX6X: cliPrint(" MIXERTYPE HEX X\n"); break; } cliPrintF("Number of Motors: %1d\n", numberMotor); cliPrintF("ESC PWM Rate: %3ld\n", eepromConfig.escPwmRate); cliPrintF("Servo PWM Rate: %3ld\n\n", eepromConfig.servoPwmRate); validQuery = false; break; /////////////////////////// case 'x': cliPrint("\nExiting Mixer CLI....\n\n"); cliBusy = false; return; break; /////////////////////////// case 'A': // Read Mixer Configuration eepromConfig.mixerConfiguration = (uint8_t)readFloatCLI(); initMixer(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'B': // Read ESC and Servo PWM Update Rates eepromConfig.escPwmRate = (uint16_t)readFloatCLI(); eepromConfig.servoPwmRate = (uint16_t)readFloatCLI(); pwmEscInit(eepromConfig.escPwmRate); pwmServoInit(eepromConfig.servoPwmRate); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'M': // Read yaw direction tempFloat = readFloatCLI(); if (tempFloat >= 0.0) tempFloat = 1.0; else tempFloat = -1.0; eepromConfig.yawDirection = tempFloat; mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'W': // Write EEPROM Parameters cliPrint("\nWriting EEPROM Parameters....\n\n"); writeEEPROM(); break; /////////////////////////// case '?': cliPrint("\n"); cliPrint("'a' Mixer Configuration Data 'A' Set Mixer Configuration A1 thru 21, see aq32Plus.h\n"); cliPrint("'b' Free Mixer Configuration 'B' Set PWM Rates BESC;Servo\n"); cliPrint(" 'C' Set BiCopter Left Servo Parameters CMin;Mid;Max\n"); cliPrint(" 'D' Set BiCopter Right Servo Parameters DMin;Mid;Max\n"); cliPrint(" 'E' Set Flying Wing Servo Directions ERollLeft;RollRight;PitchLeft;PitchRight\n"); cliPrint(" 'F' Set Flying Wing Servo Limits FLeftMin;LeftMax;RightMin;RightMax\n"); cliPrint(" 'G' Set Number of FreeMix Motors GNumber\n"); cliPrint(" 'H' Set FreeMix Matrix Element HRow;Column;Element\n"); cliPrint(" 'I' Set Gimbal Roll Servo Parameters IMin;Mid;Max;Gain\n"); cliPrint(" 'J' Set Gimbal Pitch Servo Parameters JMin;Mid;Max;Gain\n"); cliPrint(" 'K' Set TriCopter Servo Parameters KMin;Mid;Max\n"); cliPrint(" 'L' Set V Tail Angle LAngle\n"); cliPrint(" 'M' Set Yaw Direction M1 or M-1\n"); cliPrint(" 'W' Write EEPROM Parameters\n"); cliPrint("'x' Exit Sensor CLI '?' Command Summary\n"); cliPrint("\n"); break; /////////////////////////// } } }
/* Will validate the data retrieved from the configuration file */ int init(void) { int status; config_setting_t *conf_setting = NULL; const char *conf_value = NULL; /* Now the configuration file is read, we don't need to know the location * of the application anymore. We'll change working directory to root */ if(chdir("/") < 0) { syslog(LOG_ERR, "Unable to change working directory to root: %s", strerror(errno)); return EXIT_FAILURE; } syslog(LOG_INFO, "Checking presence and validity of required variables:"); validateConfigBool(&config, "sync_2way", &common_data.sync_2way, 0); validateConfigBool(&config, "diff_commands", &common_data.diff_commands, 0); common_data.send_query = config_lookup(&config, "query") ? 1:0; if(common_data.send_query && ((conf_setting = config_lookup(&config, "query.trigger")) == NULL || config_setting_is_array(conf_setting) == CONFIG_FALSE || (common_data.statusQueryLength = config_setting_length(conf_setting)) == 0)) { syslog(LOG_ERR, "[ERROR] Setting is not present or not formatted as array: query.trigger"); return EXIT_FAILURE; } if(common_data.send_query && validateConfigInt(&config, "query.interval", &common_data.statusQueryInterval, -1, 0, 255, -1) == EXIT_FAILURE) return EXIT_FAILURE; /* Set volume (curve) functions */ conf_value = NULL; config_lookup_string(&config, "volume.curve", &conf_value); if(!(common_data.volume = getVolume(&conf_value))) { syslog(LOG_ERR, "[Error] Volume curve is not recognised: %s", conf_value); return EXIT_FAILURE; } else { syslog(LOG_INFO, "[OK] volume.curve: %s", conf_value); } /* initialise volume variables */ if(common_data.volume->init() == EXIT_FAILURE) return EXIT_FAILURE; /* Set and initialise process type */ conf_value = NULL; config_lookup_string(&config, "data_type", &conf_value); if(!(common_data.process = getProcessMethod(&conf_value))) { syslog(LOG_ERR, "[Error] Setting 'data_type' is not recognised: %s", conf_value); return EXIT_FAILURE; } else { syslog(LOG_INFO, "[OK] data_type: %s", conf_value); } if(common_data.process->init() == EXIT_FAILURE) return EXIT_FAILURE; /* Set and initialise communication interface */ conf_value = NULL; config_lookup_string(&config, "interface", &conf_value); if(!(common_data.interface = getInterface(&conf_value))) { syslog(LOG_ERR, "[Error] Setting 'interface' is not recognised: %s", conf_value); return EXIT_FAILURE; } else { syslog(LOG_INFO, "[OK] interface: %s", conf_value); } if(common_data.interface->init() == EXIT_FAILURE) return EXIT_FAILURE; /* initialise mixer device */ if(initMixer() == EXIT_FAILURE) return EXIT_FAILURE; /* init multipliers */ common_data.volume->regenerateMultipliers(); #ifndef DISABLE_MSQ /* initialise message queue */ if(initMsQ() == EXIT_FAILURE) return EXIT_FAILURE; #endif if((status = pthread_mutex_init(&lockConfig, NULL)) != 0) { syslog(LOG_ERR, "Failed to create config mutex: %i", status); return EXIT_FAILURE; } return EXIT_SUCCESS; } /* end init */
void testInit(void) { GPIO_InitTypeDef GPIO_InitStructure; uint8_t i; struct __gpio_config_t { GPIO_TypeDef *gpio; uint16_t pin; GPIOMode_TypeDef mode; } gpio_cfg[] = { {LED0_GPIO, LED0_PIN, GPIO_Mode_Out_PP}, // PB3 (LED) {LED1_GPIO, LED1_PIN, GPIO_Mode_Out_PP}, // PB4 (LED) }; uint8_t gpio_count = sizeof(gpio_cfg) / sizeof(gpio_cfg[0]); // Turn on clocks for stuff we use RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE); RCC_ClearFlag(); // Make all GPIO in by default to save power and reduce noise GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_Init(GPIOB, &GPIO_InitStructure); GPIO_Init(GPIOC, &GPIO_InitStructure); // Turn off JTAG port 'cause we're using the GPIO for leds GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); // Configure gpio for (i = 0; i < gpio_count; i++) { GPIO_InitStructure.GPIO_Pin = gpio_cfg[i].pin; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = gpio_cfg[i].mode; GPIO_Init(gpio_cfg[i].gpio, &GPIO_InitStructure); } // Init cycle counter cycleCounterInit(); // SysTick SysTick_Config(SystemCoreClock / 1000); LED0_OFF; LED1_OFF; NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority checkFirstTime(true,true); initMixer(); pwmOutputConfig.motorPwmRate = 10*1000; pwmOutputConfig.noEsc = true; pwmOutputInit(&pwmOutputConfig); i2cInit(SENSOR_I2C); initGyro(); initAccel(); initMag(); nrf_init(); nrf_detect(); }
int main(int argc, char *argv[]) { /***** * boolean value indicates when to break main loop * (and thus finish this configuration tool) *****/ int request_finish = 0; int current = 0; /***** menu related variables */ int menu_items = 7; enum state status[] = {invalid, invalid, inactive, inactive, inactive, inactive, invalid}; WINDOW *mainscr; /***** ncurses related variables */ int i, j; /* ***** detect available mixer devices */ mixer_devices = scanMixerDevices(); if (mixer_devices == NULL || mixer_devices->count == 0) { /* ***** no mixer devices available -> exit! */ fprintf(stderr, "No mixer devices available!\n"); fprintf(stderr, "Please purchase a sound card and install it!\n"); exit(-1); } else { if (mixer_devices->count == 1) /***** exactly one mixer device available */ { setMixer(mixer_devices->name[0]); /***** set this mixer */ if (initMixer() == MIXER_OK) /***** if mixer is ok, keep it */ { status[0] = ok; status[2] = invalid; } else /***** otherwise, exit!*/ { fprintf(stderr, "Couldn't init the only available mixer device: /dev/%s\n", mixer_devices->name[0]); exit(-1); } } else /* ***** more than one device available! */ { /* ***** use /dev/mixer as default if it exists */ for (i = 0; i < mixer_devices->count; i++) { if (strcmp(mixer_devices->name[i], "mixer") == 0) { setMixer("mixer"); if (initMixer() == MIXER_OK) { status[0] = ok; status[2] = invalid; } else noMixer(); break; } } } } /* ***** detect available audio devices */ audio_devices = scanAudioDevices(); if (audio_devices == NULL || audio_devices->count == 0) { /* ***** no audio devices available! */ fprintf(stderr, "No audio device available that\n"); fprintf(stderr, "supports 16bit recording!\n"); fprintf(stderr, "Please purchase a sound card and install it!\n"); exit(-1); } else { if (audio_devices->count == 1) /***** exactly one audio device available */ { setAudio(audio_devices->name[0]); /***** set this audio device */ if (initAudio() == AUDIO_OK) /***** if audio device is ok, keep it */ { status[1] = ok; } else /***** otherwise, exit!*/ { fprintf(stderr, "Couldn't init the only available audio device: /dev/%s\n", audio_devices->name[0]); exit(-1); } } else /* ***** more than one device available! */ { /* ***** use /dev/dspW as default if it exists */ for (i = 0; i < audio_devices->count; i++) { if (strcmp(audio_devices->name[i], "dspW") == 0) { setAudio("dspW"); if (initAudio() == AUDIO_OK) status[1] = ok; else noAudio(); break; } } } } /***** * if mixer and audio device have been selected successfully, * set menu cursor to next available menu item *****/ if (status[0] == ok && status[1] == ok) current = 2; /***** ignore Ctrl-C */ signal(SIGINT, SIG_IGN); /* ***** ncurses stuff */ initscr(); /* initialize the curses library */ if (color_term != -1) /***** define dialog color pairs if terminal supports colors */ { start_color (); if ((color_term = has_colors ())) { color_term = 1; init_pair (1, COLOR_WHITE, COLOR_BLUE); init_pair (2, COLOR_YELLOW, COLOR_BLUE); init_pair (3, COLOR_BLUE, COLOR_YELLOW); init_pair (4, COLOR_YELLOW, COLOR_CYAN); } } else color_term = 0; keypad(stdscr, TRUE); /* enable keyboard mapping */ scrollok (stdscr, FALSE); cbreak(); /* take input chars one at a time, no wait for \n */ noecho(); /* don't echo input */ refresh(); mainscr = popupWindow(COLS, LINES); /***** dialog window that contains the main menu */ leaveok (mainscr, FALSE); while (!request_finish) { wattrset (mainscr, color_term ? COLOR_PAIR(2) | A_BOLD : A_NORMAL); /***** set bg color of the dialog */ /***** * draw a box around the dialog window * and empty it. *****/ box(mainscr, 0, 0); for (i = 1; i < COLS-1; i++) for (j = 1; j < LINES-1; j++) mvwaddch(mainscr, j, i, ' '); /***** dialog header */ mvwaddstr(mainscr, 1, 2, "CVoiceControl"); mvwaddstr(mainscr, 1, COLS - strlen("(c) 2000 Daniel Kiecza") - 2, "(c) 2000 Daniel Kiecza"); mvwaddseparator(mainscr, 2, COLS); mvwaddstr(mainscr, 3, (COLS / 2) - (strlen ("Recording Device Configuration Tool") / 2), "Recording Device Configuration Tool"); mvwaddseparator(mainscr, 4, COLS); /***** main menu */ mvwaddstr(mainscr, 5, 2, "Please Select:"); setHighlight(mainscr, status[0], current == 0); mvwaddstr(mainscr, 7,5,"Select Mixer Device"); if (mixerOK() == MIXER_OK) { mvwaddstr(mainscr, 7,24," ("); waddstr(mainscr, getMixer()); waddstr(mainscr, ")"); } else mvwaddstr(mainscr, 7,24," (none selected!)"); setHighlight(mainscr, status[1], current == 1); mvwaddstr(mainscr, 8,5,"Select Audio Device"); if (audioOK() == AUDIO_OK) { mvwaddstr(mainscr, 8,24," ("); waddstr(mainscr, getAudio()); waddstr(mainscr, ")"); } else mvwaddstr(mainscr, 8,24," (none selected!)"); setHighlight(mainscr, status[2], current == 2); mvwaddstr(mainscr, 9,5,"Adjust Mixer Levels"); setHighlight(mainscr, status[3], current == 3); mvwaddstr(mainscr, 10,5,"Calculate Recording Thresholds"); setHighlight(mainscr, status[4], current == 4); mvwaddstr(mainscr, 11,5,"Estimate Characteristics of Recording Channel"); setHighlight(mainscr, status[5], current == 5); mvwaddstr(mainscr, 12,5,"Write Configuration"); setHighlight(mainscr, status[6], current == 6); mvwaddstr(mainscr, 13,5,"Exit"); wmove(mainscr, 5, 17); /***** set cursor to an appropriate location */ wrefresh(mainscr); /***** refresh the dialog */ /* process the command keystroke */ switch(getch()) { case KEY_UP: /***** cursor up */ current = (current == 0 ? menu_items - 1 : current - 1); while(status[current] == inactive) current = (current == 0 ? menu_items - 1 : current - 1); break; case KEY_DOWN: /***** cursor down */ current = (current == menu_items-1 ? 0 : current + 1); while(status[current] == inactive) current = (current == menu_items-1 ? 0 : current + 1); break; case ENTER: /***** handle menu selections */ case BLANK: switch (current) { case 0: /***** select mixer device */ status[0] = invalid; status[2] = inactive; status[3] = inactive; status[4] = inactive; status[5] = inactive; noMixer(); if (selectMixer() == MIXER_OK) { status[0] = ok; status[2] = invalid; } break; case 1: /***** select audio device */ status[1] = invalid; status[3] = inactive; status[4] = inactive; status[5] = inactive; noAudio(); if (selectAudio() == AUDIO_OK) status[1] = ok; break; case 2: /***** adjust mixer levels */ if (adjustMixerLevels()) { status[2] = ok; status[3] = invalid; status[4] = invalid; } break; case 3: /***** calculate recording thresholds */ if (calculateThresholds()) status[3] = ok; else status[3] = invalid; break; case 4: /***** estimate the characteristics of the recording channel */ if (estimateChannelMean()) status[4] = ok; else status[4] = invalid; break; case 5: /***** save configuration! */ if (saveConfiguration()) { status[5] = ok; status[6] = ok; } break; case 6: /***** leave program */ if (status[6] == ok || (status[6] != ok && safeExit())) { wrefresh(mainscr); /***** refresh the dialog */ request_finish = 1; delwin(mainscr); /***** delete ncurses dialog window */ } break; } break; } /***** if the configuration is done, activate the menu item "Save Configuration" */ if (status[0] != ok || status[1] != ok || status[2] != ok || status[3] != ok || status[4] != ok) status[5] = inactive; else if (status[5] != ok) status[5] = invalid; } endwin(); /* we're done */ /***** free memory used by the list of mixer and audio devices */ if (mixer_devices != NULL) { for (i = 0; i < mixer_devices->count; i++) free(mixer_devices->name[i]); free(mixer_devices->name); free(mixer_devices); } if (audio_devices != NULL) { for (i = 0; i < audio_devices->count; i++) free(audio_devices->name[i]); free(audio_devices->name); free(audio_devices); } exit(0); }
void mixerCLI() { float tempFloat; uint8_t index; uint8_t rows, columns; uint8_t mixerQuery; uint8_t validQuery = false; cliBusy = true; cliPrint("\nEntering Mixer CLI....\n\n"); while(true) { cliPrint("Mixer CLI -> "); while ((cliAvailable() == false) && (validQuery == false)); if (validQuery == false) mixerQuery = cliRead(); cliPrint("\n"); switch(mixerQuery) { /////////////////////////// case 'a': // Mixer Configuration cliPrint("\nMixer Configuration: "); switch (eepromConfig.mixerConfiguration) { case MIXERTYPE_GIMBAL: cliPrint("MIXERTYPE GIMBAL\n"); break; /////////////////////// case MIXERTYPE_FLYING_WING: cliPrint("MIXERTYPE FLYING WING\n"); break; /////////////////////// case MIXERTYPE_BI: cliPrint("MIXERTYPE BICOPTER\n"); break; /////////////////////// case MIXERTYPE_TRI: cliPrint("MIXERTYPE TRICOPTER\n"); break; /////////////////////// case MIXERTYPE_QUADP: cliPrint("MIXERTYPE QUAD PLUS\n"); break; case MIXERTYPE_QUADX: cliPrint("MIXERTYPE QUAD X\n"); break; case MIXERTYPE_VTAIL4_NO_COMP: cliPrint("MULTITYPE VTAIL NO COMP\n"); break; case MIXERTYPE_VTAIL4_Y_COMP: cliPrint("MULTITYPE VTAIL Y COMP\n"); break; case MIXERTYPE_VTAIL4_RY_COMP: cliPrint("MULTITYPE VTAIL RY COMP\n"); break; case MIXERTYPE_VTAIL4_PY_COMP: cliPrint("MULTITYPE VTAIL PY COMP\n"); break; case MIXERTYPE_VTAIL4_RP_COMP: cliPrint("MULTITYPE VTAIL RP COMP\n"); break; case MIXERTYPE_VTAIL4_RPY_COMP: cliPrint("MULTITYPE VTAIL RPY COMP\n"); break; case MIXERTYPE_Y4: cliPrint("MIXERTYPE Y4\n"); break; /////////////////////// case MIXERTYPE_HEX6P: cliPrint("MIXERTYPE HEX PLUS\n"); break; case MIXERTYPE_HEX6X: cliPrint("MIXERTYPE HEX X\n"); break; case MIXERTYPE_Y6: cliPrint("MIXERTYPE Y6\n"); break; /////////////////////// case MIXERTYPE_FREEMIX: cliPrint("MIXERTYPE FREE MIX\n"); break; } cliPrintF("Number of Motors: %1d\n", numberMotor); cliPrintF("ESC PWM Rate: %3ld\n", eepromConfig.escPwmRate); cliPrintF("Servo PWM Rate: %3ld\n", eepromConfig.servoPwmRate); if ( eepromConfig.mixerConfiguration == MIXERTYPE_BI ) { cliPrintF("BiCopter Left Servo Min: %4ld\n", (uint16_t)eepromConfig.biLeftServoMin); cliPrintF("BiCopter Left Servo Mid: %4ld\n", (uint16_t)eepromConfig.biLeftServoMid); cliPrintF("BiCopter Left Servo Max: %4ld\n", (uint16_t)eepromConfig.biLeftServoMax); cliPrintF("BiCopter Right Servo Min: %4ld\n", (uint16_t)eepromConfig.biRightServoMin); cliPrintF("BiCopter Right Servo Mid: %4ld\n", (uint16_t)eepromConfig.biRightServoMid); cliPrintF("BiCopter Right Servo Max: %4ld\n", (uint16_t)eepromConfig.biRightServoMax); } if ( eepromConfig.mixerConfiguration == MIXERTYPE_FLYING_WING ) { cliPrintF("Roll Direction Left: %4ld\n", (uint16_t)eepromConfig.rollDirectionLeft); cliPrintF("Roll Direction Right: %4ld\n", (uint16_t)eepromConfig.rollDirectionRight); cliPrintF("Pitch Direction Left: %4ld\n", (uint16_t)eepromConfig.pitchDirectionLeft); cliPrintF("Pitch Direction Right: %4ld\n", (uint16_t)eepromConfig.pitchDirectionRight); cliPrintF("Wing Left Minimum: %4ld\n", (uint16_t)eepromConfig.wingLeftMinimum); cliPrintF("Wing Left Maximum: %4ld\n", (uint16_t)eepromConfig.wingLeftMaximum); cliPrintF("Wing Right Minimum: %4ld\n", (uint16_t)eepromConfig.wingRightMinimum); cliPrintF("Wing Right Maximum: %4ld\n", (uint16_t)eepromConfig.wingRightMaximum); } if ( eepromConfig.mixerConfiguration == MIXERTYPE_GIMBAL ) { cliPrintF("Gimbal Roll Servo Min: %4ld\n", (uint16_t)eepromConfig.gimbalRollServoMin); cliPrintF("Gimbal Roll Servo Mid: %4ld\n", (uint16_t)eepromConfig.gimbalRollServoMid); cliPrintF("Gimbal Roll Servo Max: %4ld\n", (uint16_t)eepromConfig.gimbalRollServoMax); cliPrintF("Gimbal Roll Servo Gain: %7.3f\n", eepromConfig.gimbalRollServoGain); cliPrintF("Gimbal Pitch Servo Min: %4ld\n", (uint16_t)eepromConfig.gimbalPitchServoMin); cliPrintF("Gimbal Pitch Servo Mid: %4ld\n", (uint16_t)eepromConfig.gimbalPitchServoMid); cliPrintF("Gimbal Pitch Servo Max: %4ld\n", (uint16_t)eepromConfig.gimbalPitchServoMax); cliPrintF("Gimbal Pitch Servo Gain: %7.3f\n", eepromConfig.gimbalPitchServoGain); } if ( eepromConfig.mixerConfiguration == MIXERTYPE_TRI ) { cliPrintF("TriCopter Yaw Servo Min: %4ld\n", (uint16_t)eepromConfig.triYawServoMin); cliPrintF("TriCopter Yaw Servo Mid: %4ld\n", (uint16_t)eepromConfig.triYawServoMid); cliPrintF("TriCopter Yaw Servo Max: %4ld\n", (uint16_t)eepromConfig.triYawServoMax); } if (eepromConfig.mixerConfiguration == MIXERTYPE_VTAIL4_Y_COMP || eepromConfig.mixerConfiguration == MIXERTYPE_VTAIL4_RY_COMP || eepromConfig.mixerConfiguration == MIXERTYPE_VTAIL4_PY_COMP || eepromConfig.mixerConfiguration == MIXERTYPE_VTAIL4_RP_COMP || eepromConfig.mixerConfiguration == MIXERTYPE_VTAIL4_RPY_COMP) { cliPrintF("V Tail Angle %6.2f\n", eepromConfig.vTailAngle); } cliPrintF("Yaw Direction: %2d\n\n", (uint16_t)eepromConfig.yawDirection); validQuery = false; break; /////////////////////////// case 'b': // Free Mix Matrix cliPrintF("\nNumber of Free Mixer Motors: %1d\n Roll Pitch Yaw\n", eepromConfig.freeMixMotors); for ( index = 0; index < eepromConfig.freeMixMotors; index++ ) { cliPrintF("Motor%1d %6.3f %6.3f %6.3f\n", index, eepromConfig.freeMix[index][ROLL ], eepromConfig.freeMix[index][PITCH], eepromConfig.freeMix[index][YAW ]); } cliPrint("\n"); validQuery = false; break; /////////////////////////// case 'x': cliPrint("\nExiting Mixer CLI....\n\n"); cliBusy = false; return; break; /////////////////////////// case 'A': // Read Mixer Configuration eepromConfig.mixerConfiguration = (uint8_t)readFloatCLI(); initMixer(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'B': // Read ESC and Servo PWM Update Rates eepromConfig.escPwmRate = (uint16_t)readFloatCLI(); eepromConfig.servoPwmRate = (uint16_t)readFloatCLI(); pwmOutputConfig.escPwmRate = eepromConfig.escPwmRate; pwmOutputConfig.servoPwmRate = eepromConfig.servoPwmRate; pwmOutputInit(&pwmOutputConfig); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'C': // Read BiCopter Left Servo Parameters eepromConfig.biLeftServoMin = readFloatCLI(); eepromConfig.biLeftServoMid = readFloatCLI(); eepromConfig.biLeftServoMax = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'D': // Read BiCopter Right Servo Parameters eepromConfig.biRightServoMin = readFloatCLI(); eepromConfig.biRightServoMid = readFloatCLI(); eepromConfig.biRightServoMax = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'E': // Read Flying Wing Servo Directions eepromConfig.rollDirectionLeft = readFloatCLI(); eepromConfig.rollDirectionRight = readFloatCLI(); eepromConfig.pitchDirectionLeft = readFloatCLI(); eepromConfig.pitchDirectionRight = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'F': // Read Flying Wing Servo Limits eepromConfig.wingLeftMinimum = readFloatCLI(); eepromConfig.wingLeftMaximum = readFloatCLI(); eepromConfig.wingRightMinimum = readFloatCLI(); eepromConfig.wingRightMaximum = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'G': // Read Free Mix Motor Number eepromConfig.freeMixMotors = (uint8_t)readFloatCLI(); initMixer(); mixerQuery = 'b'; validQuery = true; break; /////////////////////////// case 'H': // Read Free Mix Matrix Element rows = (uint8_t)readFloatCLI(); columns = (uint8_t)readFloatCLI(); eepromConfig.freeMix[rows][columns] = readFloatCLI(); mixerQuery = 'b'; validQuery = true; break; /////////////////////////// case 'I': // Read Gimbal Roll Servo Parameters eepromConfig.gimbalRollServoMin = readFloatCLI(); eepromConfig.gimbalRollServoMid = readFloatCLI(); eepromConfig.gimbalRollServoMax = readFloatCLI(); eepromConfig.gimbalRollServoGain = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'J': // Read Gimbal Pitch Servo Parameters eepromConfig.gimbalPitchServoMin = readFloatCLI(); eepromConfig.gimbalPitchServoMid = readFloatCLI(); eepromConfig.gimbalPitchServoMax = readFloatCLI(); eepromConfig.gimbalPitchServoGain = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'K': // Read TriCopter YawServo Parameters eepromConfig.triYawServoMin = readFloatCLI(); eepromConfig.triYawServoMid = readFloatCLI(); eepromConfig.triYawServoMax = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'L': // Read V Tail Angle eepromConfig.vTailAngle = readFloatCLI(); mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'M': // Read yaw direction tempFloat = readFloatCLI(); if (tempFloat >= 0.0) tempFloat = 1.0; else tempFloat = -1.0; eepromConfig.yawDirection = tempFloat; mixerQuery = 'a'; validQuery = true; break; /////////////////////////// case 'W': // Write EEPROM Parameters cliPrint("\nWriting EEPROM Parameters....\n\n"); writeEEPROM(); break; /////////////////////////// case '?': cliPrint("\n"); cliPrint("'a' Mixer Configuration Data 'A' Set Mixer Configuration A1 thru 17, see baseFlightPlus.h\n"); cliPrint("'b' Free Mixer Configuration 'B' Set PWM Rates BESC;Servo\n"); cliPrint(" 'C' Set BiCopter Left Servo Parameters CMin;Mid;Max\n"); cliPrint(" 'D' Set BiCopter Right Servo Parameters DMin;Mid;Max\n"); cliPrint(" 'E' Set Flying Wing Servo Directions ERollLeft;RollRight;PitchLeft;PitchRight\n"); cliPrint(" 'F' Set Flying Wing Servo Limits FLeftMin;LeftMax;RightMin;RightMax\n"); cliPrint(" 'G' Set Number of FreeMix Motors GNumber\n"); cliPrint(" 'H' Set FreeMix Matrix Element HRow;Column;Element\n"); cliPrint(" 'I' Set Gimbal Roll Servo Parameters IMin;Mid;Max;Gain\n"); cliPrint(" 'J' Set Gimbal Pitch Servo Parameters JMin;Mid;Max;Gain\n"); cliPrint(" 'K' Set TriCopter Servo Parameters KMin;Mid;Max\n"); cliPrint(" 'L' Set V Tail Angle LAngle\n"); cliPrint(" 'M' Set Yaw Direction M1 or M-1\n"); cliPrint(" 'W' Write EEPROM Parameters\n"); cliPrint("'x' Exit Sensor CLI '?' Command Summary\n"); cliPrint("\n"); break; /////////////////////////// } } }
void systemInit(void) { RCC_ClocksTypeDef rccClocks; /////////////////////////////////// // Init cycle counter cycleCounterInit(); // SysTick SysTick_Config(SystemCoreClock / 1000); // Turn on peripherial clocks RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // USART1, USART2 RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE); // ADC2 RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE); // PPM RX RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); // PWM ESC Out 1 & 2 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); // PWM ESC Out 5 & 6 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); // PWM Servo Out 1, 2, 3, & 4 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE); // 500 Hz dt Counter RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE); // 100 Hz dt Counter RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM15, ENABLE); // PWM ESC Out 3 & 4 RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM16, ENABLE); // RangeFinder PWM RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM17, ENABLE); // Spektrum Frame Sync RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); // Telemetry RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); // GPS RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); // Spektrum RX /////////////////////////////////////////////////////////////////////////// spiInit(SPI2); /////////////////////////////////// checkSensorEEPROM(false); checkSystemEEPROM(false); readSensorEEPROM(); readSystemEEPROM(); /////////////////////////////////// if (systemConfig.receiverType == SPEKTRUM) checkSpektrumBind(); /////////////////////////////////// checkResetType(); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 bits for pre-emption priority, 2 bits for subpriority /////////////////////////////////// gpsPortClearBuffer = &uart2ClearBuffer; gpsPortNumCharsAvailable = &uart2NumCharsAvailable; gpsPortPrintBinary = &uart2PrintBinary; gpsPortRead = &uart2Read; telemPortAvailable = &uart1Available; telemPortPrint = &uart1Print; telemPortPrintF = &uart1PrintF; telemPortRead = &uart1Read; /////////////////////////////////// initMixer(); usbInit(); gpioInit(); uart1Init(); uart2Init(); LED0_OFF; delay(10000); // 10 seconds of 20 second delay for sensor stabilization checkUsbActive(); /////////////////////////////////// #ifdef __VERSION__ cliPortPrintF("\ngcc version " __VERSION__ "\n"); #endif cliPortPrintF("\nFF32mini Firmware V%s, Build Date " __DATE__ " "__TIME__" \n", __FF32MINI_VERSION); if ((RCC->CR & RCC_CR_HSERDY) != RESET) { cliPortPrint("\nRunning on external HSE clock....\n"); } else { cliPortPrint("\nERROR: Running on internal HSI clock....\n"); } RCC_GetClocksFreq(&rccClocks); cliPortPrintF("\nHCLK-> %2d MHz\n", rccClocks.HCLK_Frequency / 1000000); cliPortPrintF( "PCLK1-> %2d MHz\n", rccClocks.PCLK1_Frequency / 1000000); cliPortPrintF( "PCLK2-> %2d MHz\n", rccClocks.PCLK2_Frequency / 1000000); cliPortPrintF( "SYSCLK-> %2d MHz\n\n", rccClocks.SYSCLK_Frequency / 1000000); if (systemConfig.receiverType == PPM) cliPortPrint("Using PPM Receiver....\n\n"); else cliPortPrint("Using Spektrum Satellite Receiver....\n\n"); initUBLOX(); delay(10000); // Remaining 10 seconds of 20 second delay for sensor stabilization - probably not long enough.. /////////////////////////////////// adcInit(); aglInit(); pwmServoInit(); if (systemConfig.receiverType == SPEKTRUM) spektrumInit(); else ppmRxInit(); timingFunctionsInit(); batteryInit(); initFirstOrderFilter(); initMavlink(); initPID(); LED0_ON; initMPU6000(); initMag(); initPressure(); }
ALSAMixer::ALSAMixer() { int err; initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidOut"); initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidIn"); snd_mixer_selem_id_t *sid; snd_mixer_selem_id_alloca(&sid); for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) { if (!mMixer[i]) continue; mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t; property_get (mixerMasterProp[i].propName, info->name, mixerMasterProp[i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); //info->volume = info->max; //setVol[i] (elem, info->volume); //if (i == SND_PCM_STREAM_PLAYBACK && // snd_mixer_selem_has_playback_switch (elem)) // snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } ALOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found"); for (int j = 0; mixerProp[j][i].device; j++) { mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t; property_get (mixerProp[j][i].propName, info->name, mixerProp[j][i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); //info->volume = info->max; //setVol[i] (elem, info->volume); //if (i == SND_PCM_STREAM_PLAYBACK && // snd_mixer_selem_has_playback_switch (elem)) // snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } ALOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found"); } } ALOGV("mixer initialized."); }
int initEverything( void ) { #ifndef _DEBUG logFile = SDL_RWFromFile( "log.txt", "w" ); if( logFile != NULL ) { SDL_LogSetOutputFunction( LogOutput, NULL ); } #endif // memory first, won't be used everywhere at first so lets keep the initial allocation low, 64 MB mem_Init( 64 * 1024 * 1024 ); /* then SDL */ SDL_SetMainReady( ); if( SDL_Init( SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS ) != 0 ) { SDL_LogError( SDL_LOG_CATEGORY_APPLICATION, SDL_GetError( ) ); return -1; } SDL_LogInfo( SDL_LOG_CATEGORY_APPLICATION, "SDL successfully initialized" ); atexit( cleanUp ); // set up opengl // try opening and parsing the config file int majorVersion; int minorVersion; int redSize; int greenSize; int blueSize; int depthSize; void* oglCFGFile = cfg_OpenFile( "opengl.cfg" ); cfg_GetInt( oglCFGFile, "MAJOR", 3, &majorVersion ); cfg_GetInt( oglCFGFile, "MINOR", 3, &minorVersion ); cfg_GetInt( oglCFGFile, "RED_SIZE", 8, &redSize ); cfg_GetInt( oglCFGFile, "GREEN_SIZE", 8, &greenSize ); cfg_GetInt( oglCFGFile, "BLUE_SIZE", 8, &blueSize ); cfg_GetInt( oglCFGFile, "DEPTH_SIZE", 16, &depthSize ); cfg_CloseFile( oglCFGFile ); majorVersion = 2; minorVersion = 1; // want the core functionality SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE ); SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, majorVersion ); SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, minorVersion ); // want 8 bits minimum per color SDL_GL_SetAttribute( SDL_GL_RED_SIZE, redSize ); SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, greenSize ); SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, blueSize ); // want 16 bit depth buffer SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, depthSize ); // want it to be double buffered SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); window = SDL_CreateWindow( windowName, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL ); if( window == NULL ) { SDL_LogError( SDL_LOG_CATEGORY_VIDEO, SDL_GetError( ) ); return -1; } SDL_LogInfo( SDL_LOG_CATEGORY_APPLICATION, "SDL OpenGL window successfully created" ); /* Load and create images */ if( gfx_Init( window ) < 0 ) { return -1; } SDL_LogInfo( SDL_LOG_CATEGORY_APPLICATION, "Rendering successfully initialized" ); /* Load and create sounds and music */ if( initMixer( ) < 0 ) { return -1; } SDL_LogInfo( SDL_LOG_CATEGORY_APPLICATION, "Mixer successfully initialized" ); cam_Init( ); cam_SetProjectionMatrices( window ); SDL_LogInfo( SDL_LOG_CATEGORY_APPLICATION, "Cameras successfully initialized" ); loadAllResources( ); return 0; }