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;
}
