void user_init(void) { uart_set_baud(0, 115200); /* configure GPIOs */ gpio_enable(gpio_frc1, GPIO_OUTPUT); gpio_enable(gpio_frc2, GPIO_OUTPUT); gpio_write(gpio_frc1, 1); /* stop both timers and mask their interrupts as a precaution */ timer_set_interrupts(FRC1, false); timer_set_run(FRC1, false); timer_set_interrupts(FRC2, false); timer_set_run(FRC2, false); /* set up ISRs */ _xt_isr_attach(INUM_TIMER_FRC1, frc1_interrupt_handler); _xt_isr_attach(INUM_TIMER_FRC2, frc2_interrupt_handler); /* configure timer frequencies */ timer_set_frequency(FRC1, freq_frc1); timer_set_frequency(FRC2, freq_frc2); /* unmask interrupts and start timers */ timer_set_interrupts(FRC1, true); timer_set_run(FRC1, true); timer_set_interrupts(FRC2, true); timer_set_run(FRC2, true); gpio_write(gpio_frc1, 0); }
void user_init(void) { uart_set_baud(0, 115200); rboot_config conf = rboot_get_config(); printf("esp-gizmo. Running on flash slot %d / %d\n", conf.current_rom, conf.count); key_task_init(); load_driver_init(); mqtt_task_init(); struct sdk_station_config config = { .ssid = WIFI_SSID, .password = WIFI_PASS, }; /* required to call wifi_set_opmode before station_set_config */ sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_station_set_config(&config); printf("Starting TFTP server..."); ota_tftp_init_server(TFTP_PORT); xTaskCreate(main_task, "main", 1024, NULL, 1, NULL); xTaskCreate(health_state, "health_state", 512, NULL, 1, NULL); }
void user_init(void) { uart_set_baud(0, 115200); i2c_init(I2C_BUS, SCL_PIN, SDA_PIN, I2C_FREQ_100K); xTaskCreate(tsl4531MeasurementTask, "tsl4531MeasurementTask", 256, NULL, 2, NULL); }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); mainqueue = xQueueCreate(10, sizeof(uint32_t)); xTaskCreate(task1, "tsk1", 256, &mainqueue, 2, NULL); xTaskCreate(task2, "tsk2", 256, &mainqueue, 2, NULL); }
// Setup HW void user_setup(void) { // Set UART Parameter uart_set_baud(0, 115200); // Give the UART some time to settle sdk_os_delay_us(500); }
extern "C" void user_init(void) { uart_set_baud(0, 115200); user.xQueue = xQueueCreate(2, sizeof(uint32_t)); xTaskCreate(readTask, (signed char *)"readTask", 256, &user, tskIDLE_PRIORITY+1, NULL); xTaskCreate(transmitTask, (signed char*)"transmitTask", 256, &user, tskIDLE_PRIORITY, &user.xHandle); }
void user_init(void) { uart_set_baud(0, 115200); wifi_init(); if (button_create(BUTTON_PIN, button_callback)) { printf("Failed to initialize button\n"); } homekit_server_init(&config); }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); sdk_wifi_set_sleep_type(WIFI_SLEEP_MODEM); wificfg_init(80, dispatch_list); }
void user_init(void) { uart_set_baud(0, 115200); gpio_enable(gpio, GPIO_INPUT); gpio_enable(gpio_blink, GPIO_OUTPUT); tsqueue = xQueueCreate(2, sizeof(uint32_t)); xTaskCreate(buttonIntTask, (signed char *)"buttonIntTask", 256, &tsqueue, 2, NULL); xTaskCreate(buttonPollTask, (signed char*)"buttonPollTask", 256, NULL, 1, NULL); }
void main() { char command; uart_set_baud(1200); while(1) { command = uart_getkey(); lcd("Key Value: %c ",command); } }
void user_init(void) { // Set UART Parameter. uart_set_baud(0, 115200); // Give the UART some time to settle vTaskDelay(1); /** -- MANDATORY PART -- */ #ifdef SPI_USED spi_bus_init (SPI_BUS, SPI_SCK_GPIO, SPI_MISO_GPIO, SPI_MOSI_GPIO); // init the sensor connected to SPI_BUS with SPI_CS_GPIO as chip select. sensor = bme680_init_sensor (SPI_BUS, 0, SPI_CS_GPIO); #else // I2C // Init all I2C bus interfaces at which BME680 sensors are connected i2c_init(I2C_BUS, I2C_SCL_PIN, I2C_SDA_PIN, I2C_FREQ); // init the sensor with slave address BME680_I2C_ADDRESS_2 connected to I2C_BUS. sensor = bme680_init_sensor (I2C_BUS, BME680_I2C_ADDRESS_2, 0); #endif // SPI_USED if (sensor) { /** -- SENSOR CONFIGURATION PART (optional) --- */ // Changes the oversampling rates to 4x oversampling for temperature // and 2x oversampling for humidity. Pressure measurement is skipped. bme680_set_oversampling_rates(sensor, osr_4x, osr_none, osr_2x); // Change the IIR filter size for temperature and pressure to 7. bme680_set_filter_size(sensor, iir_size_7); // Change the heater profile 0 to 200 degree Celcius for 100 ms. bme680_set_heater_profile (sensor, 0, 200, 100); bme680_use_heater_profile (sensor, 0); // Set ambient temperature to 10 degree Celsius bme680_set_ambient_temperature (sensor, 10); /** -- TASK CREATION PART --- */ // must be done last to avoid concurrency situations with the sensor // configuration part // Create a task that uses the sensor xTaskCreate(user_task, "user_task", TASK_STACK_DEPTH, NULL, 2, NULL); } else printf("Could not initialize BME680 sensor\n"); }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); vSemaphoreCreateBinary(wifi_alive); publish_queue = xQueueCreate(3, PUB_MSG_LEN); xTaskCreate(&wifi_task, (int8_t *)"wifi_task", 256, NULL, 2, NULL); xTaskCreate(&beat_task, (int8_t *)"beat_task", 256, NULL, 3, NULL); xTaskCreate(&mqtt_task, (int8_t *)"mqtt_task", 1024, NULL, 4, NULL); }
void user_init(void) { uart_set_baud(0, 115200); sdk_wifi_set_opmode(STATION_MODE); /* * Run at a high enough priority so that the initial time-set doesn't get interrupted * Later calls and listen-only mode calls run in the high-priority "tcpip_thread" (LWIP) * * While 196 heap seemed sufficient for many tests, use of an NTP pool * with DNS caused heap errors/warnings on starting NTP at 256 heap */ xTaskCreate(sntp_task, "SNTP task", 288, NULL, 6, NULL); }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); i2c_init(I2C_BUS, SCL_PIN, SDA_PIN, I2C_FREQ_100K); hd44780_t lcd = { .i2c_dev.bus = I2C_BUS, .i2c_dev.addr = ADDR, .font = HD44780_FONT_5X8, .lines = 2, .pins = { .rs = 0, .e = 2, .d4 = 4, .d5 = 5, .d6 = 6, .d7 = 7, .bl = 3 }, .backlight = true }; hd44780_init(&lcd); hd44780_upload_character(&lcd, 0, char_data); hd44780_upload_character(&lcd, 1, char_data + 8); hd44780_gotoxy(&lcd, 0, 0); hd44780_puts(&lcd, "\x08 Hello world!"); hd44780_gotoxy(&lcd, 0, 1); hd44780_puts(&lcd, "\x09 "); char time[16]; while (true) { hd44780_gotoxy(&lcd, 2, 1); snprintf(time, 7, "%u ", sdk_system_get_time() / 1000000); time[sizeof(time) - 1] = 0; hd44780_puts(&lcd, time); for (uint32_t i = 0; i < 1000; i++) sdk_os_delay_us(1000); } }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); struct sdk_station_config config = { .ssid = WIFI_SSID, .password = WIFI_PASS, }; /* required to call wifi_set_opmode before station_set_config */ sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_station_set_config(&config); xTaskCreate(&http_get_task, (signed char *)"get_task", 256, NULL, tskIDLE_PRIORITY+1, NULL); }
void user_init(void) { // Set UART Parameter uart_set_baud(0, 115200); // Give the UART some time to settle sdk_os_delay_us(500); /** -- MANDATORY PART -- */ // Init all I2C bus interfaces at which BME680 sensors are connected i2c_init(I2C_BUS, I2C_SCL_PIN, I2C_SDA_PIN, I2C_FREQ_100K); // Init the sensors sensor1 = bme680_init_sensor (I2C_BUS, BME680_I2C_ADDRESS_2, 0); sensor2 = bme680_init_sensor (SPI_BUS, 0, SPI_CS_GPIO); if (sensor1 && sensor2) { /** -- SENSOR CONFIGURATION PART (optional) --- */ // Changes the oversampling rates for both sensor to different values bme680_set_oversampling_rates(sensor1, osr_4x, osr_2x, osr_1x); bme680_set_oversampling_rates(sensor2, osr_8x, osr_8x, osr_8x); // Change the IIR filter size for temperature and and pressure to 7. bme680_set_filter_size(sensor1, iir_size_7); bme680_set_filter_size(sensor2, iir_size_7); // Change the heater profile 0 to 200 degree Celcius for 150 ms. bme680_set_heater_profile (sensor1, 0, 200, 150); bme680_set_heater_profile (sensor2, 0, 200, 150); // Activate the heater profile 0 bme680_use_heater_profile (sensor1, 0); bme680_use_heater_profile (sensor2, 0); /** -- TASK CREATION PART --- */ // must be done last to avoid concurrency situations with the sensor // configuration part // Create the tasks that use the sensors xTaskCreate(user_task_sensor1, "user_task_sensor1", 256, NULL, 2, 0); xTaskCreate(user_task_sensor2, "user_task_sensor2", 256, NULL, 2, 0); } }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); // Set led to indicate wifi status. sdk_wifi_status_led_install(2, PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2); struct sdk_station_config config = { .ssid = WIFI_SSID, .password = WIFI_PASS, }; // Required to call wifi_set_opmode before station_set_config. sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_station_set_config(&config); xTaskCreate(&broadcast_temperature, "broadcast_temperature", 256, NULL, 2, NULL); }
void uart_setup() { uart_disable; // configure transmission nrf_gpio_pin_dir_set(PIN_UART_TXD, NRF_GPIO_PIN_DIR_OUTPUT); uart_select_pin_as_TXD(PIN_UART_TXD); uart_select_pin_as_RTS(UART_PIN_DISABLE); uart_select_pin_as_CTS(UART_PIN_DISABLE); uart_set_baud(baud_9600); uart_set_parity_exclude; uart_flow_control_enable; // configure reception uart_select_pin_as_RXD(PIN_UART_RXD); uart_interrupt_upon_RXDRDY_enable; uart_interrupt_upon_RXTO_enable; uart_interrupt_upon_ERROR_enable; uart_start_receiver; uart_enable; }
void user_init(void) { uint8_t pins[1]; uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); printf("pwm_init(1, [14])\n"); pins[0] = 14; pwm_init(1, pins); printf("pwm_set_freq(1000) # 1 kHz\n"); pwm_set_freq(1000); printf("pwm_set_duty(UINT16_MAX/2) # 50%%\n"); pwm_set_duty(UINT16_MAX/2); printf("pwm_start()\n"); pwm_start(); xTaskCreate(task1, (signed char *)"tsk1", 256, NULL, 2, NULL); }
void user_init(void) { uart_set_baud(0, 115200); midea_ir_init(&ir, 14); config_init(); rboot_config conf = rboot_get_config(); printf("Currently running on flash slot %d / %d\n", conf.current_rom, conf.count); printf("Image addresses in flash:\n"); for(int i = 0; i <conf.count; i++) { printf("%c%d: offset 0x%08x\n", i == conf.current_rom ? '*':' ', i, conf.roms[i]); } start_config_server(); xTaskCreate(main_task, (signed char *)"main", 512, NULL, 4, NULL); /* xTaskCreate(test_task, (signed char *)"test", 512, NULL, 2, NULL); */ ota_tftp_init_server(TFTP_PORT); }
void user_init(void) { i2c_init(I2C_BUS, SCL_PIN, SDA_PIN, I2C_FREQ_100K); uart_set_baud(0, 115200); printf("SDK version:%s\n\n", sdk_system_get_sdk_version()); ms561101ba03_t device = { .i2c_dev.bus = I2C_BUS, .i2c_dev.addr = MS561101BA03_ADDR_CSB_LOW, .osr = MS561101BA03_OSR_4096, }; while (!ms561101ba03_init(&device)) printf("Device not found\n"); while (true) { if (!ms561101ba03_get_sensor_data(&device)) printf("Error reading sensor data from device"); printf("Temperature in C * 100: %i \nPressure in mbar * 100: %i\n", device.result.temperature, device.result.pressure); } }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); i2c_init(SCL_PIN, SDA_PIN); // setup EEPROM values if (mcp4725_get_power_mode(ADDR, true) != MCP4725_PM_NORMAL) { printf("DAC was sleeping... Wake up Neo!\n"); mcp4725_set_power_mode(ADDR, MCP4725_PM_NORMAL, true); wait_for_eeprom(); } printf("Set default DAC ouptut value to MAX...\n"); mcp4725_set_raw_output(ADDR, MCP4725_MAX_VALUE, true); wait_for_eeprom(); printf("And now default DAC output value is 0x%03x\n", mcp4725_get_raw_output(ADDR, true)); printf("Now let's generate the sawtooth wave in slow manner\n"); float vout = 0; while (true) { vout += 0.1; if (vout > VDD) vout = 0; printf("Vout: %.02f\n", vout); mcp4725_set_voltage(ADDR, VDD, vout, false); // It will be very low freq wave vTaskDelay(100 / portTICK_PERIOD_MS); } }
void play_task(void *pvParameters) { esp_spiffs_init(); if (esp_spiffs_mount() != SPIFFS_OK) { printf("Error mount SPIFFS\n"); } int fd = open("sample.wav", O_RDONLY); if (fd < 0) { printf("Error opening file\n"); return; } dumb_wav_header_t wav_header; read(fd, (void*)&wav_header, sizeof(wav_header)); printf("Number of channels: %d\n", wav_header.num_channels); printf("Bits per sample: %d\n", wav_header.bits_per_sample); printf("Sample rate: %d\n", wav_header.sample_rate); printf("Data size: %d\n", wav_header.data_size); if (wav_header.bits_per_sample != 16) { printf("Only 16 bit per sample is supported\n"); return; } if (wav_header.num_channels != 2) { printf("Only 2 channels is supported\n"); return; } i2s_clock_div_t clock_div = i2s_get_clock_div( wav_header.sample_rate * 2 * 16); printf("i2s clock dividers, bclk=%d, clkm=%d\n", clock_div.bclk_div, clock_div.clkm_div); i2s_pins_t i2s_pins = {.data = true, .clock = true, .ws = true}; i2s_dma_init(dma_isr_handler, clock_div, i2s_pins); while (1) { init_descriptors_list(); i2s_dma_start(dma_block_list); lseek(fd, sizeof(dumb_wav_header_t), SEEK_SET); while (play_data(fd)) {}; i2s_dma_stop(); vQueueDelete(dma_queue); printf("underrun counter: %d\n", underrun_counter); vTaskDelay(1000 / portTICK_PERIOD_MS); } close(fd); } void user_init(void) { uart_set_baud(0, 115200); xTaskCreate(play_task, "test_task", 1024, NULL, 2, NULL); }
void user_init(void) { uart_set_baud(0, 921600); printf("\n\nESP8266 UMAC\n\n"); bridge_init(); umac_cfg um_cfg = { .timer_fn = umac_impl_request_future_tick, .cancel_timer_fn = umac_impl_cancel_future_tick, .now_fn = umac_impl_now_tick, .tx_byte_fn = umac_impl_tx_byte, .tx_buf_fn = umac_impl_tx_buf, .rx_pkt_fn = umac_impl_rx_pkt, .rx_pkt_ack_fn = bridge_pkt_acked, .timeout_fn = bridge_timeout, .nonprotocol_data_fn = NULL }; umac_init(&um, &um_cfg, rx_buf); um_tim_hdl = xTimerCreate( (signed char *)"umac_tim", 10, false, (void *)um_tim_id, um_tim_cb); char ap_cred[128]; struct sdk_station_config config; bool setup_ap = true; systask_init(); device_id = 0; fs_init(); if (fs_mount() >= 0) { #if 0 spiffs_DIR d; struct spiffs_dirent e; struct spiffs_dirent *pe = &e; fs_opendir("/", &d); while ((pe = fs_readdir(&d, pe))) { printf("%s [%04x] size:%i\n", pe->name, pe->obj_id, pe->size); } fs_closedir(&d); #endif // read preferred ssid spiffs_file fd_ssid = fs_open(".ssid", SPIFFS_RDONLY, 0); if (fd_ssid > 0) { if (fs_read(fd_ssid, (uint8_t *)ap_cred, sizeof(ap_cred)) > 0) { fs_close(fd_ssid); char *nl_ix = strchr(ap_cred, '\n'); if (nl_ix > 0) { memset(&config, 0, sizeof(struct sdk_station_config)); strncpy((char *)&config.ssid, ap_cred, nl_ix - ap_cred); char *nl_ix2 = strchr(nl_ix + 1, '\n'); if (nl_ix2 > 0) { strncpy((char *)&config.password, nl_ix + 1, nl_ix2 - (nl_ix + 1)); setup_ap = false; } } printf("ssid:%s\n", config.ssid); } // if read else { printf("could not read .ssid\n"); } } // if fs_ssid else { printf("no .ssid found, running softAP\n"); } // find device id or create one spiffs_file fd_devid = fs_open(".devid", SPIFFS_RDONLY, 0); if (fd_devid < 0) { device_id = hwrand(); fd_devid = fs_open(".devid", SPIFFS_O_CREAT | SPIFFS_O_TRUNC | SPIFFS_O_WRONLY | SPIFFS_O_APPEND, 0); fs_write(fd_devid, &device_id, 4); printf("create devid\n"); } else { fs_read(fd_devid, &device_id, 4); } fs_close(fd_devid); printf("devid %08x\n", device_id); // remove previous scan results fs_remove(SYSTASK_AP_SCAN_FILENAME); } // if mount if (setup_ap) { sdk_wifi_set_opmode(SOFTAP_MODE); struct ip_info ap_ip; IP4_ADDR(&ap_ip.ip, 192, 169, 1, 1); IP4_ADDR(&ap_ip.gw, 0, 0, 0, 0); IP4_ADDR(&ap_ip.netmask, 255, 255, 255, 0); sdk_wifi_set_ip_info(1, &ap_ip); struct sdk_softap_config ap_cfg = { .ssid = "WISLEEP", .password = "", .ssid_len = 7, .channel = 1, .authmode = AUTH_OPEN, .ssid_hidden = false, .max_connection = 255, .beacon_interval = 100 }; sdk_wifi_softap_set_config(&ap_cfg); ip_addr_t first_client_ip; IP4_ADDR(&first_client_ip, 192, 169, 1, 100); dhcpserver_start(&first_client_ip, 4); } else { // required to call wifi_set_opmode before station_set_config sdk_wifi_set_opmode(STATION_MODE); sdk_wifi_station_set_config(&config); } server_init(server_actions); um_mutex = xSemaphoreCreateMutex(); xTaskCreate(uart_task, (signed char * )"uart_task", 512, NULL, 2, NULL); xTaskCreate(server_task, (signed char *)"server_task", 1024, NULL, 2, NULL); }
extern "C" void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); xTaskCreate(task1, (signed char *)"tsk1", 256, NULL, 2, NULL); }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); xTaskCreate(json_test, (signed char *)"jsont", 1024, NULL, 2, NULL); }
void user_init(void) { uart_set_baud(0, 115200); xTaskCreate(blinkenTask, (signed char *)"blinkenTask", 256, NULL, 2, NULL); //xTaskCreate(blinkenRegisterTask, (signed char *)"blinkenRegisterTask", 256, NULL, 2, NULL); }
void user_init(void) { uart_set_baud(0, 115200); xTaskCreate(dhtMeasurementTask, (signed char *)"dhtMeasurementTask", 256, NULL, 2, NULL); }
void user_init(void) { uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); xTaskCreate(loop, "loop", 1024, NULL, 2, NULL); }
void user_init(void) { #if (OVERCLOCK) sdk_system_update_cpu_freq(160); #endif // Setup HW uart_set_baud(0, 115200); printf("SDK version:%s\n", sdk_system_get_sdk_version()); #if (I2C_CONNECTION) i2c_init(I2C_BUS, SCL_PIN, SDA_PIN, I2C_FREQ_400K); #else #if (CS_PIN == 15) spi_init(SPI_BUS, SPI_MODE0, SPI_FREQ_DIV_8M, true, SPI_LITTLE_ENDIAN, false); #else spi_init(SPI_BUS, SPI_MODE0, SPI_FREQ_DIV_8M, true, SPI_LITTLE_ENDIAN, true); gpio_enable(CS_PIN, GPIO_OUTPUT); #endif #endif #if (RST_PIN != LV_DRIVER_NOPIN) gpio_enable(RST_PIN, GPIO_OUTPUT); #endif /*Gui initialization*/ lv_init(); /*Screen initialization*/ #if (I2C_CONNECTION) dev.i2c_dev = (lv_i2c_handle_t)&i2c_dev; #else dev.spi_dev = (lv_spi_handle_t)&spi_dev; #endif dev.protocol = PROTOCOL ; //SSD1306_PROTO_SPI3; dev.screen = SH1106_SCREEN; //SSD1306_SCREEN, SH1106_SCREEN dev.width = LV_HOR_RES; dev.height = LV_VER_RES; dev.rst_pin = RST_PIN; //No RST PIN USED while (ssd1306_init(&dev) != 0) { printf("%s: failed to init SSD1306 lcd\n", __func__); vTaskDelay(SECOND); } ssd1306_set_whole_display_lighting(&dev, true); /*inverse screen (180°) */ ssd1306_set_scan_direction_fwd(&dev,true); ssd1306_set_segment_remapping_enabled(&dev, false); vTaskDelay(SECOND); /*lvgl screen registration */ lv_disp_drv_t disp_drv; lv_disp_drv_init(&disp_drv); /*Set up the functions to access to your display*/ disp_drv.disp_flush = ssd1306_flush; /*Used in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/ disp_drv.disp_fill = NULL;//ex_disp_fill; /*Used in unbuffered mode (LV_VDB_SIZE == 0 in lv_conf.h)*/ disp_drv.disp_map = NULL;//ex_disp_map; /*Used in unbuffered mode (LV_VDB_SIZE == 0 in lv_conf.h)*/ disp_drv.vdb_wr = ssd1306_vdb_wr; lv_disp_drv_register(&disp_drv); /* Create user interface task */ xTaskCreate(ssd1306_task, "ssd1306_task", 512, NULL, 2, NULL); font_timer_handle = xTimerCreate("font_timer", 5 * SECOND, pdTRUE, NULL, font_timer); xTimerStart(font_timer_handle, 0); #if (!TICK_HANDLER && !LV_TICK_CUSTOM) lvgl_timer_handle = xTimerCreate("lvgl_timer", TICK_INC_MS/portTICK_PERIOD_MS, pdTRUE, NULL, lvgl_timer); xTimerStart(lvgl_timer_handle, 0); #endif }