int main() { int l = 1; uint8_t c[2]; X.output(); Y.output(); Z.output(); E.output(); setleds(l); if (1) { UART * s = new UART(0, 9600); s->send((uint8_t *) "Start\n", 6); for(;;) { for (int i = 0 ; ((i & (1 << 22)) == 0) && !g_LoopDummy ; i++) { } c[0] = '0' + (l & 7); c[1] = '\n'; //s->send(c, 2); setleds(l++); } } }
void ButEvent(int IntNo) { if (IntNo == 0) { if (g_bUartState == false) { g_Uart.Enable(); g_bUartState = true; } else { g_Uart.Disable(); g_bUartState = false; } } }
int main(void) { char dutyCycle; UART uart; PWM pwm; uart.init(); uart.println("*** QC-BLCD OS Startup Sequence ***"); uart.println(" > UART initialized"); pwm.init(); uart.println(" > PWM initialized"); uart.println("Startup Sequence successfull!"); uart.println("Main program starts now"); dutyCycle=0; while(42) { /*itoa(dutyCycle,msg,10); println(msg);*/ pwm.setDutyCycle(dutyCycle); dutyCycle++; _delay_ms(200); } }
void UartRxChedHandler(void * p_event_data, uint16_t event_size) { uint8_t buff[128]; int l = g_Uart.Rx(buff, 128); if (l > 0) { BleSrvcCharNotify(&g_UartBleSrvc, 0, buff, l); } }
void uart_task(void *pvParameters) { char buffer[128]; char *p; uint8_t tmp; (void)pvParameters; // Enable nCTS uart2.handle_.Instance->CR3 |= (USART_CR3_CTSE); for (unsigned int i = 0; true; i++) { snprintf(buffer, sizeof(buffer), "{\"uart_task\": %d}\n", i); for (p = buffer; *p; p++) { uart2.rx(&tmp, 0); if (uart2.tx(*p, 250) != HAL_OK) break; } vTaskDelay(350 / portTICK_RATE_MS); } }
namespace RODOS { #endif /* * nonblocking getc / getchar (from stdin) */ /****************************************************/ static UART uart0 ("uart0"); /** Returns -1 if no data, else char from getchar **/ int getcharNoWait() { char c; if (uart0.getcharNoWait(c)) return (unsigned char)c; else return -1; } bool isCharReady() { return uart0.isCharReady(); } char* getsNoWait() { static char inBuffer[122]; static int inBufferIndex = 0; while(1) { // terminated with returns int c= getcharNoWait(); if(c < 0) return 0; if(c == '\n') { // end of string -> return inBuffer[inBufferIndex] = 0; inBufferIndex = 0; return inBuffer; } inBuffer[inBufferIndex] = c; if(inBufferIndex < 120) inBufferIndex++; } } void getUARTStats(XUartLite_Stats* stats) { uart0.getStats(stats); } void clearUARTStats() { uart0.clearStats(); } #ifndef NO_RODOS_NAMESPACE }
int main() { UART uart; std::string outputString; int outData; uart.initUart(); std::string RPM="010C\r"; std::string Speed="010D\r"; uart.sendLine("ATZ\r"); sleep(5); outputString = uart.receiveLineString(); std::cout << outputString << std::endl; uart.sendLine(RPM); outData = uart.receiveLineData("010C41 0C ", 5); std::cout << outData << std::endl; }
int main(void) { HAL *hal = HAL::get_HAL(); UART *uart = hal->uart; uart->init((uint32_t)115200); const int TEST_DATA_SIZE = 3; uint8_t test_data[TEST_DATA_SIZE] = {'!', '1', ' '}; uint8_t recv_buff[TEST_DATA_SIZE] = {}; volatile bool testOk = false; while(1) { int msg_size = uart->write(test_data, TEST_DATA_SIZE); if (msg_size == TEST_DATA_SIZE) { hal->time->delay(1000); int recv_bytes = uart->read(recv_buff, TEST_DATA_SIZE); if (recv_bytes == TEST_DATA_SIZE) { int i; for(i = 0; i < TEST_DATA_SIZE; i++) { testOk = test_data[i] == recv_buff[i]; recv_buff[i] = 0; if (!testOk) break; } } } if (!testOk) {//Fail catch while(1){} } } }
void HardwareInit() { g_Uart.Init(g_UartCfg); IOPinCfg(s_LedPins, s_NbLedPins); IOPinSet(BLUEIO_LED_BLUE_PORT, BLUEIO_LED_BLUE_PIN); IOPinSet(BLUEIO_LED_GREEN_PORT, BLUEIO_LED_GREEN_PIN); IOPinSet(BLUEIO_LED_RED_PORT, BLUEIO_LED_RED_PIN); IOPinCfg(s_ButPins, s_NbButPins); IOPinEnableInterrupt(0, APP_IRQ_PRIORITY_LOW, s_ButPins[0].PortNo, s_ButPins[0].PinNo, IOPINSENSE_LOW_TRANSITION, ButEvent); }
int main() { HardwareInit(); g_Uart.printf("UART over BLE Demo\r\n"); //g_Uart.Disable(); BleAppInit((const BLEAPP_CFG *)&s_BleAppCfg, true); BleAppRun(); return 0; }
void ApplicationEntryPoint() { BOOL result; RAM RamTest ( (UINT32*)RAMTestBase, (UINT32)RAMTestSize, (ENDIAN_TYPE)ENDIANESS, BUS_WIDTH ); TimedEvents eventsTest; UART usartTest ( COMTestPort, 9600, USART_PARITY_NONE, 8, USART_STOP_BITS_ONE, USART_FLOW_NONE ); GPIO gpioTest ( GPIOTestPin ); SPI spiTest ( SPIChipSelect, SPIModule, g_EEPROM_STM95x ); Timers timersTest ( DisplayInterval, TimerDuration ); do { result = RamTest.Execute ( STREAM__OUT ); result = eventsTest.Execute( STREAM__OUT ); result = usartTest.Execute ( STREAM__OUT ); result = gpioTest.Execute ( STREAM__OUT ); result = spiTest.Execute ( STREAM__OUT ); result = timersTest.Execute( STREAM__OUT ); } while(FALSE); // run only once! while(TRUE); }
// must contain quick code only void serialCommand(char *line) { // check uart1/wlan first if (strstr(line, "+CWLAP:(0")) {// == 0 && line[8] == '0') { // some pointer dangerous magic uint8_t apNameLength = strstr(line+11, "\"") - line - 11; if (apNameLength > 19) apNameLength = 19; // TODO: trim -> will result in connection error : redo datatypes if (data.freeAPCount < 5) { memset(data.freeAPList[data.freeAPCount], 0, 19); strncpy(data.freeAPList[data.freeAPCount], line+11, apNameLength); uart0.send("free ap: %s ", data.freeAPList[data.freeAPCount]); data.freeAPCount++; } } // check uart0/user commands first if (strcmp(line, "beep") == 0) beep(); else if (strcmp(line, "shutdown") == 0) shutdown(); else if (strcmp(line, "listwlan") == 0) wifi.listAP(); }
int _write(int fd, uint8_t *buf, size_t buflen) { dbg.send((uint8_t *) buf, buflen); return buflen; }
void main_task(void *pvParameters) { (void) pvParameters; vTaskDelay(500 / portTICK_RATE_MS); SPIMaster spi5(SPI5, SPI_BAUDRATEPRESCALER_32, 0x2000, { {MEMS_SPI_SCK_PIN, GPIO_MODE_AF_PP, GPIO_PULLDOWN, GPIO_SPEED_MEDIUM, GPIO_AF5_SPI5}, {MEMS_SPI_MISO_PIN, GPIO_MODE_AF_PP, GPIO_PULLDOWN, GPIO_SPEED_MEDIUM, GPIO_AF5_SPI5}, {MEMS_SPI_MOSI_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, GPIO_SPEED_MEDIUM, GPIO_AF5_SPI5}, }, { {GYRO_CS_PIN, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_MEDIUM, 0}, {ACCEL_CS_PIN, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_MEDIUM, 0}, }); SPIMaster spi2(SPI2, SPI_BAUDRATEPRESCALER_32, 0x2000, { {EXT_MEMS_SPI_SCK_PIN, GPIO_MODE_AF_PP, GPIO_PULLDOWN, GPIO_SPEED_MEDIUM, GPIO_AF5_SPI2}, {EXT_MEMS_SPI_MISO_PIN, GPIO_MODE_AF_PP, GPIO_PULLDOWN, GPIO_SPEED_MEDIUM, GPIO_AF5_SPI2}, {EXT_MEMS_SPI_MOSI_PIN, GPIO_MODE_AF_PP, GPIO_NOPULL, GPIO_SPEED_MEDIUM, GPIO_AF5_SPI2}, }, { {EXT_GYRO_CS_PIN, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_MEDIUM, 0}, {LPS25HB_PRESSURE_CS_PIN, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_MEDIUM, 0}, {BMP280_PRESSURE_CS_PIN, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_MEDIUM, 0}, }); L3GD20 gyro(spi5, 0); LPS25HB lps25hb(spi2, 1); BMP280 bmp2(spi2, 2); LSM303D accel(spi5, 1); uint8_t gyro_wtm = 5; uint8_t acc_wtm = 8; TimeStamp console_update_time; TimeStamp sample_dt; TimeStamp led_toggle_ts; FlightControl flight_ctl; static bool print_to_console = false; LowPassFilter<Vector3f, float> gyro_lpf({0.5}); LowPassFilter<Vector3f, float> acc_lpf_alt({0.9}); LowPassFilter<Vector3f, float> acc_lpf_att({0.990}); LowPassFilter<float, float> pressure_lpf({0.6}); attitudetracker att; /* * Apply the boot configuration from flash memory. */ dronestate_boot_config(*drone_state); L3GD20Reader gyro_reader(gyro, GYRO_INT2_PIN, gyro_align); LSM303Reader acc_reader(accel, ACC_INT2_PIN, acc_align); UartRpcServer rpcserver(*drone_state, configdata, acc_reader.mag_calibrator_); bmp2.set_oversamp_pressure(BMP280_OVERSAMP_16X); bmp2.set_work_mode(BMP280_ULTRA_HIGH_RESOLUTION_MODE); bmp2.set_filter(BMP280_FILTER_COEFF_OFF); Bmp280Reader bmp_reader(bmp2); HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 1, 1); HAL_NVIC_EnableIRQ (DMA1_Stream6_IRQn); HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 1, 0); HAL_NVIC_EnableIRQ (DMA1_Stream5_IRQn); #ifndef ENABLE_UART_TASK uart2.uart_dmarx_start(); #endif printf("Priority Group: %lu\n", NVIC_GetPriorityGrouping()); printf("SysTick_IRQn priority: %lu\n", NVIC_GetPriority(SysTick_IRQn) << __NVIC_PRIO_BITS); printf("configKERNEL_INTERRUPT_PRIORITY: %d\n", configKERNEL_INTERRUPT_PRIORITY); printf("configMAX_SYSCALL_INTERRUPT_PRIORITY: %d\n", configMAX_SYSCALL_INTERRUPT_PRIORITY); printf("LPS25HB Device id: %d\n", lps25hb.Get_DeviceID()); vTaskDelay(500 / portTICK_RATE_MS); gyro_reader.init(gyro_wtm); gyro_reader.enable_int2(false); vTaskDelay(500 / portTICK_RATE_MS); acc_reader.init(acc_wtm); acc_reader.enable_int2(false); acc_reader.mag_calibrator_.set_bias(drone_state->mag_bias_); acc_reader.mag_calibrator_.set_scale_factor(drone_state->mag_scale_factor_); vTaskDelay(500 / portTICK_RATE_MS); printf("Calibrating..."); gyro_reader.enable_int2(true); gyro_reader.calculate_static_bias_filtered(2400); printf(" Done!\n"); flight_ctl.start_receiver(); printf("Entering main loop...\n"); gyro_reader.enable_int2(true); sample_dt.time_stamp(); lps25hb.Set_FifoMode(LPS25HB_FIFO_STREAM_MODE); lps25hb.Set_FifoModeUse(LPS25HB_ENABLE); lps25hb.Set_Odr(LPS25HB_ODR_25HZ); lps25hb.Set_Bdu(LPS25HB_BDU_NO_UPDATE); LPS25HB_FIFOTypeDef_st fifo_config; memset(&fifo_config, 0, sizeof(fifo_config)); lps25hb.Get_FifoConfig(&fifo_config); #ifdef USE_LPS25HB float base_pressure = lps25hb.Get_PressureHpa(); for (int i = 0; i < 100; i++) { while (lps25hb.Get_FifoStatus().FIFO_EMPTY) vTaskDelay(50 / portTICK_RATE_MS); base_pressure = pressure_lpf.do_filter(lps25hb.Get_PressureHpa()); } #endif bmp_reader.calibrate(); // Infinite loop PerfCounter idle_time; while (1) { drone_state->iteration_++; if (drone_state->iteration_ % 120 == 0) { led1.toggle(); } if (drone_state->iteration_ % 4 == 0) { #ifdef USE_LPS25HB drone_state->temperature_ = lps25hb.Get_TemperatureCelsius(); while (!lps25hb.Get_FifoStatus().FIFO_EMPTY) { drone_state->pressure_hpa_ = pressure_lpf.do_filter(lps25hb.Get_PressureHpa()); float alt = (powf(base_pressure/drone_state->pressure_hpa_, 0.1902f) - 1.0f) * ((lps25hb.Get_TemperatureCelsius()) + 273.15f)/0.0065; drone_state->altitude_ = Distance::from_meters(alt); } #else bmp_reader.pressure_filter_.set_alpha(drone_state->altitude_lpf_); drone_state->altitude_ = bmp_reader.get_altitude(true); drone_state->pressure_hpa_ = bmp_reader.get_pressure().hpa(); drone_state->temperature_ = bmp_reader.get_temperature(false).celsius(); #endif } idle_time.begin_measure(); gyro_reader.wait_for_data(); idle_time.end_measure(); drone_state->dt_ = sample_dt.elapsed(); sample_dt.time_stamp(); if (drone_state->base_throttle_ > 0.1) att.accelerometer_correction_speed(drone_state->accelerometer_correction_speed_); else att.accelerometer_correction_speed(3.0f); att.gyro_drift_pid(drone_state->gyro_drift_kp_, drone_state->gyro_drift_ki_, drone_state->gyro_drift_kd_); att.gyro_drift_leak_rate(drone_state->gyro_drift_leak_rate_); size_t fifosize = gyro_reader.size(); for (size_t i = 0; i < fifosize; i++) drone_state->gyro_raw_ = gyro_lpf.do_filter(gyro_reader.read_sample()); if (drone_state->gyro_raw_.length_squared() > 0 && drone_state->dt_.microseconds() > 0) { drone_state->gyro_ = (drone_state->gyro_raw_ - gyro_reader.bias()) * drone_state->gyro_factor_; att.track_gyroscope(DEG2RAD(drone_state->gyro_) * 1.0f, drone_state->dt_.seconds_float()); } fifosize = acc_reader.size(); for (size_t i = 0; i < fifosize; i++) { Vector3f acc_sample = acc_reader.read_sample_acc(); acc_lpf_att.do_filter(acc_sample); acc_lpf_alt.do_filter(acc_sample); } drone_state->accel_raw_ = acc_lpf_att.output(); drone_state->accel_alt_ = acc_lpf_alt.output(); drone_state->accel_ = (drone_state->accel_raw_ - drone_state->accelerometer_adjustment_).normalize(); #define ALLOW_ACCELEROMETER_OFF #ifdef ALLOW_ACCELEROMETER_OFF if (drone_state->track_accelerometer_) { att.track_accelerometer(drone_state->accel_, drone_state->dt_.seconds_float()); } #else att.track_accelerometer(drone_state->accel_, drone_state->dt_.seconds_float()); #endif #define REALTIME_DATA 0 #if REALTIME_DATA std::cout << drone_state->gyro_.transpose() << drone_state->accel_.transpose() << drone_state->pid_torque_.transpose(); std::cout << drone_state->dt_.seconds_float() << std::endl; #endif drone_state->mag_raw_ = acc_reader.read_sample_mag(); drone_state->mag_ = drone_state->mag_raw_.normalize(); if (drone_state->track_magnetometer_) { att.track_magnetometer(drone_state->mag_, drone_state->dt_.seconds_float()); } drone_state->attitude_ = att.get_attitude(); drone_state->gyro_drift_error_ = RAD2DEG(att.get_drift_error()); flight_ctl.update_state(*drone_state); flight_ctl.send_throttle_to_motors(); if (print_to_console && console_update_time.elapsed() > TimeSpan::from_milliseconds(300)) { Vector3f drift_err = att.get_drift_error(); console_update_time.time_stamp(); printf("Gyro : %5.3f %5.3f %5.3f\n", drone_state->gyro_.at(0), drone_state->gyro_.at(1), drone_state->gyro_.at(2)); printf("Drift Err : %5.3f %5.3f %5.3f\n", RAD2DEG(drift_err.at(0)), RAD2DEG(drift_err.at(1)), RAD2DEG(drift_err.at(2))); printf("Gyro Raw : %5.3f %5.3f %5.3f\n", drone_state->gyro_raw_.at(0), drone_state->gyro_raw_.at(1), drone_state->gyro_raw_.at(2)); printf("Accel : %5.3f %5.3f %5.3f\n", drone_state->accel_.at(0), drone_state->accel_.at(1), drone_state->accel_.at(2)); printf("Mag : %5.3f %5.3f %5.3f\n", drone_state->mag_.at(0), drone_state->mag_.at(1), drone_state->mag_.at(2)); printf("dT : %lu uSec\n", (uint32_t)drone_state->dt_.microseconds()); printf("Q : %5.3f %5.3f %5.3f %5.3f\n\n", drone_state->attitude_.w, drone_state->attitude_.x, drone_state->attitude_.y, drone_state->attitude_.z); #if 1 printf("Motors : %1.2f %1.2f %1.2f %1.2f\n", drone_state->motors_[0], drone_state->motors_[1], drone_state->motors_[2], drone_state->motors_[3]); printf("Throttle : %1.2f\n", drone_state->base_throttle_); printf("Armed : %d\n", drone_state->motors_armed_); printf("Altitude : %4.2f m\n", drone_state->altitude_.meters()); printf("GPS : Lon: %3.4f Lat: %3.4f Sat %lu Alt: %4.2f m\n", drone_state->longitude_.degrees(), drone_state->latitude_.degrees(), drone_state->satellite_count_, drone_state->gps_altitude_.meters()); printf("Battery : %2.1f V, %2.0f%%\n", drone_state->battery_voltage_.volts(), drone_state->battery_percentage_); #endif } #if 0 if (led_toggle_ts.elapsed() > TimeSpan::from_seconds(1)) { led_toggle_ts.time_stamp(); led0.toggle(); } #endif #ifndef ENABLE_UART_TASK rpcserver.jsonrpc_request_handler(&uart2); #endif } }
int main() { bool res; #ifdef DEMO_C res = UARTInit(&g_UartDev, &g_UartCfg); #else res = g_Uart.Init(g_UartCfg); #endif uint8_t d = 0xff; uint8_t val = 0; uint32_t errcnt = 0; uint32_t cnt = 0; auto t_start = std::chrono::high_resolution_clock::now(); auto t_end = std::chrono::high_resolution_clock::now(); std::chrono::duration<float> elapse = std::chrono::duration<float>(0); t_start = std::chrono::high_resolution_clock::now(); time_t t; double e = 0.0; bool isOK = false; // do { #ifdef DEMO_C while (UARTRx(&g_UartDev, &d, 1) <= 0); #else while (g_Uart.Rx(&d, 1) <= 0); #endif if (val == d) isOK = true; val = Prbs8(d); // } while (!isOK); while(1) { // t_start = std::chrono::high_resolution_clock::now(); t = time(NULL); #ifdef DEMO_C while (UARTRx(&g_UartDev, &d, 1) <= 0); #else while (g_Uart.Rx(&d, 1) <= 0); #endif { e += difftime(time(NULL), t); // t_end = std::chrono::high_resolution_clock::now(); //elapse += std::chrono::duration<float>(t_end-t_start); cnt++; // If success send next code // printf("%x ", d); if (val != d) { errcnt++; // printf("PRBS %u errors %x %x\n", errcnt, val, d); } else if ((cnt & 0x7fff) == 0) { printf("PRBS rate %.3f B/s, err : %u\n", cnt / e, errcnt); // printf("PRBS rate %.3f B/s, err : %u\n", cnt / elapse.count(), errcnt); } val = Prbs8(d); } } return 0; }
void clearUARTStats() { uart0.clearStats(); }
void getUARTStats(XUartLite_Stats* stats) { uart0.getStats(stats); }
bool isCharReady() { return uart0.isCharReady(); }
/** Returns -1 if no data, else char from getchar **/ int getcharNoWait() { char c; if (uart0.getcharNoWait(c)) return (unsigned char)c; else return -1; }
// main entry point, go ahead, have fun! int main(void) { // hold the power button for 3 seconds or shutdown //_delay_ms(STARTUP_DELAY); // keep power pin High unless we want to shutdown powerControl = 1; // disable JTAG so we can use PF4,PF5,PF6,PF7 for ADC and GPIO MCUCSR |=(1<<JTD);MCUCSR |=(1<<JTD); // two times!! // init time RTC time.init(callback_timeSecond, callback_timeMinute); time.startInterval(); // microcontroller features adc.init(); // needed by gp2y10 and more spi_init(); // needed by ILI9341 i2c_init(); // needed by bmp180 and mics-vz-89t uart1.init(1, 9600, 1); // needed by esp8266 . Interrupts are hard on parsing, polling would be easier but blocking uart0.init(0, 9600, 1); // CONFIGURE INTERRUPT INT4 to count pulses from Geiger Counter EICRB |= (1<<ISC00) | (1<<ISC01); // Configure INT4 to trigger on RISING EDGE EIMSK |= (1<<INT4); // Configure INT4 to fire interrupts // CREATE Timer T1 PWM to drive inverter for regulated Geiger tube voltage inverter.initPWM(); // init display lcd.init(); lcd.setRotation(ILI9341::ROT0); //lcd.drawClear(BLACK); backlight(true); // init sensors bmp180.init(); dust.init(&dustFlash, &adc, PF1); beep(); // start UI // enter main menu // ## touchscreen calibration code /*while (1) { uint16_t x = 0, y = 0, z = 0; if (touch.read(&x, &y , &z)) { lcd.drawPixel(x,y, 2, RED); } lcd.drawStringF(0,0,2,WHITE, BLACK, "%4u %4u %4u", touch.readRawX(), touch.readRawY(), touch.readRawPressure()); }*/ // draw GUI first page with self check if (!gui.drawPage(PAGE_INIT)) shutdown(); _delay_ms(1000); gui.drawPage(PAGE_MAIN); // ## main code loop while (1) { // ## beep if (cmdBeep && !cmdAlarm && !isMuted) { beep(); cmdBeep = false; } // ## read sensors // read inverter voltage, via 10M/47K resistive divider, connected to pin ADC2 data.geiger_voltage = readTubeVoltage(); inverter.adjustDutyCycle(data.geiger_voltage); // do nothing on failure, we can't reset // read battery data.battery_voltage = readBatVoltage(); // turn backlight off when timeout is reached if (secTimeout > BACKLIGHT_TIMEOUT) { backlight(false); secTimeout = 0; } // ## draw titlebar and refresh data display if (cmdRefreshText) { // sensor BMP180 bmp180.readAll(&data.bmp180_temp, &data.bmp180_pressure, &data.bmp180_altitude); dust.readDust(&data.gp2y10_dust); // sensor MICS-VZ-89T uint8_t reactivity = 0; // repeat until successful read with timeout? //int timeout = 10; //while (!vz89.read(&data.vz89_co2, &reactivity, &data.vz89_voc) && timeout) { _delay_ms(1500); timeout--; } vz89.read(&data.vz89_co2, &reactivity, &data.vz89_voc); // geiger readings //float dose = aux_CPM2uSVh((uint8_t)DEV_RAD_DETECTOR, geigerCPM); data.geiger_cpm = geigerCPM; data.time_hour = time.getHour(); data.time_minute = time.getMin(); data.time_second = time.getSec(); data.setLimits(); // must be changed to proper OOP set/get for all fields gui.updateValues(); // ## alarm condition if (geigerCPM >= GEIGER_CPM_ALARM) { // threshold to sound alarm reached cmdAlarm = ALARM_RADIATION; } else if (cmdAlarm) { // alarm should be turned off cmdAlarm = 0; speaker = 0; } cmdRefreshText = false; } // ## every minute we can dispatch data over serial or over WLAN to uradmonitor if (cmdSend) { char tmp[200]; sprintf(tmp,"{\"data\":{ \"id\":\"%08lX\"," "\"type\":\"%X\",\"detector\":\"%s\"," "\"cpm\":%lu,\"temperature\":%.2f,\"uptime\": %lu," "\"pressure\":%lu,\"dust\":%.2f,\"co2\":%.2f,\"voc\":%.2f," "\"battery\":%.2f,\"tube\":%u}}", deviceID, DEV_MODEL, aux_detectorName(DEV_RAD_DETECTOR), geigerCPM, data.bmp180_temp, time.getTotalSec(), data.bmp180_pressure, data.gp2y10_dust,data.vz89_co2, data.vz89_voc, data.battery_voltage, data.geiger_voltage); data.serial_sent += strlen(tmp); uart0.send(tmp); // internet code here sprintf(tmp,"id=%08lX&ts=%ld&inv=%d&ind=%d&s1t=%2.2f&cpm=%ld&voc=%.2f&co2=%.2f", deviceID, time.getTotalSec(), data.geiger_voltage, data.geiger_duty, data.bmp180_temp, geigerCPM, data.vz89_voc, data.vz89_co2); wifi.sendData(tmp); cmdSend = false; } // ## act on the gui elements // read a new touch event only if we are done with previous: useful for handling confirmation "modal" "dialogs" if (uiResult == 0) { uiResult = gui.readTouchEvent(); // reset backlight timeout on valid touch if (uiResult > 0) { secTimeout = 0; backlight(true); // if screen is pressed while alarm is on, stop alarm if (cmdAlarm) { cmdAlarm = false; speaker = 0; } } } // handle special cases: click on wlan AP buttons if (uiResult >= ID_BUTTON_WLAN_START && uiResult < ID_BUTTON_WLAN_STOP) { uint8_t ap_index = uiResult - ID_BUTTON_WLAN_START; // connect and return to main screen wifi.connectWiFi(data.freeAPList[ap_index], ""); uiResult = 0; gui.drawPage(PAGE_MAIN); } // handle regular buttons switch (uiResult) { case ID_BUTTON_SHUTDOWN: { uint16_t result = gui.showYesNoPopup("Are you sure?"); if (result == ID_YES) shutdown(); else if (result == ID_NO) { uiResult = 0; gui.drawPage(PAGE_MAIN); } } break; case ID_BUTTON_MEASURE: { uiResult = 0; gui.drawPage(PAGE_MEASURE); } break; case ID_BUTTON_MONITOR: { uiResult = 0; gui.drawPage(PAGE_MONITOR); } break; case ID_BUTTON_SETTINGS: { uiResult = 0; gui.drawPage(PAGE_SETTINGS); } break; case ID_BUTTON_BACK: { uiResult = 0; gui.drawPage(PAGE_MAIN); } break; case ID_BUTTON_MUTE: { isMuted = !isMuted; if (!isMuted) beep(); // test beep that sound is on uiResult = 0; } break; case ID_BUTTON_CALIBRATE: { uiResult = 0; gui.drawPage(PAGE_CALIBRATE); } break; case ID_BUTTON_WLAN: { // request list of WLAN APs data.freeAPCount = 0; //wifi.setMode(); wifi.listAP(); uiResult = 0; gui.drawPage(PAGE_WLAN); } break; // other commands that don't require a popup so we consume asap default: uiResult = 0; } //uint16_t x, y,z; //gui.getLastTouch(&x, &y, &z); //lcd.drawStringF(0,288, 2, RED, BLACK,"%u %d,%d ", uiResult, x,y); } }
void query() { //////////////////////////////////////////////// extern int curSpeed; extern int curRPM; extern int initFuel, prevFuel, curFuel; extern int initDist, curDist; extern int curTemp; extern int leftDist, rightDist; //Time Globals extern time_t rawTime; extern struct tm *prevTime, *curTime; extern int timeOffset; extern bool forwardMode; //////////////////////////////////////////////// int temp, count=0; UART uart; myI2C *sensorPtr0 = new myI2C(); myI2C *sensorPtr1 = new myI2C(); std::string RPM="010C\r"; std::string Speed="010D\r"; std::string Temperature="0105\r"; std::string Fuel="012F\r"; std::string Dist="0131\r"; // sensorPtr0->i2cSetAddress(DEVICE_ADDR0); // sensorPtr1->i2cSetAddress(DEVICE_ADDR1); uart.initUart(); uart.sendLine("ATZ\r"); int fd = open( "/sys/class/gpio/gpio67/value", O_RDONLY | O_NONBLOCK ); GIOChannel* channel = g_io_channel_unix_new( fd ); GIOCondition cond = GIOCondition( G_IO_PRI ); guint id = g_io_add_watch( channel, cond, onButtonEvent, 0 ); usleep(5000000); //Get initial Distance //====================================== uart.sendLine(Dist); temp=-1; while(temp==-1) { if ((temp=uart.receiveLineData("013141 31 ",5))!=-1) { initDist=temp; curDist=initDist; } usleep(500000); } //====================================== //Get initial time //====================================== time(&rawTime); prevTime=localtime(&rawTime); prevTime->tm_hour+=timeOffset; curTime=localtime(&rawTime); curTime->tm_hour+=timeOffset; if(prevTime->tm_hour<0) { prevTime->tm_hour+=24; curTime->tm_hour+=24; } //====================================== //Get initial fuel level //====================================== uart.sendLine(Fuel); temp=-1; while(temp==-1) { if ((temp=uart.receiveLineData("012F41 2F ",2))!=-1) { initFuel=temp; prevFuel=initFuel; curFuel=initFuel; } usleep(500000); } //====================================== //Query for Engine Temp //====================================== uart.sendLine(Temperature); temp=-1; while(temp==-1) { if ((temp=uart.receiveLineData("010541 05 ",2))!=-1) { curTemp=temp; } usleep(500000); } //====================================== while(1) { //Forward Mode //====================================== if(forwardMode) { //Query for Speed //====================================== uart.sendLine(Speed); if ((temp=uart.receiveLineData("010D41 0D ",2))!=-1) { curSpeed=temp; } //====================================== usleep(500000); //Query for RPM //====================================== uart.sendLine(RPM); if ((temp=uart.receiveLineData("010C41 0C ",5))!=-1) { curRPM=temp; } //====================================== //Get the time //====================================== time(&rawTime); curTime=localtime(&rawTime); curTime->tm_hour+=timeOffset; if(curTime->tm_hour < 0) { curTime->tm_hour+=24; } //====================================== usleep(500000); //if it's been a minute, check fuel level and engine Temp //====================================== if(count>99) { count=0; prevTime=localtime(&rawTime); prevTime->tm_hour+=timeOffset; if(prevTime->tm_hour < 0) { prevTime->tm_hour+=24; } uart.sendLine(Fuel); if ((temp=uart.receiveLineData("012F41 2F ",2))!=-1) { curFuel=temp; } usleep(500000); //Query for Engine Temp //====================================== if ((temp=uart.receiveLineData("010541 05 ",2))!=-1) { curTemp=temp; } //====================================== usleep(500000); } //====================================== //if the fuel level has changed, //check distance //====================================== if(prevFuel!=curFuel) { prevFuel=curFuel; uart.sendLine(Dist); if ((temp=uart.receiveLineData("013141 31 ",4))!=-1) { curDist=temp; } usleep(500000); } //if the speed is greater than 30MPH or 49 KPH //check rear distance //====================================== if(curSpeed > 49) { /*sensorPtr0->Send_I2C_Byte(0x00, 0x51); usleep(68E3); leftDist=sensorPtr0->Read_2I2C_Bytes(0x02); sensorPtr1->Send_I2C_Byte(0x00, 0x51); usleep(68E3); rightDist=sensorPtr1->Read_2I2C_Bytes(0x02);*/ } //====================================== count++; } //====================================== //Reverse Mode //====================================== else { usleep(1000000); //Query reverse distance as much as possible //====================================== /*sensorPtr0->Send_I2C_Byte(0x00, 0x51); usleep(68E3); leftDist=sensorPtr0->Read_2I2C_Bytes(0x02); sensorPtr1->Send_I2C_Byte(0x00, 0x51); usleep(68E3); rightDist=sensorPtr1->Read_2I2C_Bytes(0x02);*/ //====================================== } } }
void printk(const char* message_) { // boring and not flexible but mandatory =/ UART com; VGA v; v.put(message_, COLOR_WHITE); com.send(message_); }
void UartTxSrvcCallback(BLESRVC *pBlueIOSvc, uint8_t *pData, int Offset, int Len) { g_Uart.Tx(pData, Len); }
int main() { g_Uart.Init(s_UartCfg); // Retarget printf to UART UARTRetargetEnable(g_Uart, STDOUT_FILENO); UARTRetargetEnable(g_Uart, STDIN_FILENO); printf("Flash Memory Demo\r\n"); getchar(); g_Spi.Init(s_SpiCfg); IOPinConfig(FLASH_HOLD_PORT, FLASH_HOLD_PIN, FLASH_HOLD_PINOP, IOPINDIR_OUTPUT, IOPINRES_PULLUP, IOPINTYPE_NORMAL); g_FlashDiskIO.Init(s_FlashDiskCfg, &g_Spi, &g_FlashCache, 1); uint8_t buff[512]; uint8_t tmp[512]; uint16_t *p = (uint16_t*)buff; memset(tmp, 0, 512); for (int i = 0; i < 256; i++) { p[i] = i; } printf("Erasing... Please wait\r\n"); // Ease could take a few minutes g_FlashDiskIO.Erase(); printf("Writing 2KB data...\r\n"); g_FlashDiskIO.SectWrite(0, buff); g_FlashDiskIO.SectWrite(2, buff); g_FlashDiskIO.SectWrite(4, buff); g_FlashDiskIO.SectWrite(8, buff); printf("Validate readback...\r\n"); g_FlashDiskIO.SectRead(0, tmp); if (memcmp(buff, tmp, 512) != 0) { printf("Sector 0 verify failed\r\n"); } else { printf("Sector 0 verify success\r\n"); } memset(tmp, 0, 512); g_FlashDiskIO.SectRead(2, tmp); if (memcmp(buff, tmp, 512) != 0) { printf("Sector 2 verify failed\r\n"); } else { printf("Sector 2 verify success\r\n"); } memset(tmp, 0, 512); g_FlashDiskIO.SectRead(4, tmp); if (memcmp(buff, tmp, 512) != 0) { printf("Sector 4 verify failed\r\n"); } else { printf("Sector 4 verify success\r\n"); } memset(tmp, 0, 512); g_FlashDiskIO.SectRead(8, tmp); if (memcmp(buff, tmp, 512) != 0) { printf("Sector 8 verify failed\r\n"); } else { printf("Sector 8 verify success\r\n"); } }
int main() { bool res; char *data = "nRF UART Hello World\r\n"; uint8_t buff[20]; /* nrf_gpio_cfg_output(9); while (1) { nrf_gpio_pin_toggle(9); usDelay(1000); }*/ //NRF_MPU->PERR0 &= ~(1 << 2); //uart_init(); //simple_uart_config(UART_RTS_PIN, UART_TX_PIN, UART_CTS_PIN, UART_RX_PIN, false); #ifdef C_CODE res = UARTInit(&g_UartDev, &g_UartCfg); UARTprintf(&g_UartDev, data); #else res = g_Uart.Init(g_UartCfg); g_Uart.printf(data);dfg #endif // nrf_drv_gpiote_in_config_t cts_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false); // nrf_drv_gpiote_in_init(p_comm_params->cts_pin_no, &cts_config, gpiote_uart_event_handler); //for (int i = 0; i < 20; i++) // simple_uart_put(data[i]); //simple_uart_putstring((const uint8_t*)data); while(1) { uint8_t d; //usDelay(1000); //d = simple_uart_get(); //simple_uart_put(d); #ifndef TEST_INTERRUPT if (UARTRx(&g_UartDev, &d, 1) > 0) { UARTTx(&g_UartDev, &d, 1); // UARTTx(&g_UartDev, (uint8_t*)data, 22); //usDelay(1000); } #else int cnt = UARTRx(&g_UartDev, buff, 20); if (cnt > 0) { uint8_t *p = buff; while (cnt > 0) { int l = UARTTx(&g_UartDev, p, cnt); cnt -= l; p += l; } // UARTTx(&g_UartDev, (uint8_t*)data, 22); //usDelay(1000); } #endif //__WFI(); } return 0; }