void serialInit(uint32_t baudrate)
{
int idx;
core.mainport = uartOpen(USART1, NULL, baudrate, MODE_RXTX);
// calculate used boxes based on features and fill availableBoxes[] array
memset(availableBoxes, 0xFF, sizeof(availableBoxes));
idx = 0;
availableBoxes[idx++] = BOXARM;
if (sensors(SENSOR_ACC)) {
availableBoxes[idx++] = BOXANGLE;
availableBoxes[idx++] = BOXHORIZON;
}
if (sensors(SENSOR_BARO)) {
availableBoxes[idx++] = BOXBARO;
if (feature(FEATURE_VARIO))
availableBoxes[idx++] = BOXVARIO;
}
if (sensors(SENSOR_ACC) || sensors(SENSOR_MAG)) {
availableBoxes[idx++] = BOXMAG;
availableBoxes[idx++] = BOXHEADFREE;
availableBoxes[idx++] = BOXHEADADJ;
}
if (feature(FEATURE_SERVO_TILT))
availableBoxes[idx++] = BOXCAMSTAB;
if (feature(FEATURE_GPS)) {
availableBoxes[idx++] = BOXGPSHOME;
availableBoxes[idx++] = BOXGPSHOLD;
}
if (mcfg.mixerConfiguration == MULTITYPE_FLYING_WING || mcfg.mixerConfiguration == MULTITYPE_AIRPLANE)
availableBoxes[idx++] = BOXPASSTHRU;
availableBoxes[idx++] = BOXBEEPERON;
if (feature(FEATURE_INFLIGHT_ACC_CAL))
availableBoxes[idx++] = BOXCALIB;
availableBoxes[idx++] = BOXOSD;
numberBoxItems = idx;
}
void gpsInit(uint8_t baudrateIndex)
{
portMode_t mode = MODE_RXTX;
// init gpsData structure. if we're not actually enabled, don't bother doing anything else
gpsSetState(GPS_UNKNOWN);
if (!feature(FEATURE_GPS))
return;
gpsData.baudrateIndex = baudrateIndex;
gpsData.lastMessage = millis();
gpsData.errors = 0;
// only RX is needed for NMEA-style GPS
if (mcfg.gps_type == GPS_NMEA)
mode = MODE_RX;
gpsSetPIDs();
// Open GPS UART, no callback - buffer will be read out in gpsThread()
core.gpsport = uartOpen(USART2, NULL, gpsInitData[baudrateIndex].baudrate, mode);
// signal GPS "thread" to initialize when it gets to it
gpsSetState(GPS_INITIALIZING);
}
void HardwareSerial3::begin(uint32_t baud)
{
this->_uart = uartOpen(USART3, serial_event_3, baud, MODE_RX, SERIAL_NOT_INVERTED);
serial3_rx_index = 0;
}
serialPort_t *openSerialPort(
serialPortIdentifier_e identifier,
serialPortFunction_e function,
serialReceiveCallbackPtr callback,
uint32_t baudRate,
portMode_t mode,
portOptions_t options)
{
#if (!defined(USE_VCP) && !defined(USE_UART1) && !defined(USE_UART2) && !defined(USE_UART3) && !defined(USE_UART4) && !defined(USE_UART5) && !defined(USE_SOFTSERIAL1) && !defined(USE_SOFTSERIAL1))
UNUSED(callback);
UNUSED(baudRate);
UNUSED(mode);
UNUSED(options);
#endif
serialPortUsage_t *serialPortUsage = findSerialPortUsageByIdentifier(identifier);
if (!serialPortUsage || serialPortUsage->function != FUNCTION_NONE) {
// not available / already in use
return NULL;
}
serialPort_t *serialPort = NULL;
switch(identifier) {
#ifdef USE_VCP
case SERIAL_PORT_USB_VCP:
serialPort = usbVcpOpen();
break;
#endif
#ifdef USE_UART1
case SERIAL_PORT_UART1:
serialPort = uartOpen(USART1, callback, baudRate, mode, options);
break;
#endif
#ifdef USE_UART2
case SERIAL_PORT_UART2:
serialPort = uartOpen(USART2, callback, baudRate, mode, options);
break;
#endif
#ifdef USE_UART3
case SERIAL_PORT_UART3:
serialPort = uartOpen(USART3, callback, baudRate, mode, options);
break;
#endif
#ifdef USE_UART4
case SERIAL_PORT_UART4:
serialPort = uartOpen(UART4, callback, baudRate, mode, options);
break;
#endif
#ifdef USE_UART5
case SERIAL_PORT_UART5:
serialPort = uartOpen(UART5, callback, baudRate, mode, options);
break;
#endif
#ifdef USE_SOFTSERIAL1
case SERIAL_PORT_SOFTSERIAL1:
serialPort = openSoftSerial(SOFTSERIAL1, callback, baudRate, options);
serialSetMode(serialPort, mode);
break;
#endif
#ifdef USE_SOFTSERIAL2
case SERIAL_PORT_SOFTSERIAL2:
serialPort = openSoftSerial(SOFTSERIAL2, callback, baudRate, options);
serialSetMode(serialPort, mode);
break;
#endif
default:
break;
}
if (!serialPort) {
return NULL;
}
serialPort->identifier = identifier;
serialPortUsage->function = function;
serialPortUsage->serialPort = serialPort;
return serialPort;
}
/*---------------------------------------------------------------------------
TITLE : cmd_bluetooth_change_name
WORK :
ARG : void
RET : void
---------------------------------------------------------------------------*/
void cmd_bluetooth_change_name( void )
{
uint32_t time_out;
uint8_t ch;
uint8_t ch_array[20] = "AT+NAME";
uint8_t ch_i;
uint8_t ch_offset;
osStatus ret;
ret = osMutexWait( Mutex_Loop, 1000 );
if( ret != osOK )
{
_menu_printf("Fail to osMutexWait\r\n");
return;
}
core.blueport = uartOpen(USART2, NULL, 115200, MODE_RXTX);
//-- 이름 입력
//
_menu_printf("Enter Name : ");
ch_i = 0;
ch_offset = 7;
while(1)
{
if( _menu_received() > 0 )
{
ch = _menu_getch();
if( ch_i < 12 && ch != 0x0D )
{
ch_array[ch_offset+ch_i++] = ch;
}
else
{
break;
}
_menu_printf("%c", ch);
if( ch == 0x0D )
{
_menu_printf("\r\n");
break;
}
}
}
ch_array[ch_offset+ch_i] = 0;
//-- 블루투스 설정
//
//serialPrint(core.blueport, "AT+NAMEbaram1");
serialPrint(core.blueport, (const char *)ch_array);
ch_array[0] = 0;
ch_array[1] = 0;
ch_i = 0;
//-- 응답이 올때까지 기다림
time_out = 1000;
while(time_out--)
{
if( serialTotalBytesWaiting(core.blueport) )
{
ch = serialRead(core.blueport);
//_menu_putch(ch);
ch_array[ch_i++] = ch;
if( ch_i >= 2 ) break;
}
osDelay(1);
}
if( ch_array[0] == 'O' && ch_array[1] == 'K' )
{
_menu_printf("\r\nBluetooth OK");
}
else
{
_menu_printf("\r\nBluetooth Fail");
}
_menu_printf("\r\nEnd\r\n");
serialInit(mcfg.serial_baudrate);
osMutexRelease( Mutex_Loop );
}
/*---------------------------------------------------------------------------
TITLE : cmd_bluetooth_setup
WORK :
ARG : void
RET : void
---------------------------------------------------------------------------*/
void cmd_bluetooth_setup( void )
{
uint32_t time_out;
uint8_t ch;
osStatus ret;
//-- MW의 메인 Loop를 중지 시킨다.
//
ret = osMutexWait( Mutex_Loop, 1000 );
if( ret != osOK )
{
_menu_printf("Fail to osMutexWait\r\n");
return;
}
_menu_printf("\r\nUart2 Open 9600BPS \r\n");
core.blueport = uartOpen(USART2, NULL, 9600, MODE_RXTX);
_menu_printf("\r\nAT -> ");
serialPrint(core.blueport, "AT");
//-- 응답이 올때까지 기다림
time_out = 100;
while(time_out--)
{
if( serialTotalBytesWaiting(core.blueport) )
{
ch = serialRead(core.blueport);
_menu_putch(ch);
}
osDelay(1);
}
_menu_printf("\r\nAT+BAUD4 -> ");
serialPrint(core.blueport, "AT+BAUD4");
//-- 응답이 올때까지 기다림
time_out = 500;
while(time_out--)
{
if( serialTotalBytesWaiting(core.blueport) )
{
ch = serialRead(core.blueport);
_menu_putch(ch);
}
osDelay(1);
}
_menu_printf("\r\nAT+RESET -> ");
serialPrint(core.blueport, "AT+RESET");
//-- 응답이 올때까지 기다림
time_out = 500;
while(time_out--)
{
if( serialTotalBytesWaiting(core.blueport) )
{
ch = serialRead(core.blueport);
_menu_putch(ch);
}
osDelay(1);
}
_menu_printf("\r\n");
serialInit(mcfg.serial_baudrate);
osMutexRelease( Mutex_Loop );
}
serialPort_t *openSerialPort(
serialPortIdentifier_e identifier,
serialPortFunction_e function,
serialReceiveCallbackPtr callback,
uint32_t baudRate,
portMode_t mode,
serialInversion_e inversion)
{
serialPortUsage_t *serialPortUsage = findSerialPortUsageByIdentifier(identifier);
if (serialPortUsage->function != FUNCTION_NONE) {
// already in use
return NULL;
}
serialPort_t *serialPort = NULL;
switch(identifier) {
#ifdef USE_VCP
case SERIAL_PORT_USB_VCP:
serialPort = usbVcpOpen();
break;
#endif
#ifdef USE_USART1
case SERIAL_PORT_USART1:
serialPort = uartOpen(USART1, callback, baudRate, mode, inversion);
break;
#endif
#ifdef USE_USART2
case SERIAL_PORT_USART2:
serialPort = uartOpen(USART2, callback, baudRate, mode, inversion);
break;
#endif
#ifdef USE_USART3
case SERIAL_PORT_USART3:
serialPort = uartOpen(USART3, callback, baudRate, mode, inversion);
break;
#endif
#ifdef USE_SOFTSERIAL1
case SERIAL_PORT_SOFTSERIAL1:
serialPort = openSoftSerial(SOFTSERIAL1, callback, baudRate, inversion);
serialSetMode(serialPort, mode);
break;
#endif
#ifdef USE_SOFTSERIAL2
case SERIAL_PORT_SOFTSERIAL2:
serialPort = openSoftSerial(SOFTSERIAL2, callback, baudRate, inversion);
serialSetMode(serialPort, mode);
break;
#endif
default:
break;
}
if (!serialPort) {
return NULL;
}
serialPort->identifier = identifier;
serialPortUsage->function = function;
serialPortUsage->serialPort = serialPort;
return serialPort;
}
void HardwareSerial1::begin(uint32_t baud)
{
this->_uart = (void *)uartOpen(USART2, serialEvent1, baud, MODE_RXTX);
}
void HardwareSerial0::begin(uint32_t baud)
{
this->_uart = (void *)uartOpen(USART1, NULL, baud, MODE_RXTX);
}
/* entry point of application */
int main ( )
{
/* first thing is to enable the watchdog - so if the app crashes, the watchdog will
expire and the AS7000 will reset */
wdgEnable( ONE_SECOND );
/* count variable to see some movement on uart */
cnt = 0;
/* now we want to use the UART to report */
ccuSelectUartPins( GPIO_NONE, UART_TX_PIN );
uartInitialise( );
uartOpen( UART_BAUD_RATE_FAST );
/* send a greeting via uart */
uartTxString( "AS7000 is alive\n" );
/* we need the timers to measure the real slow clock frequency */
tmrInitialise( );
slowClockFrequency = tmrSlowClockFrequency( 10 ); /* make sure you measure for less than 1 seconds, otherwise the watchdog will expire */
/* note: the real slow clock frequency is than used by the SW for further timer calculations - or sleep mode calculations */
/* print the measured frequency */
uartTxString( "SlowClockFrequency=" );
uartTxUint( slowClockFrequency );
uartTxString( "Hz\n" );
/* e.g. configure i2c as slave to be used */
ccuSelectI2CPins( 0 /* slave */, I2C_SCL_PIN, 0 /* SCL - no internal pull-up */, I2C_SDA_PIN, 0 /* SDA - no internal pull-up */ );
i2cSlaveInitialise( );
i2cSlaveOpen( I2C_SLAVE_ADDRESS );
/* drive a led through one of the gpio pins */
ccuSelectGPIOPin( LED_PIN, 1 /* digital */, CCU_NO_PULL );
gpioInitialise();
gpioConfigure( 0 /* no input */, LED_MASK /* led is output */ );
gpioWrite( LED_MASK, LED_OFF ); /* switch off */
/* enalbe interrupts in system */
__enable_irq( );
/* show how to use the delays */
delayInMicroseconds( 0 );
delayInMicroseconds( 1 );
delayInMicroseconds( 2 );
/* put the AS7000 to sleep always for 500 milliseconds */
ccuConfigureDeepSleep( 500, 0 /* no wake-up on gpio7 */, 0 /* no wake-up on gpio8 */ );
while ( 1 )
{
wdgToggle( ); /* make sure the watchdog does not expire */
/* count up and report value on uart and blink led - to see something */
cnt++;
if ( cnt & 1 )
{
gpioWrite( LED_MASK, LED_ON );
}
else
{
gpioWrite( LED_MASK, LED_OFF );
}
uartTxUint( cnt );
uartTx( '\n' );
/* do some usefull stuff here */
/* not to be used in debugger:
ccuEnterDeepSleep( ); <---- debugger does not see the CPU anymore and stops
*/
/* use instead: */ delayInMilliseconds( 500 );
}
}
//-- main
//
int main(void)
{
uint8_t i;
drv_pwm_config_t pwm_params;
drv_adc_config_t adc_params;
serialPort_t* loopbackPort = NULL;
//-- 하드웨어 초기화
//
systemInit();
#ifdef USE_LAME_PRINTF
init_printf(NULL, _putc);
#endif
checkFirstTime(false);
readEEPROM();
// configure power ADC
if (mcfg.power_adc_channel > 0 && (mcfg.power_adc_channel == 1 || mcfg.power_adc_channel == 9))
adc_params.powerAdcChannel = mcfg.power_adc_channel;
else
{
adc_params.powerAdcChannel = 0;
mcfg.power_adc_channel = 0;
}
adcInit(&adc_params);
initBoardAlignment();
// We have these sensors; SENSORS_SET defined in board.h depending on hardware platform
sensorsSet(SENSORS_SET);
mixerInit(); // this will set core.useServo var depending on mixer type
// when using airplane/wing mixer, servo/motor outputs are remapped
if (mcfg.mixerConfiguration == MULTITYPE_AIRPLANE || mcfg.mixerConfiguration == MULTITYPE_FLYING_WING)
pwm_params.airplane = true;
else
pwm_params.airplane = false;
//pwm_params.useUART = feature(FEATURE_GPS) || feature(FEATURE_SERIALRX); // spektrum/sbus support uses UART too
pwm_params.useUART = 0;
pwm_params.useSoftSerial = feature(FEATURE_SOFTSERIAL);
pwm_params.usePPM = feature(FEATURE_PPM);
pwm_params.enableInput = !feature(FEATURE_SERIALRX); // disable inputs if using spektrum
pwm_params.useServos = core.useServo;
pwm_params.extraServos = cfg.gimbal_flags & GIMBAL_FORWARDAUX;
pwm_params.motorPwmRate = mcfg.motor_pwm_rate;
pwm_params.servoPwmRate = mcfg.servo_pwm_rate;
pwm_params.idlePulse = PULSE_1MS; // standard PWM for brushless ESC (default, overridden below)
if (feature(FEATURE_3D))
pwm_params.idlePulse = mcfg.neutral3d;
if (pwm_params.motorPwmRate > 500)
pwm_params.idlePulse = 0; // brushed motors
pwm_params.servoCenterPulse = mcfg.midrc;
pwm_params.failsafeThreshold = cfg.failsafe_detect_threshold;
switch (mcfg.power_adc_channel) {
case 1:
pwm_params.adcChannel = PWM2;
break;
case 9:
pwm_params.adcChannel = PWM8;
break;
default:
pwm_params.adcChannel = 0;
break;
}
pwmInit(&pwm_params);
// configure PWM/CPPM read function and max number of channels. spektrum or sbus below will override both of these, if enabled
for (i = 0; i < RC_CHANS; i++)
rcData[i] = 1502;
rcReadRawFunc = pwmReadRawRC;
core.numRCChannels = MAX_INPUTS;
if (feature(FEATURE_SERIALRX)) {
switch (mcfg.serialrx_type) {
case SERIALRX_SPEKTRUM1024:
case SERIALRX_SPEKTRUM2048:
spektrumInit(&rcReadRawFunc);
break;
case SERIALRX_SBUS:
sbusInit(&rcReadRawFunc);
break;
case SERIALRX_SUMD:
sumdInit(&rcReadRawFunc);
break;
#if defined(SKYROVER)
case SERIALRX_HEXAIRBOT:
hexairbotInit(&rcReadRawFunc);
break;
#endif
}
} else { // spektrum and GPS are mutually exclusive
// Optional GPS - available in both PPM and PWM input mode, in PWM input, reduces number of available channels by 2.
// gpsInit will return if FEATURE_GPS is not enabled.
// Sanity check below - protocols other than NMEA do not support baud rate autodetection
if (mcfg.gps_type > 0 && mcfg.gps_baudrate < 0)
mcfg.gps_baudrate = 0;
gpsInit(mcfg.gps_baudrate);
}
#ifdef SONAR
// sonar stuff only works with PPM
if (feature(FEATURE_PPM)) {
if (feature(FEATURE_SONAR))
Sonar_init();
}
#endif
LED1_ON;
LED0_OFF;
for (i = 0; i < 10; i++) {
LED1_TOGGLE;
LED0_TOGGLE;
delay(25);
BEEP_ON;
delay(25);
BEEP_OFF;
}
LED0_OFF;
LED1_OFF;
serialInit(mcfg.serial_baudrate);
#if _DEF_MW_PORT == PORT_UART1
core.menuport = uartOpen(USART1, NULL, mcfg.serial_baudrate, MODE_RXTX);
core.debugport = core.menuport;
#else
core.menuport = uartOpen(USART1, NULL, mcfg.serial_baudrate, MODE_RXTX);
core.debugport = core.menuport;
#endif
DEBUG_PRINT("Booting.. V140926R1\r\n");
// drop out any sensors that don't seem to work, init all the others. halt if gyro is dead.
sensorsAutodetect();
imuInit(); // Mag is initialized inside imuInit
// Check battery type/voltage
if (feature(FEATURE_VBAT))
batteryInit();
if (feature(FEATURE_SOFTSERIAL)) {
setupSoftSerial1(mcfg.softserial_baudrate, mcfg.softserial_inverted);
#ifdef SOFTSERIAL_LOOPBACK
loopbackPort = (serialPort_t*)&(softSerialPorts[0]);
serialPrint(loopbackPort, "LOOPBACK ENABLED\r\n");
#endif
}
if (feature(FEATURE_TELEMETRY))
initTelemetry();
previousTime = micros();
if (mcfg.mixerConfiguration == MULTITYPE_GIMBAL)
calibratingA = CALIBRATING_ACC_CYCLES;
calibratingG = CALIBRATING_GYRO_CYCLES;
calibratingB = CALIBRATING_BARO_CYCLES; // 10 seconds init_delay + 200 * 25 ms = 15 seconds before ground pressure settles
f.SMALL_ANGLES_25 = 1;
//-- 센서초기화 루틴때문에 USB 통신안되는것 때문에 마지막으로 순서 변경
//
Hw_VCom_Init();
DEBUG_PRINT("Start\r\n");
//-- thread 시작
//
thread_main();
while(1)
{
}
}
