status_t arch_debug_console_init(kernel_args *args) { // only use the port if we could find one, else use the standard port if (args != NULL && args->platform_args.serial_base_ports[0] != 0) sSerialBasePort = args->platform_args.serial_base_ports[0]; init_serial_port(sSerialBasePort, kSerialBaudRate); return B_OK; }
//*FUNCTION DEFINITIONS bool initSerial( unsigned int & serialPort, char * serialAddr ) { #ifdef ENABLE_SERIAL //initialize serial port serialPort = open_port(serialAddr); if (init_serial_port(serialPort) == SERIAL_ERROR) return false; else return true; #endif }
event_producer_elotouch::event_producer_elotouch(std::string devname) : just_untouched(false), raw_mode_(false) { calib_b=-3670; calib_a=1.0/(400-3670); calib_d=-500; calib_c=1.0/(3540-500); fd = open(devname.c_str(),O_RDWR | O_NOCTTY | O_NDELAY); if(fd <0) ERROR("Couldnt open elotouch Device " << devname); init_serial_port(fd); init_elotouch(fd,false); }
status_t arch_debug_console_init_settings(kernel_args *args) { uint32 baudRate = kSerialBaudRate; uint16 basePort = sSerialBasePort; void *handle; // get debug settings handle = load_driver_settings("kernel"); if (handle != NULL) { const char *value = get_driver_parameter(handle, "serial_debug_port", NULL, NULL); if (value != NULL) { int32 number = strtol(value, NULL, 0); if (number >= MAX_SERIAL_PORTS) { // use as port number directly basePort = number; } else if (number >= 0) { // use as index into port array if (args->platform_args.serial_base_ports[number] != 0) basePort = args->platform_args.serial_base_ports[number]; } else { // ignore value and use default } } value = get_driver_parameter(handle, "serial_debug_speed", NULL, NULL); if (value != NULL) { int32 number = strtol(value, NULL, 0); switch (number) { case 9600: case 19200: case 38400: case 57600: case 115200: //case 230400: baudRate = number; } } unload_driver_settings(handle); } if (sSerialBasePort == basePort && baudRate == kSerialBaudRate) return B_OK; init_serial_port(sSerialBasePort, kSerialBaudRate); return B_OK; }
int main(int argc, char **argv) { char *path; char chtosend='\n'; int fd; //file descriptor signal(SIGINT, terminate); if (argc > 1) { path = argv[1]; } else { printf("\nAddress of serial device required as argument.\n"); return 1; } printf("Opening serial port...\n"); fd = open_port(path); printf("Initializing serial port...\n"); if(init_serial_port(fd)) { printf("Initialization failed!\n"); return 1; } printf("Initialized!\n"); printf("Press escape to quit.\n"); printf("Press ENTER when ready:\n"); chtosend = getch(); //pause until ready printf("Ready!\n"); //echoPrint(fd); //read the buffer while(chtosend != 0x1B) //while not escape read and send data { chtosend = getch(); printf("0x%x \t %c\n", chtosend,chtosend); write(fd, (char*) &chtosend, sizeof(chtosend)); //echoPrint(fd); } printf("\nExiting..\n"); close(fd); return 0; }
int __declspec(dllexport) serial(struct unit *unit) { int iobase; int irq; char devname[8]; iobase = get_unit_iobase(unit); irq = get_unit_irq(unit); if (iobase < 0) iobase = serial_default_iobase[next_serial_portno - 1]; if (irq < 0) irq = serial_default_irq[next_serial_portno - 1]; sprintf(devname, "com%d", next_serial_portno++); init_serial_port(devname, iobase, irq, unit); return 0; }
int main(int argc, char** argv) { const char* portname = "/dev/ttyS0"; int c; while ((c = getopt(argc, argv, "p:?")) != -1) switch (c) { case 'p': portname = optarg; break; case '?': exit_usage(); default: abort(); } if (optind < argc) exit_usage(); setlocale(LC_ALL, ""); init_screen(); int portfd = open(portname, O_RDWR | O_NOCTTY | O_NONBLOCK); if (portfd < 0) exit_error(portname, errno); init_serial_port(portfd, portname); int flags = fcntl(portfd, F_GETFL, 0); if (flags < 0 || fcntl(portfd, F_SETFL, flags & ~O_NONBLOCK) < 0) exit_error(portname, errno); wprintw(win_header, "Using serial port %s.\nPress CTRL-D to quit.", portname); waddch(win_prompt, '>'); wnoutrefresh(win_header); wnoutrefresh(win_prompt); wnoutrefresh(win_input); doupdate(); input_loop(portfd); while (close(portfd) < 0) if (errno != EINTR) exit_error(portname, errno); destroy_screen(); return 0; }
//---------------------------------------------------- void get_compass_data_full(unsigned char *buffer_in) { int ttys_descriptor; int bytes_arrived = 0; while(1) { ttys_descriptor = init_serial_port(); write_cmd(ttys_descriptor,0x23); sleep(1); bytes_arrived = rs232_buffer_in_lenght(ttys_descriptor); if (bytes_arrived != ANSWER_CMD_FULL_LENGHT) { printf("ERROR: Re-send command (FULL) to serial port, bytes arrived:%d\n",bytes_arrived); rs232_close(ttys_descriptor); continue; } break; } rs232_get(ttys_descriptor,buffer_in, ANSWER_CMD_FULL_LENGHT); rs232_close(ttys_descriptor); }
/* * Our main */ int main(void) { /* Check if the firmware asked to start the bootloader */ if (bootloader_start_var == 0xBEEF) { wdt_disable(); start_bootloader(); } /* Pull PC3 low to enable boot loader */ PORTC_DIRCLR = PIN3_bm; // PC3 input PORTC.PIN3CTRL = PORT_OPC_PULLUP_gc; // Pullup PC3 _delay_ms(10); // Small delay if((PORTC_IN & PIN3_bm) == 0) // Check PC3 { start_bootloader(); } /* Normal boot */ switch_to_32MHz_clock(); // Switch to 32MHz _delay_ms(1000); // Wait for power to settle init_serial_port(); // Initialize serial port init_dac(); // Init DAC init_adc(); // Init ADC init_ios(); // Init IOs init_calibration(); // Init calibration enable_interrupts(); // Enable interrupts init_usb(); // Init USB comms functional_test(); // Functional test if started for the first time uint8_t current_fw_mode = MODE_IDLE; while(1) { if (current_fw_mode == MODE_CAP_MES) { // If we are in cap measurement mode and have a report to send if(cap_measurement_loop(&cap_report) == TRUE) { maindprintf_P(PSTR("*")); usb_packet.length = sizeof(cap_report); usb_packet.command_id = CMD_CAP_MES_REPORT; memcpy((void*)usb_packet.payload, (void*)&cap_report, sizeof(cap_report)); usb_send_data((uint8_t*)&usb_packet); } } // USB command parser if (usb_receive_data((uint8_t*)&usb_packet) == TRUE) { switch(usb_packet.command_id) { case CMD_BOOTLOADER_START: { maindprintf_P(PSTR("USB- Bootloader start")); bootloader_start_var = 0xBEEF; wdt_enable(WDTO_1S); while(1); } case CMD_PING: { maindprintf_P(PSTR(".")); // Ping packet, resend the same one usb_send_data((uint8_t*)&usb_packet); break; } case CMD_VERSION: { maindprintf_P(PSTR("USB- Version\r\n")); // Version request packet strcpy((char*)usb_packet.payload, CAPMETER_VER); usb_packet.length = sizeof(CAPMETER_VER); usb_send_data((uint8_t*)&usb_packet); break; } case CMD_OE_CALIB_STATE: { maindprintf_P(PSTR("USB- Calib state\r\n")); // Get open ended calibration state. if (is_platform_calibrated() == TRUE) { // Calibrated, return calibration data usb_packet.length = get_openended_calibration_data(usb_packet.payload); } else { // Not calibrated, return 0 usb_packet.length = 1; usb_packet.payload[0] = 0; } usb_send_data((uint8_t*)&usb_packet); break; } case CMD_OE_CALIB_START: { maindprintf_P(PSTR("USB- Calib start\r\n")); // Check if we are in idle mode if (current_fw_mode == MODE_IDLE) { // Calibration start start_openended_calibration(usb_packet.payload[0], usb_packet.payload[1], usb_packet.payload[2]); usb_packet.length = get_openended_calibration_data(usb_packet.payload); } else { usb_packet.length = 1; usb_packet.payload[0] = USB_RETURN_ERROR; } usb_send_data((uint8_t*)&usb_packet); break; } case CMD_GET_OE_CALIB: { maindprintf_P(PSTR("USB- Calib data\r\n")); // Get calibration data usb_packet.length = get_openended_calibration_data(usb_packet.payload); usb_send_data((uint8_t*)&usb_packet); break; } case CMD_SET_VBIAS: { // Check that we are not measuring anything and if so, skip samples and stop oscillation if (current_fw_mode == MODE_CAP_MES) { pause_capacitance_measurement_mode(); } // Enable and set vbias... can also be called to update it uint16_t* temp_vbias = (uint16_t*)usb_packet.payload; uint16_t set_vbias = enable_bias_voltage(*temp_vbias); uint16_t cur_dacv = get_current_vbias_dac_value(); usb_packet.length = 4; memcpy((void*)usb_packet.payload, (void*)&set_vbias, sizeof(set_vbias)); memcpy((void*)&usb_packet.payload[2], (void*)&cur_dacv, sizeof(cur_dacv)); usb_send_data((uint8_t*)&usb_packet); // If we are measuring anything, resume measurements if (current_fw_mode == MODE_CAP_MES) { resume_capacitance_measurement_mode(); } break; } case CMD_DISABLE_VBIAS: { // Disable vbias usb_packet.length = 0; disable_bias_voltage(); usb_send_data((uint8_t*)&usb_packet); break; } case CMD_CUR_MES_MODE: { // Enable current measurement or start another measurement if (current_fw_mode == MODE_IDLE) { set_current_measurement_mode(usb_packet.payload[0]); current_fw_mode = MODE_CURRENT_MES; } // Check if we are in the right mode to start a measurement if (current_fw_mode == MODE_CURRENT_MES) { // We either just set current measurement mode or another measurement was requested if (get_configured_adc_ampl() != usb_packet.payload[0]) { // If the amplification isn't the same one as requested set_current_measurement_mode(usb_packet.payload[0]); } // Start measurement usb_packet.length = 2; uint16_t return_value = cur_measurement_loop(usb_packet.payload[1]); memcpy((void*)usb_packet.payload, (void*)&return_value, sizeof(return_value)); usb_send_data((uint8_t*)&usb_packet); } else { usb_packet.length = 1; usb_packet.payload[0] = USB_RETURN_ERROR; usb_send_data((uint8_t*)&usb_packet); } break; } case CMD_CUR_MES_MODE_EXIT: { if (current_fw_mode == MODE_CURRENT_MES) { usb_packet.payload[0] = USB_RETURN_OK; disable_current_measurement_mode(); current_fw_mode = MODE_IDLE; } else { usb_packet.payload[0] = USB_RETURN_ERROR; } usb_packet.length = 1; usb_send_data((uint8_t*)&usb_packet); break; } case CMD_CAP_REPORT_FREQ: { if (current_fw_mode == MODE_IDLE) { set_capacitance_report_frequency(usb_packet.payload[0]); usb_packet.payload[0] = USB_RETURN_OK; } else { usb_packet.payload[0] = USB_RETURN_ERROR; } usb_packet.length = 1; usb_send_data((uint8_t*)&usb_packet); break; } case CMD_CAP_MES_START: { if (current_fw_mode == MODE_IDLE) { current_fw_mode = MODE_CAP_MES; set_capacitance_measurement_mode(); usb_packet.payload[0] = USB_RETURN_OK; } else { usb_packet.payload[0] = USB_RETURN_ERROR; } usb_packet.length = 1; usb_send_data((uint8_t*)&usb_packet); break; } case CMD_CAP_MES_EXIT: { if (current_fw_mode == MODE_CAP_MES) { current_fw_mode = MODE_IDLE; disable_capacitance_measurement_mode(); usb_packet.payload[0] = USB_RETURN_OK; } else { usb_packet.payload[0] = USB_RETURN_ERROR; } usb_packet.length = 1; usb_send_data((uint8_t*)&usb_packet); break; } case CMD_SET_VBIAS_DAC: { uint16_t* requested_dac_val = (uint16_t*)usb_packet.payload; uint16_t* requested_wait = (uint16_t*)&usb_packet.payload[2]; usb_packet.length = 2; if (is_ldo_enabled() == TRUE) { uint16_t set_vbias = force_vbias_dac_change(*requested_dac_val, *requested_wait); memcpy((void*)usb_packet.payload, (void*)&set_vbias, sizeof(set_vbias)); } else { usb_packet.payload[0] = 0; usb_packet.payload[1] = 0; } usb_send_data((uint8_t*)&usb_packet); break; } case CMD_RESET_STATE: { maindprintf_P(PSTR("USB- Reset\r\n")); usb_packet.length = 1; current_fw_mode = MODE_IDLE; if(is_platform_calibrated() == TRUE) { disable_bias_voltage(); disable_current_measurement_mode(); disable_capacitance_measurement_mode(); usb_packet.payload[0] = USB_RETURN_OK; } else { usb_packet.payload[0] = USB_RETURN_ERROR; } usb_send_data((uint8_t*)&usb_packet); break; } case CMD_SET_EEPROM_VALS: { uint16_t* addr = (uint16_t*)usb_packet.payload; uint16_t size = usb_packet.payload[2]; if(((*addr) + size > APP_STORED_DATA_MAX_SIZE) || (size > (RAWHID_RX_SIZE-5))) { usb_packet.payload[0] = USB_RETURN_ERROR; } else { eeprom_write_block((void*)&usb_packet.payload[3], (void*)(EEP_APP_STORED_DATA + (*addr)), size); usb_packet.payload[0] = USB_RETURN_OK; } usb_packet.length = 1; usb_send_data((uint8_t*)&usb_packet); break; } case CMD_READ_EEPROM_VALS: { uint16_t* addr = (uint16_t*)usb_packet.payload; uint16_t size = usb_packet.payload[2]; if(((*addr) + size > APP_STORED_DATA_MAX_SIZE) || (size > (RAWHID_TX_SIZE-2))) { usb_packet.length = 1; usb_packet.payload[0] = USB_RETURN_ERROR; } else { usb_packet.length = size; eeprom_read_block(usb_packet.payload, (void*)(EEP_APP_STORED_DATA + (*addr)), size); } usb_send_data((uint8_t*)&usb_packet); break; } default: break; } } } // Left here for reference //enable_bias_voltage(850);while(1); //automated_current_testing(); //ramp_bias_voltage_test(); //voltage_settling_test(); //automated_vbias_testing(); //automated_current_testing(); //peak_to_peak_adc_noise_measurement_test(); //ramp_bias_voltage_test(); //printf("blah\r\n");_delay_ms(3333); //ramp_current_test(); //functional_test(); //while(1); //calibrate_thresholds(); // Calibrate vup vlow & thresholds //calibrate_cur_mos_0nA(); // Calibrate 0nA point and store values in eeprom //calibrate_current_measurement(); // Calibrate the ADC for current measurements }
int main(void) { //disable interrupts cli(); //reset watchdog wdt_reset(); wdt_disable(); init_serial_port(9600); init_rf_module(); //TODO: set-up unused pins to avoid floating! //set direction registers ( 1 - output, 0 - input ) DDRB |= ( 1 << LED1_PIN ) | ( 1 << LED2_PIN ); set_led_state(1, 0); set_led_state(2, 0); //set up WDT interrupt _WD_CONTROL_REG = (1<<WDCE) | (1<<WDE); //Start watchdog timer with 8s prescaler _WD_CONTROL_REG = (1<<WDIE) | (1<<WDE) | (1<<WDP3) | (1<<WDP0); //Enable global interrupts sei(); for ( int i = 0; i < 3; i++ ) { set_led_state(1, 1); _delay_ms(100); set_led_state(1, 0); _delay_ms(350); } uint8_t cycle_count = 0; while ( 1 ) { cycle_count++; if ( cycle_count == 3 ) { for ( int i = 0; i < 2; i++ ) { set_led_state(2, 1); _delay_ms(200); set_led_state(2, 0); _delay_ms(200); } wdt_reset(); read_temperature_data(); cycle_count = 0; }else { set_led_state(1, 1); _delay_ms(1000); set_led_state(1, 0); } //wdt_reset(); set_sleep_mode(SLEEP_MODE_PWR_DOWN); sei(); sleep_mode(); } /* float temperature, humidity; while(1) { _delay_ms(1000); power_up_sensor(); _delay_ms(2500); temperature = 0.0; humidity = 0.0; read_data(&temperature, &humidity); _delay_ms(1500); power_down_sensor(); }*/ }
/* * Get datapoint data according to datapoint properties. * Here we fake the data using random numbers. */ void * get_datapoint_data(void *props) { float temperature = 0.0; void *ret = NULL; const char *name = get_string_by_name(props, "name"); ret = malloc(sizeof(double)); if (ret == NULL) { perror("No memory available.\n"); exit(-1); } if (strcmp(name, "grove_temperature") == 0) { /* the temperature sensor's output connect to a0 pin of galileo */ int a0v = galileo_analog_read(0); /* the value of a0v should within [0,4096], that use 12bit to * moderize 0~5v voltage, which means 0 stands for 0v while * 4096 stands for 5v. */ printf("Readed a0 pin voltage: %1.2f\n", ((double)a0v * 5) / 4096); /* then next we'll need to calculate temperature based on * the design of temperature sensor. */ int val = a0v / 4; int B = 3975; float resistance; if (val != 0) { resistance = (float)(1023 - val) * 10000 / val; temperature = 1 / (log(resistance / 10000) / B + 1 / 298.15) - 273.15; } printf("The temperature is: %2.2f c\n", temperature); /* return the temperature to libsensor */ *(double *)ret = (double)temperature; } else if (strcmp(name, "grove_light") == 0) { int a1v = galileo_analog_read(1); printf("Readed a1 pin voltage: %1.2f\n", ((double)a1v * 5) / 4096); int val = a1v / 4; printf("The light number is: %2.2f\n", (double)val); *(double *)ret = (double)val; } else if (strcmp(name, "grove_sound") == 0) { int a2v = galileo_analog_read(2); printf("Readed a2 pin voltage: %1.2f\n", ((double)a2v * 5) / 4096); int val = a2v / 4; printf("The sound number is: %2.2f\n", (double)val); *(double *)ret = (double)val; } else if (strcmp(name, "lm35-temperature") == 0) { int a0v = galileo_analog_read(0); /* get voltage */ printf("Readed a0 pin voltage: %1.2f\n", ((double)a0v * 5) / 4096); double val = a0v / 4; /* the lm35 output voltage is 10mV per degree, from 0 to 100 C */ double temperature = (val * 5 / 1024) * 100.00; printf("The lm35 temperature is: %2.2f C\n", temperature); *(double *)ret = temperature; } else if (strcmp(name, "oc_image") == 0) { struct timeb t; ftime(&t); /* prepare a image file then return its name to libsensor */ char *file = NULL; char *cmd = NULL; /* note, according to asprintf, the 'file' need be freed later, which will be done by libsensor */ asprintf(&file, "image_%lld%s", 1000 * (long long)t.time + t.millitm, ".jpg"); asprintf(&cmd, "capture %s 2>/dev/null", file); system(cmd); free(cmd); cmd = NULL; ret = (void*)file; } else if (strcmp(name, "image") == 0) { struct timeb t; ftime(&t); /* prepare a image file then return its name to libsensor */ char *file = NULL; char *cmd = NULL; /* note, according to asprintf, the 'file' need be freed later, which will be done by libsensor */ asprintf(&file, "image_%lld%s", 1000 * (long long)t.time + t.millitm, ".jpg"); asprintf(&cmd, "fswebcam -r 1280x720 --save %s 2>/dev/null", file); system(cmd); free(cmd); cmd = NULL; ret = (void*)file; } else if (strcmp(name, "serial_test") == 0) { unsigned char buf[32] = {}; int fd = init_serial_port(SERISL_DEVICE); if (fd < 0) { *(double *)ret = 0; } else { int len = do_read_from_serial(buf, fd); dump_str(buf, len); *(double *)ret = 1; } clean_serial_port(fd); } return ret; }