void Katapult::initDisplay() { display = settings->display(); if(display == 0) { initAccel(this); } else { initAccel(display); setQuery(""); connect(display, SIGNAL(keyReleased(QKeyEvent *)), this, SLOT(keyReleased(QKeyEvent *))); connect(display, SIGNAL(focusOut()), this, SLOT(hideLauncher())); } }
int main(void) { ConfigPins(); initUART(); initSysTick(); RValue = initAccel(); printInteger(RValue); if (RValue == 0) { printString("Boldly going :)\r\n"); } else { printString("Inertia sensors offline :(\r\n"); } while (1) { Temperature = getTemperature(); printShort(Temperature); printString(" "); getMotion(&m); printShort(m.x_a); printString(" "); printShort(m.y_a); printString(" "); printShort(m.z_a); printString(" "); printString("\r\n"); GPIO0DATA ^= BIT2; delay(10000); } return 0; }
uint16_t LSM9DS0_begin( LSM9DS0_t* lsm_t, LMS9DS0_Init_t* init_t ) { #if (DEBUG0==1) uint8_t test[8]; #endif uint8_t gTest, xmTest; if(init_t==NULL) init_t = &LMS_Device_Defaults; // Store the given scales in class variables. These scale variables // are used throughout to calculate the actual g's, DPS,and Gs's. lsm_t->gScale = init_t->gScl; lsm_t->aScale = init_t->aScl; lsm_t->mScale = init_t->mScl; // Once we have the scale values, we can calculate the resolution // of each sensor. That's what these functions are for. One for each sensor calcgRes(lsm_t); // Calculate DPS / ADC tick, stored in gRes variable calcmRes(lsm_t); // Calculate Gs / ADC tick, stored in mRes variable calcaRes(lsm_t); // Calculate g / ADC tick, stored in aRes variable // Now, initialize our hardware interface. #if(LSM_I2C_SUPPORT==1) if (lsm_t->interfaceMode == MODE_I2C) // If we're using I2C LSM_initI2C(); // Initialize I2C else if (lsm_t->interfaceMode == MODE_SPI) // else, if we're using SPI #endif //LSM_initSPI(); // Initialize SPI // To verify communication, we can read from the WHO_AM_I register of // each device. Store those in a variable so we can return them. gTest = gReadByte(lsm_t,WHO_AM_I_G); // Read the gyro WHO_AM_I xmTest = xmReadByte(lsm_t,WHO_AM_I_XM); // Read the accel/mag WHO_AM_I // Gyro initialization stuff: initGyro(lsm_t); // This will "turn on" the gyro. Setting up interrupts, etc. setGyroODR(lsm_t,init_t->gODR); // Set the gyro output data rate and bandwidth. setGyroScale(lsm_t,lsm_t->gScale); // Set the gyro range // Accelerometer initialization stuff: initAccel(lsm_t); // "Turn on" all axes of the accel. Set up interrupts, etc. setAccelODR(lsm_t,init_t->aODR); // Set the accel data rate. setAccelScale(lsm_t,lsm_t->aScale); // Set the accel range. // Magnetometer initialization stuff: initMag(lsm_t); // "Turn on" all axes of the mag. Set up interrupts, etc. setMagODR(lsm_t,init_t->mODR); // Set the magnetometer output data rate. setMagScale(lsm_t,lsm_t->mScale); // Set the magnetometer's range. LSM9DS0_Update_Ctrl(lsm_t); lsm_t->update=UPDATE_ON_SET; #if (DEBUG0==1) I2CreadBytes(lsm_t->gAddress,CTRL_REG1_G,test,5); I2CreadBytes(lsm_t->xmAddress,CTRL_REG0_XM,test,7); #endif // Once everything is initialized, return the WHO_AM_I registers we read: return (xmTest << 8) | gTest; }
uint16_t LSM9DS1::begin() { //! Todo: don't use ACCEL_GYRO_ADDRESS or MAGNETOMETER_ADDRESS, duplicating memory constrainScales(); // Once we have the scale values, we can calculate the resolution // of each sensor. That's what these functions are for. One for each sensor calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable calcaRes(); // Calculate g / ADC tick, stored in aRes variable initI2C(); // Initialize I2C // To verify communication, we can read from the WHO_AM_I register of // each device. Store those in a variable so we can return them. uint8_t mTest = mReadByte(WHO_AM_I_M); // Read the gyro WHO_AM_I uint8_t xgTest = xgReadByte(WHO_AM_I_XG); // Read the accel/mag WHO_AM_I uint16_t whoAmICombined = (xgTest << 8) | mTest; if (whoAmICombined != ((WHO_AM_I_AG_RSP << 8) | WHO_AM_I_M_RSP)) return 0; // Gyro initialization stuff: initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc. // Accelerometer initialization stuff: initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc. // Magnetometer initialization stuff: initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc. // Once everything is initialized, return the WHO_AM_I registers we read: return whoAmICombined; }
/* ************************************************************************** */ uint16_t LSM9DS0_begin_adv( stLSM9DS0_t * stThis, gyro_scale gScl, accel_scale aScl, mag_scale mScl, gyro_odr gODR, accel_odr aODR, mag_odr mODR ) { // Default to 0xFF to indicate status is not OK uint8_t gTest = 0xFF; uint8_t xmTest = 0xFF; byte byDatas; byte byAddress = 0x1D; byte bySubAddress = 0x0F; // Wiat for a few millis at the beginning for the chip to boot WAIT1_Waitms( 200 ); // Store the given scales in class variables. These scale variables // are used throughout to calculate the actual g's, DPS,and Gs's. stThis->gScale = gScl; stThis->aScale = aScl; stThis->mScale = mScl; // Once we have the scale values, we can calculate the resolution // of each sensor. That's what these functions are for. One for each sensor calcgRes(stThis); // Calculate DPS / ADC tick, stored in gRes variable calcmRes(stThis); // Calculate Gs / ADC tick, stored in mRes variable calcaRes(stThis); // Calculate g / ADC tick, stored in aRes variable // Now, initialize our hardware interface. if (stThis->interfaceMode == MODE_I2C) // If we're using I2C initI2C(stThis); // Initialize I2C else if (stThis->interfaceMode == MODE_SPI) // else, if we're using SPI initSPI(stThis); // Initialize SPI // To verify communication, we can read from the WHO_AM_I register of // each device. Store those in a variable so we can return them. gTest = gReadByte( stThis, WHO_AM_I_G ); // Read the gyro WHO_AM_I xmTest = xmReadByte( stThis, WHO_AM_I_XM ); // Read the accel/mag WHO_AM_I // Gyro initialization stuff: initGyro(stThis); // This will "turn on" the gyro. Setting up interrupts, etc. LSM9DS0_setGyroODR(stThis, gODR); // Set the gyro output data rate and bandwidth. LSM9DS0_setGyroScale(stThis, stThis->gScale); // Set the gyro range // Accelerometer initialization stuff: initAccel(stThis); // "Turn on" all axes of the accel. Set up interrupts, etc. LSM9DS0_setAccelODR(stThis, aODR); // Set the accel data rate. LSM9DS0_setAccelScale(stThis, stThis->aScale); // Set the accel range. // Magnetometer initialization stuff: initMag(stThis); // "Turn on" all axes of the mag. Set up interrupts, etc. LSM9DS0_setMagODR(stThis, mODR); // Set the magnetometer output data rate. LSM9DS0_setMagScale(stThis, stThis->mScale); // Set the magnetometer's range. // Once everything is initialized, return the WHO_AM_I registers we read: return (xmTest << 8) | gTest; }
int main(void) { thread_t *sh = NULL; PollerData.temp = 0; PollerData.press = 0;/* PollerData.uTime = 0;*/ halInit(); chSysInit(); shellInit(); usbDisconnectBus(serusbcfg.usbp); chThdSleepMilliseconds(1000); usbStart(serusbcfg.usbp, &usbcfg); usbConnectBus(serusbcfg.usbp); sduObjectInit(&SDU1); sduStart(&SDU1, &serusbcfg); // SPI-related pins (for display) palSetPadMode(GPIOB, 11, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOB, 10, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5)); palSetPadMode(GPIOB, 14, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5)); spiStart(&SPID1, &spi1cfg); spiStart(&SPID2, &spi2cfg); i2cStart(&I2CD1, &i2cconfig); initGyro(); initAccel(); initMag(); // nunchuk_status = nunchuk_init(); bmp085_status = bmp085_init(); lcd5110Init(); lcd5110SetPosXY(0, 0); lcd5110WriteText("P :: "); lcd5110SetPosXY(0, 1); lcd5110WriteText("T :: "); chThdCreateStatic(waThreadBlink, sizeof(waThreadBlink), NORMALPRIO, ThreadBlink, NULL); chThdCreateStatic(waThreadButton, sizeof(waThreadButton), NORMALPRIO, ThreadButton, NULL); chThdCreateStatic(waPoller, sizeof(waPoller), NORMALPRIO, ThreadPoller, NULL); while (TRUE) { if (!sh) { sh = shellCreate(&shCfg, SHELL_WA_SIZE, NORMALPRIO); } else if (chThdTerminatedX(sh)) { chThdRelease(sh); sh = NULL; } chThdSleepMilliseconds(1000); } return 0; // never returns, lol }
uint16_t begin(void) { //! Todo: don't use _xgAddress or _mAddress, duplicating memory _xgAddress = settings.device.agAddress; _mAddress = settings.device.mAddress; constrainScales(); // Once we have the scale values, we can calculate the resolution // of each sensor. That's what these functions are for. One for each sensor calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable calcaRes(); // Calculate g / ADC tick, stored in aRes variable if (settings.device.commInterface == IMU_MODE_I2C) // If we're using I2C initI2C(); // Initialize I2C else if (settings.device.commInterface == IMU_MODE_SPI) // else, if we're using SPI initSPI(); // Initialize SPI // To verify communication, we can read from the WHO_AM_I register of // each device. Store those in a variable so we can return them. uint8_t mTest = mReadByte(WHO_AM_I_M); // Read the gyro WHO_AM_I delay(DELAY * 150); uint8_t xgTest = xgReadByte(WHO_AM_I_XG); // Read the accel/mag WHO_AM_I uint16_t whoAmICombined = (xgTest << 8) | mTest; if (whoAmICombined != ((WHO_AM_I_AG_RSP << 8) | WHO_AM_I_M_RSP)) { return 0; } // Gyro initialization stuff: initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc. // Accelerometer initialization stuff: initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc. // Magnetometer initialization stuff: initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc. // Once everything is initialized, return the WHO_AM_I registers we read: return whoAmICombined; }
uint16_t LSM9DS0::begin(gyro_scale gScl, accel_scale aScl, mag_scale mScl, gyro_odr gODR, accel_odr aODR, mag_odr mODR) { // Store the given scales in class variables. These scale variables // are used throughout to calculate the actual g's, DPS,and Gs's. gScale = gScl; aScale = aScl; mScale = mScl; // Once we have the scale values, we can calculate the resolution // of each sensor. That's what these functions are for. One for each sensor calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable calcaRes(); // Calculate g / ADC tick, stored in aRes variable // Now, initialize our hardware interface. if (interfaceMode == MODE_I2C) // If we're using I2C {} //initI2C(); // Initialize I2C else if (interfaceMode == MODE_SPI) // else, if we're using SPI initSPI(); // Initialize SPI // To verify communication, we can read from the WHO_AM_I register of // each device. Store those in a variable so we can return them. uint8_t gTest = gReadByte(WHO_AM_I_G); // Read the gyro WHO_AM_I uint8_t xmTest = xmReadByte(WHO_AM_I_XM); // Read the accel/mag WHO_AM_I // Gyro initialization stuff: initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc. setGyroODR(gODR); // Set the gyro output data rate and bandwidth. setGyroScale(gScale); // Set the gyro range // Accelerometer initialization stuff: initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc. setAccelODR(aODR); // Set the accel data rate. setAccelScale(aScale); // Set the accel range. // Magnetometer initialization stuff: initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc. setMagODR(mODR); // Set the magnetometer output data rate. setMagScale(mScale); // Set the magnetometer's range. // Once everything is initialized, return the WHO_AM_I registers we read: return (xmTest << 8) | gTest; }
/** Power on and prepare for general usage. * This will activate the device and take it out of sleep mode (which must be done * after start-up). This function also sets both the accelerometer and the gyroscope * to their most sensitive settings, namely +/- 2g and +/- 250 degrees/sec, and sets * the clock source to use the X Gyro for reference, which is slightly better than * the default internal clock source. */ PUBLIC void initializeLSM6DS0(bool useAccel, bool useGyro) { xAccelOffset = yAccelOffset = zAccelOffset = 0; xGyroOffset = yGyroOffset = zGyroOffset = 0; gyroEnabled = useGyro; accelEnabled = useAccel; if(gyroEnabled) { gScale = GYRO_FS_245DSP; calcGyroRes(); } if(accelEnabled) { aScale = ACC_FS_2G; calcAccelRes(); } if(testConnection()) { resetLSM6DS0(); if(accelEnabled) { initAccel(); setFullScaleAccelRange(aScale); setAccelODR(ACC_ODR_119Hz); } if(gyroEnabled) { initGyro(); setFullScaleGyroRange(gScale); setGyroODR(GYRO_ODR_119Hz_CO_14Hz); } calibrateLSM6DS0(gbias,abias); } }
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(); }
int main(void) { uint8_t sensor; // Stores analog readings for transmission int i; // multipurpose counter char choice = 0; // Holds the top-level menu character // int red = 0; // For the red LED intensity // int green = 0; // For the green LED intensity // int blue = 0; // For the blue LED intensity uint8_t exit = 0; // Flag that gets set if we need to go back to idle mode. unsigned int temph=0; // Temporary variable (typically stores high byte of a 16-bit int ) unsigned int templ=0; // Temporary variable (typically stores low byte of a 16-bit int) uint8_t location = 0; // Holds the EEPROM location of a stored IR signal // unsigned int frequency = 0; // For PWM control - PWM frequency, also used to set buzzer frequency // int amplitude; int channel; unsigned int duty; // For PWM control - PWM duty cycle int baud; // Baud rate selection for auxiliary UART char scale; // For auxiliary UART long int time_out=0; // Counter which counts to a preset level corresponding to roughly 1 minute // Initialize system // Turn off JTAG to save a bit of battery life CCP = CCP_IOREG_gc; MCU.MCUCR = 1; init_clock(); init_led(); init_adc(); init_ir(); init_BT(); init_dac(); init_buzzer(); initAccel(); init_aux_uart(131, -3); // Set the auxiliary uart to 115200 8n1 EEPROM_DisableMapping(); // Enable global interrupts sei(); // Do the following indefinitely while(1) { // Turn off LED set_led(0,0,0); // Reset flags (in case this isn't the first time through the loop) exit = 0; choice = 0; time_out = 0; stop_ir_timer(); // Sing a BL song in idle mode so you can be found. Stop as soon as you get a * while(choice != 42) { bt_putchar('B'); bt_putchar('L'); if (USART_RXBufferData_Available(&BT_data)) { choice = USART_RXBuffer_GetByte(&BT_data); if (choice == 128) { // Something is trying to connect directly to an iRobot set_aux_baud_rate( ROOMBA_UART_SETTINGS ); // depends on model aux_putchar( 128); // pass through to iRobot serial_bridge(); // currently never returns } else if (choice == 0) { // Something may be trying to connect directly to a MindFlex headset set_aux_baud_rate( 135, -2); // 57600 aux_putchar( 0); // pass through to headset serial_bridge(); // currently never returns; } else { bt_putchar(choice); } } if (choice != 42) _delay_ms(500); } // Active part of the program - listens for commands and responds as necessary while(exit == 0) { // Checks if we haven't heard anything for a long time, in which case we exit loop and go back to idle mode time_out++; // Corresponds to roughly 60 seconds if(time_out > 33840000) { exit = 1; } // Check for a command character if (USART_RXBufferData_Available(&BT_data)) { choice = USART_RXBuffer_GetByte(&BT_data); } else { choice = 0; } // If it exists, act on command if(choice != 0) { // Reset the time out time_out = 0; // Return the command so the host knows we got it bt_putchar(choice); // Giant switch statement to decide what to do with the command switch(choice) { // Return the currect accelerometer data - X, Y, Z, and status (contains tapped and shaken bits) case 'A': updateAccel(); bt_putchar(_acc.x); bt_putchar(_acc.y); bt_putchar(_acc.z); bt_putchar(_acc.status); break; // Set the buzzer case 'B': // frequency_divider(2) if (get_arguments(2)) { set_buzzer(GET_16BIT_ARGUMENT(0)); } break; // Turn off the buzzer case 'b': turn_off_buzzer(); break; // Returns the value of the light sensor case 'L': sensor = read_analog(LIGHT, 0); bt_putchar(sensor); break; // Returns the Xmegas internal temperature read - this is undocumented because the value returned is very erratic case 'T': sensor = read_internal_temperature(); bt_putchar(sensor); break; // Returns the battery voltage case 'V': sensor = read_analog(BATT_VOLT, 0); bt_putchar(sensor); break; // Differential ADC mode case 'D': // active(1) numgainstages(1) if (get_arguments(2)) { if (arguments[0] == '0') { adcResolution = ADC_RESOLUTION_8BIT_gc; adcConvMode = ADC_ConvMode_Unsigned; adcGain = ADC_DRIVER_CH_GAIN_NONE; adcInputMode = ADC_CH_INPUTMODE_SINGLEENDED_gc; init_adc(); } else if (arguments[0] == '1') { adcResolution = ADC_RESOLUTION_12BIT_gc; adcConvMode = ADC_ConvMode_Signed; if (arguments[1] >= '1' && arguments[1] <= '6') { // number of gain stages adcGain = (arguments[1] - '0') << ADC_CH_GAINFAC_gp; adcInputMode = ADC_CH_INPUTMODE_DIFFWGAIN_gc; init_adc(); } else if (arguments[1] == '0') { adcGain = ADC_DRIVER_CH_GAIN_NONE; adcInputMode = ADC_CH_INPUTMODE_DIFF_gc; init_adc(); } else { err(); } } else { err(); } } break; // Returns the readings on all six ADC ports case 'X': for (i=0; i<6; i++) { sensor = read_analog(pgm_read_byte_near(muxPosPins+i), 0); bt_putchar(sensor); } break; // Returns differential measurement on pair of ADC ports // Assumes we are in differential mode case 'x': if (get_arguments(2)) { i = read_differential(arguments[0], arguments[1]); bt_putchar(0xFF&(i >> 8)); bt_putchar(0xFF&i); } break; case 'e': // this is a bit of testing code, which will eventually be changed // do not rely on it if (get_arguments(2)) { char a1 = arguments[0]; char a2 = arguments[1]; while(1) { _delay_ms(2); i = read_differential(a1, a2); itoa((i<<4)>>4, (char*)arguments, 10); for (i=0; arguments[i]; i++) bt_putchar(arguments[i]); bt_putchar('\r'); bt_putchar('\n'); } } break; // Sets the full-color LED case 'O': // red(1) green(1) blue(1); if (get_arguments(3)) { set_led(arguments[0], arguments[1], arguments[2]); } break; // Switches serial between irDA and standard serial // Currently, this works over the same port numbers as // standard serial, instead of using the IR receiver // and IR LED. This may change when I get the IR receiver // and LED working reliably. case 'J': temph = bt_getchar_timeout_echo(); if(/*temph == 256 || */ temph < '0' || temph > '1') { err(); break; } set_irda_mode(temph - '0'); break; // Sets up the IR transmitter with signal characteristics case 'I': init_ir(); temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } // Set the frequency of the IR carrier robotData.frequency = ((temph)<<8) + templ; set_ir_carrier(robotData.frequency); templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } else { // Set the length of the start up pulses robotData.startUpPulseLength = templ; } if(robotData.startUpPulseLength > 16) { err(); break; } // Read in the start up pulse timing data for(i=0; i < robotData.startUpPulseLength; i++) { temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } robotData.startUpPulse[i] = ((temph)<<8) + templ; } if(temph == 256 || templ == 256) { break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } // Set the bit encoding to one of four pre-determined settings (see protocol instructions for more information) robotData.bitEncoding = templ; templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } // Set the number of bits (and bytes) contained in an IR command robotData.numBits = templ; robotData.numBytes = (robotData.numBits-1)/8 + 1; temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } // Set timing data for a high bit robotData.highBitTime = ((temph)<<8) + templ; temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } // Set timing data for a low bit robotData.lowBitTime = ((temph)<<8) + templ; temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } // Set timing data for on or off robotData.offTime = ((temph)<<8) + templ; break; // Transmit an IR signal according to the previously determined configuration case 'i': init_ir(); // Get the signal data as one or more bytes for(i = 0; i < robotData.numBytes; i++) { templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } robotData.irBytes[i] = templ; } if(templ == 256) { break; } temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } // Determine if the signal is repeated or not, and if so, with what frequency robotData.repeatTime = ((temph)<<8) + templ; if(robotData.repeatTime != 0) { robotData.repeatFlag = 1; } else { robotData.repeatFlag = 0; } // Startup timer interrupts start_ir_timer(); break; // Turn off any repeating IR signal case '!': robotData.repeatFlag = 0; stop_ir_timer(); break; // Capture a signal from the IR receiver case 'R': init_ir_read(); while(ir_read_flag!=0); break; // Store the captured signal in an EEPROM location case 'S': location = bt_getchar_timeout_echo()-48; // Subtracting 48 converts from ASCII to numeric numbers if((location >= 0) && (location < 5) && (signal_count > 4)) { write_data_to_eeprom(location); } else { err(); } break; // Receive a raw IR signal over bluetooth and transmit it with the IR LED case 's': if(read_data_from_serial()) { temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } // Set if the signal should repeat and if so, with what frequency robotData.repeatTime = ((temph)<<8) + templ; if(robotData.repeatTime != 0) { robotData.repeatFlag = 1; } else { robotData.repeatFlag = 0; } // Set frequency to 38KHz, since raw signals must have come from the receiver at some point robotData.frequency = 0x0349; robotData.startUpPulseLength = 0; robotData.bitEncoding = 0x04; start_ir_timer(); } else { err(); break; } break; // Get a stored signal from an EEPROM location and transmit it over the IR LED (and repeat as desired) case 'G': location = bt_getchar_timeout_echo()-48; if(location >= 0 && location < 5) { temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } robotData.repeatTime = ((temph)<<8) + templ; if(robotData.repeatTime != 0) { robotData.repeatFlag = 1; } else { robotData.repeatFlag = 0; } read_data_from_eeprom(location); robotData.frequency = 0x0349; robotData.startUpPulseLength = 0; robotData.bitEncoding = 0x04; start_ir_timer(); } else { err(); } break; // Get a stored signal from EEPROM and print it over bluetooth to the host case 'g': location = bt_getchar_timeout_echo()-48; if(location >= 0 && location < 5) { print_data_from_eeprom(location); } else { err(); } break; // Output on digital I/O case '>': // Set port temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } // Get value templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } set_output(temph, (templ-48)); break; // Input on digital I/O case '<': // Get port temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } // Get value (1 or 0) templ = read_input(temph)+48; bt_putchar(templ); break; // Configure PWM frequency case 'P': if (get_arguments(2)) pwm_frequency = GET_16BIT_ARGUMENT(0); break; // Set PWM duty cycle for a specific port case 'p': if (get_arguments(3)) { set_pwm(); duty = GET_16BIT_ARGUMENT(1); if (arguments[0] == '0') set_pwm0(duty); else if (arguments[1] == '1') set_pwm1(duty); // could add else err();, but original firmware doesn't do this } break; // Set DAC voltage on one of the two DAC ports case 'd': temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } if(temph == '0') { temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } else { set_dac0(temph); } } else if(temph == '1') { temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } else { set_dac1(temph); } } break; // Go back to idle mode so you can be found again. Should be sent at end of host program. case 'Q': exit = 1; break; // Human-readable uart speed setting case 'u': temph = bt_getchar_timeout_echo(); if(temph == 256) { err(); break; } templ = bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } baud = ((temph)<<8) + templ; switch(baud) { case ('1'<<8) + '2': // 1200 baud = 6663; scale = -2; break; case ('4'<<8) + '8': // 4800 baud = 3325; scale = -3; break; case ('9'<<8) + '6': // 9600 baud = 829; scale = -2; break; case ('1'<<8) + '9': // 19200 baud = 825; scale = -3; break; case ('3'<<8) + '8': // 38400 baud = 204; scale = -2; break; case ('5'<<8) + '7': // 57600 baud = 135; scale = -2; break; case ('1'<<8) + '1': // 115200 baud = 131; scale = -3; break; default: err(); goto BAUD_DONE; } set_aux_baud_rate(baud, scale); BAUD_DONE: break; // Configures the baud rate of the auxiliary UART case 'C': // baud(2) scale(1) // e.g., 9600 = C\x03\x3D\xFE if (! get_arguments(3)) break; bt_putchar(arguments[2]); // duplicate buggy behavior from official firmware; delete if unwanted set_aux_baud_rate( GET_16BIT_ARGUMENT(0), arguments[2]); break; // BT-serial high speed bridge mode case 'Z': serial_bridge(); break; case 'w': // channel(1) type(1) duty(1) amplitude(1) frequency(3) // w0s\x20\xFF\x02\x00\x00 if (!get_arguments(7)) break; if (arguments[0] < '0' || arguments[0] > '1' || arguments[2] > WAVEFORM_SIZE) { err(); break; } play_wave_dac(arguments[0]-'0', (char)arguments[1], arguments[2], arguments[3], get_24bit_argument(4)); break; case 'W': // channel(1) frequency(3) length(1) data(length) if (!get_arguments(5)) break; if (arguments[0] < '0' || arguments[0] > '1' || arguments[4] > WAVEFORM_SIZE || arguments[4] == 0 ) { err(); break; } channel = arguments[0] - '0'; if (bt_to_buffer(waveform[channel], arguments[4])) { disable_waveform(channel); play_arb_wave(channel, waveform[channel], arguments[4], get_24bit_argument(1)); } break; case '@': channel = bt_getchar_timeout_echo(); if (channel == '0') disable_waveform0(); else if (channel == '1') disable_waveform1(); else err(); break; case 'r': i = USART_RXBufferData_AvailableCount(&AUX_data); bt_putchar((uint8_t)(i+1)); while(i-- > 0) { bt_putchar(USART_RXBuffer_GetByte(&AUX_data)); } break; // Transmit a stream of characters from bluetooth to auxiliary serial case 't': temph= bt_getchar_timeout_echo(); if (temph == 256) { err(); break; } for(; temph>0; temph--) { templ= bt_getchar_timeout_echo(); if(templ == 256) { err(); break; } else { aux_putchar( templ); } } break; default: break; } }
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(); }