/**
* Handle a GPIO interrupt.
* We have arrived in this callback function because the state of a GPIO pin has changed
* and it is time to record that change.
*/
static void CALLED_FROM_INTERRUPT intrHandlerCB(
uint32 interruptMask, //!< A mask indicating which GPIOs have changed.
void *arg //!< Optional argument.
) {
// Given the interrupt mask, we as if bit "x" is on. If it is, then that is defined as meaning
// that the state of GPIO "x" has changed so we want to raised an event that indicates that this
// has happened...
// Once we have handled the interrupt flags, we need to acknowledge the interrupts so
// that the ESP8266 will once again cause future interrupts to be processed.
//os_printf_plus(">> intrHandlerCB\n");
gpio_intr_ack(interruptMask);
// We have a mask of interrupts that have happened. Go through each bit in the mask
// and, if it is on, then an interrupt has occurred on the corresponding pin.
int pin;
for (pin=0; pin<JSH_PIN_COUNT; pin++) {
if ((interruptMask & (1<<pin)) != 0) {
// Pin has changed so push the event that says pin has changed.
jshPushIOWatchEvent(pinToEV_EXTI(pin));
gpio_pin_intr_state_set(GPIO_ID_PIN(pin), GPIO_PIN_INTR_ANYEDGE);
}
}
//os_printf_plus("<< intrHandlerCB\n");
}
/******************************************************************************
* FunctionName : user_humiture_init
* Description : init humiture function, include key and mvh3004
* Parameters : none
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_sensor_init(uint8 active)
{
user_link_led_init();
wifi_status_led_install(SENSOR_WIFI_LED_IO_NUM, SENSOR_WIFI_LED_IO_MUX, SENSOR_WIFI_LED_IO_FUNC);
if (wifi_get_opmode() != SOFTAP_MODE) {
single_key[0] = key_init_single(SENSOR_KEY_IO_NUM, SENSOR_KEY_IO_MUX, SENSOR_KEY_IO_FUNC,
user_sensor_long_press, NULL);
keys.key_num = SENSOR_KEY_NUM;
keys.single_key = single_key;
key_init(&keys);
if (GPIO_INPUT_GET(GPIO_ID_PIN(SENSOR_KEY_IO_NUM)) == 0) {
user_sensor_long_press();
}
}
#if HUMITURE_SUB_DEVICE
user_mvh3004_init();
user_mvh3004_read_th(humiture_data);
#endif
#ifdef SENSOR_DEEP_SLEEP
if (wifi_get_opmode() != STATIONAP_MODE) {
if (active == 1) {
user_sensor_deep_sleep_init(SENSOR_DEEP_SLEEP_TIME / 1000 / 3);
} else {
user_sensor_deep_sleep_init(SENSOR_DEEP_SLEEP_TIME / 1000 / 3 * 2);
}
}
#endif
}
static void ICACHE_FLASH_ATTR stledIsr(void)
{
switch (opState) {
case STLED_OFF:
GPIO_OUTPUT_SET(GPIO_ID_PIN(STLED_GPIO), 1);
break;
case STLED_ON:
GPIO_OUTPUT_SET(GPIO_ID_PIN(STLED_GPIO), 0);
break;
case STLED_BLINK_SLOW:
GPIO_OUTPUT_SET(GPIO_ID_PIN(STLED_GPIO), ((counter>>2)&1u));
break;
case STLED_BLINK_FAST:
GPIO_OUTPUT_SET(GPIO_ID_PIN(STLED_GPIO), (counter&1u));
break;
case STLED_BLINK_HB:
if ((counter&7u) ==0 || (counter&7u) == 2 || (counter&7u) == 4)
GPIO_OUTPUT_SET(GPIO_ID_PIN(STLED_GPIO), 0);
else
GPIO_OUTPUT_SET(GPIO_ID_PIN(STLED_GPIO), 1);
break;
}
++counter;
}
void ICACHE_FLASH_ATTR SEND_WS_0()
{
uint8_t time;
time = 4; while(time--) WRITE_PERI_REG( PERIPHS_GPIO_BASEADDR + GPIO_ID_PIN(0), 1 );
time = 9; while(time--) WRITE_PERI_REG( PERIPHS_GPIO_BASEADDR + GPIO_ID_PIN(0), 0 );
}
void ICACHE_FLASH_ATTR
supla_esp_gpio_init(void) {
switch_cfgbtn_state_check = 0;
switch_cfgbtn_last_state = -1;
switch_cfgbtn_counter = 0;
#if defined(USE_GPIO3) || defined(UART_SWAP)
system_uart_swap ();
#endif
ETS_GPIO_INTR_DISABLE();
GPIO_PORT_INIT;
#ifdef USE_GPIO16_INPUT
gpio16_input_conf();
#endif
#ifdef USE_GPIO16_OUTPUT
gpio16_output_conf();
#endif
#ifdef USE_GPIO3
PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_GPIO3);
PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0RXD_U);
#endif
#ifdef BTN_PULLUP
#if CFG_PORT == 0
PIN_PULLUP_EN(PERIPHS_IO_MUX_GPIO0_U);
#elif CFG_PORT == 2
PIN_PULLUP_EN(PERIPHS_IO_MUX_GPIO2_U);
#elif CFG_PORT == 4
PIN_PULLUP_EN(PERIPHS_IO_MUX_GPIO4_U);
#elif CFG_PORT == 12
PIN_PULLUP_EN(PERIPHS_IO_MUX_MTDI_U);
#elif CFG_PORT == 13
PIN_PULLUP_EN(PERIPHS_IO_MUX_MTCK_U);
#elif CFG_PORT == 14
PIN_PULLUP_EN(PERIPHS_IO_MUX_MTMS_U);
#endif
#endif
#ifdef LED_RED_PORT
#if LED_RED_PORT != 16
gpio_pin_intr_state_set(GPIO_ID_PIN(LED_RED_PORT), GPIO_PIN_INTR_DISABLE);
#endif
#endif
#ifdef LED_GREEN_PORT
gpio_pin_intr_state_set(GPIO_ID_PIN(LED_GREEN_PORT), GPIO_PIN_INTR_DISABLE);
#endif
#ifdef LED_BLUE_PORT
gpio_pin_intr_state_set(GPIO_ID_PIN(LED_BLUE_PORT), GPIO_PIN_INTR_DISABLE);
#endif
#ifdef RELAY1_PORT
gpio_pin_intr_state_set(GPIO_ID_PIN(RELAY1_PORT), GPIO_PIN_INTR_DISABLE);
#endif
#ifdef RELAY2_PORT
gpio_pin_intr_state_set(GPIO_ID_PIN(RELAY2_PORT), GPIO_PIN_INTR_DISABLE);
#endif
#ifdef ZAM_INPUT1
supla_esp_gpio_enable_input_port(ZAM_INPUT1);
#endif
#ifdef ZAM_INPUT2
supla_esp_gpio_enable_input_port(ZAM_INPUT2);
#endif
ETS_GPIO_INTR_ENABLE();
keys.key_num = 0;
single_key[0] = key_init_single(CFG_PORT, supla_esg_gpio_cfg_pressed, supla_esg_gpio_manual_pressed);
keys.key_num++;
#if defined(BUTTON1_PORT) && defined(RELAY1_PORT)
single_key[keys.key_num] = key_init_single(BUTTON1_PORT, NULL, supla_esg_gpio_button1_pressed);
keys.key_num++;
#endif
#if defined(BUTTON1_PORT) && defined(RELAY1_PORT)
single_key[keys.key_num] = key_init_single(BUTTON2_PORT, NULL, supla_esg_gpio_button2_pressed);
keys.key_num++;
#endif
keys.single_key = single_key;
keys.handler = supla_esp_key_intr_handler;
#ifdef RELAY_STATE_RESTORE
struct rst_info *rtc_info = system_get_rst_info();
#ifdef RELAY1_PORT
if ( rtc_info->reason == 0 ) {
supla_esp_gpio_relay1_hi(supla_esp_state.Relay1);
}
#endif
#ifdef RELAY2_PORT
if ( rtc_info->reason == 0 ) {
supla_esp_gpio_relay2_hi(supla_esp_state.Relay2);
}
#endif
#elif defined(RESET_RELAY_PORT)
#ifdef RELAY1_PORT
supla_esp_gpio_relay1_hi(RELAY_INIT_VALUE);
#endif
#ifdef RELAY2_PORT
supla_esp_gpio_relay2_hi(RELAY_INIT_VALUE);
#endif
#endif
key_init(&keys);
GPIO_PORT_POST_INIT;
supla_esp_gpio_init_time = system_get_time();
}
void Softuart_Intr_Handler(Softuart *s)
{
uint8_t level, gpio_id;
// clear gpio status. Say ESP8266EX SDK Programming Guide in 5.1.6. GPIO interrupt handler
uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
gpio_id = Softuart_Bitcount(gpio_status);
//if interrupt was by an attached rx pin
if (gpio_id != 0xFF)
{
//load instance which has rx pin on interrupt pin attached
s = _Softuart_GPIO_Instances[gpio_id];
// disable interrupt for GPIO0
gpio_pin_intr_state_set(GPIO_ID_PIN(s->pin_rx.gpio_id), GPIO_PIN_INTR_DISABLE);
// Do something, for example, increment whatyouwant indirectly
//check level
level = GPIO_INPUT_GET(GPIO_ID_PIN(s->pin_rx.gpio_id));
if(!level) {
//pin is low
//therefore we have a start bit
//wait till start bit is half over so we can sample the next one in the center
os_delay_us(s->bit_time/2);
//now sample bits
unsigned i;
unsigned d = 0;
unsigned start_time = 0x7FFFFFFF & system_get_time();
for(i = 0; i < 8; i ++ )
{
while ((0x7FFFFFFF & system_get_time()) < (start_time + (s->bit_time*(i+1))))
{
//If system timer overflow, escape from while loop
if ((0x7FFFFFFF & system_get_time()) < start_time){break;}
}
//shift d to the right
d >>= 1;
//read bit
if(GPIO_INPUT_GET(GPIO_ID_PIN(s->pin_rx.gpio_id))) {
//if high, set msb of 8bit to 1
d |= 0x80;
}
}
//store byte in buffer
// if buffer full, set the overflow flag and return
uint8 next = (s->buffer.receive_buffer_tail + 1) % SOFTUART_MAX_RX_BUFF;
if (next != s->buffer.receive_buffer_head)
{
// save new data in buffer: tail points to where byte goes
s->buffer.receive_buffer[s->buffer.receive_buffer_tail] = d; // save new byte
s->buffer.receive_buffer_tail = next;
}
else
{
s->buffer.buffer_overflow = 1;
}
//wait for stop bit
os_delay_us(s->bit_time);
//done
}
//-----------------------------------------------------------------------------------------
void static dht11_protocol(uint32 gpio_status,int cause)
{
static int actual_bit;
switch(cause) // 0 = gpio interrupt, 1=timer
{
case 0: // gpio edge
{
// disable interrupt for GPIO
gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_DISABLE);
// clear interrupt status for GPIO
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & GPIO_Pin(dht11_gpio));
// Reactivate interrupts for GPIO0
gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_ANYEGDE);
switch(sStatus)
{
case dht11_connecting:
if(GPIO_INPUT_GET(dht11_gpio))
{
// Rising edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
sStatus = dht11_mark_connecting;
}
break;
case dht11_mark_connecting:
if(!GPIO_INPUT_GET(dht11_gpio))
{
// Falling edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
sStatus = dht11_waiting_bit;
}
break;
case dht11_waiting_bit:
if(GPIO_INPUT_GET(dht11_gpio))
{
// Rising edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
sStatus = dht11_mark_bit;
actual_bit=0;
}
break;
case dht11_mark_bit:
if(! GPIO_INPUT_GET(dht11_gpio))
{
// Falling edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
if(actual_bit >= 40)
{
dht11_set_standby(); // finish OK
}
else
{
last_timer = system_get_time();
sStatus = dht11_read_bit;
}
}
break;
case dht11_read_bit:
if(GPIO_INPUT_GET(dht11_gpio))
{
// Rising edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
// 26-28 uS means 0. 70 uS means 1
int bit_data = ((system_get_time()-last_timer) > 40) ? 1:0;
int actual_byte = actual_bit / 8;
sRead[actual_byte] <<= 1;
sRead[actual_byte] |= bit_data;
actual_bit++;
sStatus = dht11_mark_bit;
}
break;
case dht11_standby:
case dht11_mark:
default:
dht11_set_standby();
break;
}
}
break;
case 1: //timer
switch(sStatus)
{
case dht11_mark: // end of mark
sStatus = dht11_connecting;
// GPIO as Output to high level by default.
GPIO_OUTPUT_SET(dht11_gpio,1);
GPIO_AS_INPUT(dht11_gpio);
ETS_GPIO_INTR_DISABLE();
gpio_register_set(GPIO_PIN_ADDR(dht11_gpio),
GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) |
GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) |
GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE));
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(dht11_gpio));
gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_ANYEGDE);
ETS_GPIO_INTR_ENABLE();
os_timer_disarm(&dht11_timer);
os_timer_arm(&dht11_timer,6,0); // maximun frame time 4.8 ms
break;
case dht11_connecting:
case dht11_mark_connecting:
case dht11_waiting_bit:
case dht11_mark_bit:
case dht11_read_bit:
default:
dht11_set_read_nok();
dht11_set_standby();
break;
}
default:
break;
}
}
void ICACHE_FLASH_ATTR
user_link_led_output(uint8 level)
{
GPIO_OUTPUT_SET(GPIO_ID_PIN(PLUG_LINK_LED_IO_NUM), level);
}
void ICACHE_FLASH_ATTR
user_link_led_timer_done(void)
{
os_timer_disarm(&link_led_timer);
GPIO_OUTPUT_SET(GPIO_ID_PIN(PLUG_LINK_LED_IO_NUM), 0);
}
/**
* Sends a ping, and returns the number of microseconds it took to receive a response.
* Will give up after maxPeriod (with false as return value)
*/
bool ICACHE_FLASH_ATTR
ping_pingUs(Ping_Data *pingData, uint32_t maxPeriod, uint32_t* response) {
uint32_t timeOutAt = system_get_time() + maxPeriod;
ping_echoEnded = false;
ping_echoStarted = false;
ping_timeStamp0 = system_get_time();
if (!pingData->isInitiated) {
*response = 0;
os_printf("ping_pingUs: Error: not initiated properly.\n");
return false;
}
if (ping_currentEchoPin >= 0) {
// this should not really happend, how did you end up here?
*response = 0;
os_printf("ping_pingUs: Error: another ping is already running.\n");
return false;
}
uint32_t echoPin = pingData->echoPin;
uint32_t triggerPin = pingData->triggerPin;
ping_currentEchoPin = pingData->echoPin;
while (GPIO_INPUT_GET(echoPin)) {
if (system_get_time() > timeOutAt) {
// echo pin never went low, something is wrong.
// turns out this happens whenever the sensor doesn't receive any echo at all.
//os_printf("ping_ping: Error: echo pin %d permanently high %d?.\n", echoPin, GPIO_INPUT_GET(echoPin));
*response = system_get_time() - ping_timeStamp0;
// Wake up a sleeping device
GPIO_OUTPUT_SET(triggerPin, PING_TRIGGER_DEFAULT_STATE);
os_delay_us(50);
GPIO_OUTPUT_SET(triggerPin, !PING_TRIGGER_DEFAULT_STATE);
os_delay_us(50);
GPIO_OUTPUT_SET(triggerPin, PING_TRIGGER_DEFAULT_STATE);
ping_disableInterrupt(ping_currentEchoPin);
ping_currentEchoPin = -1;
return false;
}
os_delay_us(PING_POLL_PERIOD);
}
GPIO_OUTPUT_SET(triggerPin, 1);
os_delay_us(PING_TRIGGER_LENGTH);
GPIO_OUTPUT_SET(triggerPin, 0);
if (echoPin == triggerPin) {
// force the trigger pin low for 50us. This helps stabilise echo pin when
// running in single pin mode.
os_delay_us(50);
}
GPIO_DIS_OUTPUT(echoPin);
gpio_pin_intr_state_set(GPIO_ID_PIN(echoPin), GPIO_PIN_INTR_POSEDGE);
while (!ping_echoEnded) {
if (system_get_time() > timeOutAt) {
*response = system_get_time() - ping_timeStamp0;
ping_disableInterrupt(ping_currentEchoPin);
ping_currentEchoPin = -1;
return false;
}
os_delay_us(PING_POLL_PERIOD);
}
*response = ping_timeStamp1 - ping_timeStamp0;
if (ping_timeStamp1 < ping_timeStamp0 || *response < 50) {
// probably a previous echo or clock overflow - false result
ping_disableInterrupt(ping_currentEchoPin);
ping_currentEchoPin = -1;
return false;
}
return true;
}
int platform_gpio_mode( unsigned pin, unsigned mode, unsigned pull )
{
// NODE_DBG("Function platform_gpio_mode() is called. pin_mux:%d, func:%d\n",pin_mux[pin],pin_func[pin]);
if (pin >= NUM_GPIO)
return -1;
if(pin == 0){
if(mode==PLATFORM_GPIO_INPUT)
gpio16_input_conf();
else
gpio16_output_conf();
return 1;
}
platform_pwm_close(pin); // closed from pwm module, if it is used in pwm
switch(pull){
case PLATFORM_GPIO_PULLUP:
PIN_PULLDWN_DIS(pin_mux[pin]);
PIN_PULLUP_EN(pin_mux[pin]);
break;
case PLATFORM_GPIO_PULLDOWN:
PIN_PULLUP_DIS(pin_mux[pin]);
PIN_PULLDWN_EN(pin_mux[pin]);
break;
case PLATFORM_GPIO_FLOAT:
PIN_PULLUP_DIS(pin_mux[pin]);
PIN_PULLDWN_DIS(pin_mux[pin]);
break;
default:
PIN_PULLUP_DIS(pin_mux[pin]);
PIN_PULLDWN_DIS(pin_mux[pin]);
break;
}
switch(mode){
case PLATFORM_GPIO_INPUT:
#if defined( LUA_USE_MODULES_GPIO ) && defined( GPIO_INTERRUPT_ENABLE )
lua_gpio_unref(pin); // unref the lua ref call back.
#endif
GPIO_DIS_OUTPUT(pin_num[pin]);
case PLATFORM_GPIO_OUTPUT:
ETS_GPIO_INTR_DISABLE();
#ifdef GPIO_INTERRUPT_ENABLE
pin_int_type[pin] = GPIO_PIN_INTR_DISABLE;
#endif
PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]);
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[pin]), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pin_num[pin]));
GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin]))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain;
ETS_GPIO_INTR_ENABLE();
break;
#ifdef GPIO_INTERRUPT_ENABLE
case PLATFORM_GPIO_INT:
ETS_GPIO_INTR_DISABLE();
PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]);
GPIO_DIS_OUTPUT(pin_num[pin]);
gpio_register_set(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE)
| GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE)
| GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE));
ETS_GPIO_INTR_ENABLE();
break;
#endif
default:
break;
}
return 1;
}
LOCAL void ICACHE_FLASH_ATTR user_link_led_init(void) {
PIN_FUNC_SELECT(SENSOR_LINK_LED_IO_MUX, SENSOR_LINK_LED_IO_FUNC);
PIN_FUNC_SELECT(SENSOR_UNUSED_LED_IO_MUX, SENSOR_UNUSED_LED_IO_FUNC);
GPIO_OUTPUT_SET(GPIO_ID_PIN(SENSOR_UNUSED_LED_IO_NUM), 0);
}
// initialize the custom stuff that goes beyond esp-link
void user_init()
{
// Initialize the GPIO subsystem.
gpio_init();
/* ====================================== */
/* UART */
/* ====================================== */
// Initialize UART0 and UART1
/* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */
uart_init( BIT_RATE_115200, BIT_RATE_115200 );
// uart0_sendStr( "\nUART0 - USED TO PROGRAM THE MODULE\n" );
os_printf("\n===================\nUART1 - DEBUG OUPUT\n===================\n");
/* NOTE: PWM CANNOT BE USED SIMULTANEOUSLY WITH HW TIMER */
#if 0
/* ====================================== */
/* PWM */
/* ====================================== */
uint32 pwm_period = 1000;
uint32 pwm_duty[PWM_CHANNEL] = {0};
uint32 io_info[][3] = { {PWM_0_OUT_IO_MUX,PWM_0_OUT_IO_FUNC,PWM_0_OUT_IO_NUM},
{PWM_1_OUT_IO_MUX,PWM_1_OUT_IO_FUNC,PWM_1_OUT_IO_NUM},
};
/* PIN FUNCTION INIT FOR PWM OUTPUT */
pwm_init(pwm_period, pwm_duty, PWM_CHANNEL, io_info);
/* set pwm_duty cycle */
pwm_set_duty (14185, 0);
pwm_set_duty (22222, 1); // todo: explain why 22222 is the highest possible value
/* start PWM */
pwm_start(); // NOTE: PWM causes spikes in other GPIOs
#endif
/* ====================================== */
/* GPIO INTERRPUT */
/* ====================================== */
/* Set GPIO12 in GPIO mode */
PIN_FUNC_SELECT( PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12 );
/* Set GPIO12 as input */
GPIO_DIS_OUTPUT( GPIO_ID_PIN(12) );
/* Disable all GPIO interrupts */
ETS_GPIO_INTR_DISABLE();
/* Set a GPIO callback function */
ETS_GPIO_INTR_ATTACH( gpioCallback, NULL );
/* Configure the type of edge */
gpio_pin_intr_state_set( GPIO_ID_PIN(12), GPIO_PIN_INTR_ANYEDGE );
ETS_GPIO_INTR_ENABLE();
/* ====================================== */
/* SOFTWARE TIMER */
/* ====================================== */
// Set GPIO0 to output mode
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
//Set GPIO0 low
gpio_output_set(0, RELAY_PIN, RELAY_PIN, 0);
/* disarm timer */
os_timer_disarm((ETSTimer*)&some_timer);
/* set callback */
os_timer_setfn((ETSTimer*)&some_timer, (os_timer_func_t *) softwareTimerCallback, NULL);
/* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */
os_timer_arm((ETSTimer*)&some_timer, 10, 1);
/* ====================================== */
/* OS TASK */
/* ====================================== */
/* setup OS task */
// system_os_task(user_procTask, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen);
/* send a message to OS task (fire task) */
// system_os_post(user_procTaskPrio, 0, 0 );
/* ====================================== */
/* HARDWARE TIMER */
/* ====================================== */
/* The hardware timer is used to indicate when a complete IR message frame should have
* arrived in order to process the received data and calculate the IR command.
*
* It is configured in "one-shot" mode. It is started when the beginning of an
* IR message frame is detected and stopped after the complete message frame has been read.
* This means that the duration of the HW timer should be longer than the duration of
* the longest message frame. In the NEC IR tranmission protocol all message frames have
* a duration of approximately 67.5ms.
*/
/* load the HW TIMER */
uint32 ticks = usToTicks(70000); // 70ms
RTC_REG_WRITE(FRC1_LOAD_ADDRESS, ticks);
/* register callback function */
ETS_FRC_TIMER1_INTR_ATTACH( hwTimerCallback, NULL );
/* enable interrupts */
TM1_EDGE_INT_ENABLE();
ETS_FRC1_INTR_ENABLE();
/* don't start timer yet */
/* the timer is started inside the GPIO INT callback */
/* ====================================== */
/* UDP SERVER */
/* ====================================== */
/* usage: echo <data> | nc -wl -u <ip address> <port>
* example: echo "foo" | nc -w1 -u 192.168.1.187 7777 */
/* allocate space for server */
pUdpServer = (struct espconn *) os_zalloc(sizeof(struct espconn));
/* clear allocated memory */
ets_memset(pUdpServer, 0, sizeof(struct espconn));
/* create the server */
espconn_create(pUdpServer);
/* set the type of server */
pUdpServer->type = ESPCONN_UDP;
/* allocate memory for UDP settings */
pUdpServer->proto.udp = (esp_udp *) os_zalloc(sizeof(esp_udp));
/* set the port that the server will be listening to */
pUdpServer->proto.udp->local_port = 7777;
/* register the callback */
espconn_regist_recvcb(pUdpServer, udpServerRxCb);
/* start listening */
if (espconn_create(pUdpServer))
{
while (1) { os_printf("Error creating a UDP server\n"); }
}
/* ====================================== */
/* WIFI */
/* ====================================== */
wifi_set_opmode(STATION_MODE);
wifi_station_get_config_default(&stconf);
// os_strncpy((char*) stconf.ssid, "TP-LINK_2.4GHz_FC2E51", 32);
// os_strncpy((char*) stconf.password, "tonytony", 64);
os_strncpy((char*) stconf.ssid, "WLAN-PUB", 32);
os_strncpy((char*) stconf.password, "", 64);
// os_strncpy((char*) stconf.ssid, "MAD air", 32);
// os_strncpy((char*) stconf.password, "glioninlog", 64);
stconf.bssid_set = 0;
wifi_station_set_config(&stconf);
// /* ====================================== */
// /* WS2812 LED STRIP */
// /* ====================================== */
//
// /* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */
// ws2812_init();
//
// /* G R B */
// uint8_t ledout[] = {
// 0xff, 0x00, 0x00, //4th
//// 0xff, 0x00, 0x00, //3rd
//// 0x00, 0xff, 0x00, //2nd
//// 0x00, 0x00, 0xff, //1st
// };
//
//#if 0
// os_printf("\r\nB R G: %x %x %x\r\n", ledout[0], ledout[1],ledout[2]);
//#endif
//
// ws2812_push( ledout, sizeof( ledout ) );
/* ====================================== */
/* TCP CONNECTION */
/* ====================================== */
/* allocate space for server */
pTcpConn = (struct espconn *) os_zalloc(sizeof(struct espconn));
/* clear allocated memory */
ets_memset(pTcpConn, 0, sizeof(struct espconn));
/* set the type of connection */
pTcpConn->type = ESPCONN_TCP;
/* set state to NONE */
pTcpConn->state = ESPCONN_NONE;
/* allocate memory for TCP settings */
pTcpConn->proto.tcp = (esp_tcp *) os_zalloc(sizeof(esp_tcp));
/* set the port that the connection will be listening to */
pTcpConn->proto.tcp->local_port = espconn_port();
/* set the remote port and IP address */
pTcpConn->proto.tcp->remote_port = 80;
os_memcpy(pTcpConn->proto.tcp->remote_ip, server_ip_address, sizeof(server_ip_address));
/* register callbacks */
espconn_regist_connectcb(pTcpConn, tcpConnCb);
espconn_regist_reconcb(pTcpConn, tcpReconnCb);
/* disarm timer */
os_timer_disarm((ETSTimer*)&wifi_setup_timer);
/* set callback */
os_timer_setfn((ETSTimer*)&wifi_setup_timer, (os_timer_func_t *) wifiConnectTimerCb, NULL);
/* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */
os_timer_arm((ETSTimer*)&wifi_setup_timer, 5000, 1);
return;
}
FUN_ATTRIBUTE
void plug_power_change(void)
{
uint8 pin_state = GPIO_INPUT_GET(GPIO_ID_PIN(PLUG_POWR_PIN));
product_power_control(!pin_state);
}
void gpio_intr_handler(struct base_key_param **keys_param)
{
uint8 i;
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
uint8 gpio_id;
struct base_key_param * single_key = NULL;
PRINTF("Get into gpio_intr_handler, gpio_status:%u\n", gpio_status);
for(i = 0; i < KEY_MAX_NUM; i++)
{
single_key = keys_param[i];
if(single_key == NULL)
{
PRINTF("\r\nintr sinle_key is NULL, i:%d\r\n",i);
continue;
}
gpio_id = single_key->gpio_id;
PRINTF("\r\ngpio_id:%d, BIT(gpio_id):%d\r\n",gpio_id, BIT(gpio_id));
if(gpio_status & BIT(gpio_id))
{
PRINTF("\r\n key config start....\r\n");
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(gpio_id), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(gpio_id));
//if need to manage special gpio event, manage here
//example: manage key config wifi connect, need call config_key_init() first
if(i == 0)
{
if(single_key->level == 1)
{// 5s, restart & enter softap mode
PRINTF("\r\n sinle_key->level:%d....\r\n", single_key->level);
os_timer_disarm(&single_key->k_timer1);
os_timer_setfn(&single_key->k_timer1, (os_timer_func_t *)key_5s_cb,
single_key);
os_timer_arm(&single_key->k_timer1, LONG_PRESS_COUNT, 0);
single_key->level = 0;
gpio_pin_intr_state_set(GPIO_ID_PIN(gpio_id), GPIO_PIN_INTR_POSEDGE);
}
else
{
// 50ms, check if this is a real key up
PRINTF("\r\n50ms sinle_key->level:%d....\r\n", single_key->level);
os_timer_disarm(&single_key->k_timer2);
os_timer_setfn(&single_key->k_timer2, (os_timer_func_t *)key_50ms_cb,
single_key);
os_timer_arm(&single_key->k_timer2, 50, 0);
}
continue;
}
//other manage
}
}
}
/******************************************************************************
* FunctionName : i2c_master_getCL
* Description : Internal used function -
* get i2c SCL bit value
* Parameters : NONE
* Returns : uint8 - SCL bit value
*******************************************************************************/
LOCAL uint8 i2c_master_getCL(void)
{
uint8 scl_out;
scl_out = GPIO_INPUT_GET(GPIO_ID_PIN(pinSCL));
return scl_out;
}
/******************************************************************************
* FunctionName : i2c_master_getDC
* Description : Internal used function -
* get i2c SDA bit value
* Parameters : NONE
* Returns : uint8 - SDA bit value
*******************************************************************************/
LOCAL uint8 i2c_master_getDC(void)
{
return GPIO_INPUT_GET(GPIO_ID_PIN(pinSDA));
}
/* ICACHE_FLASH_ATTR macro: put functions in .irom0 segment in flash */
#define MESSAGE_QUEUE_DEPTH 1
static os_timer_t os_timer;
static os_event_t queue[MESSAGE_QUEUE_DEPTH];
__attribute__((unused)) static void ICACHE_FLASH_ATTR user_rf_preinit()
{
}
static void timer(__attribute__((unused)) void *param)
{
if (GPIO_REG_READ(GPIO_OUT_ADDRESS) & BIT2) {
GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 0);
} else {
GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 1);
}
}
static void ICACHE_FLASH_ATTR os_task(__attribute__((unused)) os_event_t *event)
{
os_delay_us(10);
}
void ICACHE_FLASH_ATTR user_init()
{
/* select GPIO2 function of pin 14
* (see ESP8266__Pin_List*.xlsx, ESP8266_Interface_GPIO*.pdf) */
gpio_init();
static void
ping_disableInterrupt(int8_t pin) {
if (pin>0){
gpio_pin_intr_state_set(GPIO_ID_PIN(pin), GPIO_PIN_INTR_DISABLE);
}
}
void ICACHE_FLASH_ATTR user_relay_init() {
PIN_FUNC_SELECT(relay_hardware.gpio_name, relay_hardware.gpio_func);
relay_state = GPIO_INPUT_GET(GPIO_ID_PIN(relay_hardware.gpio_id));
webserver_register_handler_callback(RELAY_URL, relay_handler);
device_register(NATIVE, 0, ESP8266, RELAY_URL, NULL, NULL);
}
bool DHTRead(DHT_Sensor *sensor, DHT_Sensor_Data* output)
{
int counter = 0;
int laststate = 1;
int i = 0;
int j = 0;
int checksum = 0;
int data[100];
data[0] = data[1] = data[2] = data[3] = data[4] = 0;
uint8_t pin = GPIO_ID_PIN(sensor->port);
// Wake up device, 250ms of high
GPIO_OUTPUT_SET(pin, 1);
sleepms(250);
// Hold low for 20ms
GPIO_OUTPUT_SET(pin, 0);
sleepms(20);
// High for 40ns
GPIO_OUTPUT_SET(pin, 1);
os_delay_us(40);
// Set DHT_PIN pin as an input
GPIO_DIS_OUTPUT(pin);
// wait for pin to drop?
while (GPIO_INPUT_GET(pin) == 1 && i < DHT_MAXCOUNT) {
os_delay_us(1);
i++;
}
if(i == DHT_MAXCOUNT)
{
DHT_DEBUG("DHT: Failed to get reading from GPIO%d, dying\r\n", pin);
return false;
}
// read data
for (i = 0; i < DHT_MAXTIMINGS; i++)
{
// Count high time (in approx us)
counter = 0;
while (GPIO_INPUT_GET(pin) == laststate)
{
counter++;
os_delay_us(1);
if (counter == 1000)
break;
}
laststate = GPIO_INPUT_GET(pin);
if (counter == 1000)
break;
// store data after 3 reads
if ((i>3) && (i%2 == 0)) {
// shove each bit into the storage bytes
data[j/8] <<= 1;
if (counter > DHT_BREAKTIME)
data[j/8] |= 1;
j++;
}
}
if (j >= 39) {
checksum = (data[0] + data[1] + data[2] + data[3]) & 0xFF;
DHT_DEBUG("DHT%s: %02x %02x %02x %02x [%02x] CS: %02x (GPIO%d)\r\n",
sensor->type==DHT11?"11":"22",
data[0], data[1], data[2], data[3], data[4], checksum, pin);
if (data[4] == checksum) {
// checksum is valid
output->temperature = scale_temperature(sensor->type, data);
output->humidity = scale_humidity(sensor->type, data);
//DHT_DEBUG("DHT: Temperature = %d *C, Humidity = %d %%\r\n", (int)(reading.temperature * 100), (int)(reading.humidity * 100));
DHT_DEBUG("DHT: Temperature*100 = %d *C, Humidity*100 = %d %% (GPIO%d)\n",
(int) (output->temperature * 100), (int) (output->humidity * 100), pin);
} else {
//DHT_DEBUG("Checksum was incorrect after %d bits. Expected %d but got %d\r\n", j, data[4], checksum);
DHT_DEBUG("DHT: Checksum was incorrect after %d bits. Expected %d but got %d (GPIO%d)\r\n",
j, data[4], checksum, pin);
return false;
}
} else {
//DHT_DEBUG("Got too few bits: %d should be at least 40\r\n", j);
DHT_DEBUG("DHT: Got too few bits: %d should be at least 40 (GPIO%d)\r\n", j, pin);
return false;
}
return true;
}
/******************************************************************************
* FunctionName : get_key_status
* Description : get single key status
* Parameters : single_key - single key pointer parameter
* Returns : none
*******************************************************************************/
BOOL
get_key_status(struct single_key_param *single_key)
{
return GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id));
}
int ICACHE_FLASH_ATTR set_gpio_mode(unsigned pin, unsigned mode, unsigned pull)
{
if (pin >= GPIO_PIN_NUM)
return -1;
if(pin == 0) {
if(mode == GPIO_INPUT)
gpio16_input_conf();
else
gpio16_output_conf();
return 1;
}
switch(pull) {
case GPIO_PULLUP:
// PIN_PULLDWN_DIS(pin_mux[pin]);
PIN_PULLUP_EN(pin_mux[pin]);
break;
case GPIO_PULLDOWN:
PIN_PULLUP_DIS(pin_mux[pin]);
// PIN_PULLDWN_EN(pin_mux[pin]);
break;
case GPIO_FLOAT:
PIN_PULLUP_DIS(pin_mux[pin]);
// PIN_PULLDWN_DIS(pin_mux[pin]);
break;
default:
PIN_PULLUP_DIS(pin_mux[pin]);
// PIN_PULLDWN_DIS(pin_mux[pin]);
break;
}
switch(mode) {
case GPIO_INPUT:
GPIO_DIS_OUTPUT(pin_num[pin]);
break;
case GPIO_OUTPUT:
ETS_GPIO_INTR_DISABLE();
#ifdef GPIO_INTERRUPT_ENABLE
pin_int_type[pin] = GPIO_PIN_INTR_DISABLE;
#endif
PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]);
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[pin]), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pin_num[pin]));
GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin]))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain;
ETS_GPIO_INTR_ENABLE();
break;
#ifdef GPIO_INTERRUPT_ENABLE
case GPIO_INT:
ETS_GPIO_INTR_DISABLE();
PIN_FUNC_SELECT(pin_mux[pin], pin_func[pin]);
GPIO_DIS_OUTPUT(pin_num[pin]);
gpio_register_set(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[pin])), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE)
| GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE)
| GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE));
ETS_GPIO_INTR_ENABLE();
break;
#endif
default:
break;
}
return 1;
}
void becomesOn(){
GPIO_OUTPUT_SET(GPIO_ID_PIN(gpio), 1);
}
LOCAL void ICACHE_FLASH_ATTR
user_link_led_timer_cb(void)
{
link_led_level = (~link_led_level) & 0x01;
GPIO_OUTPUT_SET(GPIO_ID_PIN(PLUG_LINK_LED_IO_NUM), link_led_level);
}
void becomesOff(){
GPIO_OUTPUT_SET(GPIO_ID_PIN(gpio), 0);
}
else
{
s->buffer.buffer_overflow = 1;
}
//wait for stop bit
os_delay_us(s->bit_time);
//done
}
//clear interrupt
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status);
// Reactivate interrupts for GPIO0
gpio_pin_intr_state_set(GPIO_ID_PIN(s->pin_rx.gpio_id), 3);
} else {
//clear interrupt, no matter from which pin
//otherwise, this interrupt will be called again forever
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status);
}
}
// Read data from buffer
uint8_t Softuart_Read(Softuart *s)
{
// Empty buffer?
if (s->buffer.receive_buffer_head == s->buffer.receive_buffer_tail)
return 0;
static uint8_t irom i2c_get_dc(void)
{
uint8_t sda_out;
sda_out = GPIO_INPUT_GET(GPIO_ID_PIN(I2C_MASTER_SDA_GPIO));
return sda_out;
}
void Softuart_Init(Softuart *s, uint16_t baudrate)
{
//disable rs485
s->is_rs485 = 0;
if(! _Softuart_Instances_Count) {
os_printf("SOFTUART initialize gpio\r\n");
//Initilaize gpio subsystem
gpio_init();
}
//set bit time
s->bit_time = (1000000 / baudrate);
os_printf("SOFTUART bit_time is %d\r\n",s->bit_time);
//init tx pin
if(!s->pin_tx.gpio_mux_name) {
os_printf("SOFTUART ERROR: Set tx pin (%d)\r\n",s->pin_tx.gpio_mux_name);
} else {
//enable pin as gpio
PIN_FUNC_SELECT(s->pin_tx.gpio_mux_name, s->pin_tx.gpio_func);
//set pullup (UART idle is VDD)
PIN_PULLUP_EN(s->pin_tx.gpio_mux_name);
//set high for tx idle
GPIO_OUTPUT_SET(GPIO_ID_PIN(s->pin_tx.gpio_id), 1);
os_delay_us(100000);
os_printf("SOFTUART TX INIT DONE\r\n");
}
//init rx pin
if(!s->pin_rx.gpio_mux_name) {
os_printf("SOFTUART ERROR: Set rx pin (%d)\r\n",s->pin_rx.gpio_mux_name);
} else {
//enable pin as gpio
PIN_FUNC_SELECT(s->pin_rx.gpio_mux_name, s->pin_rx.gpio_func);
//set pullup (UART idle is VDD)
PIN_PULLUP_EN(s->pin_rx.gpio_mux_name);
//set to input -> disable output
GPIO_DIS_OUTPUT(GPIO_ID_PIN(s->pin_rx.gpio_id));
//set interrupt related things
//disable interrupts by GPIO
ETS_GPIO_INTR_DISABLE();
//attach interrupt handler and a pointer that will be passed around each time
ETS_GPIO_INTR_ATTACH(Softuart_Intr_Handler, s);
//not sure what this does... (quote from example):
// void gpio_register_set(uint32 reg_id, uint32 value);
//
// From include file
// Set the specified GPIO register to the specified value.
// This is a very general and powerful interface that is not
// expected to be used during normal operation. It is intended
// mainly for debug, or for unusual requirements.
//
// All people repeat this mantra but I don't know what it means
//
gpio_register_set(GPIO_PIN_ADDR(s->pin_rx.gpio_id),
GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) |
GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) |
GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE));
//clear interrupt handler status, basically writing a low to the output
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(s->pin_rx.gpio_id));
//enable interrupt for pin on any edge (rise and fall)
//@TODO: should work with ANYEDGE (=3), but complie error
gpio_pin_intr_state_set(GPIO_ID_PIN(s->pin_rx.gpio_id), 3);
//globally enable GPIO interrupts
ETS_GPIO_INTR_ENABLE();
os_printf("SOFTUART RX INIT DONE\r\n");
}
//add instance to array of instances
_Softuart_GPIO_Instances[s->pin_rx.gpio_id] = s;
_Softuart_Instances_Count++;
os_printf("SOFTUART INIT DONE\r\n");
}
//Main routine. Initialize stdout, the I/O and the webserver and we're done.
void user_init(void) {
// my stuff
dBR_BOILER_SET=65; // default setting 65C boiler temperature on reboot
dBR_TEMP_ROOM_SET=18; // default setting 18C room temperature on reboot
dBR_HUMIDITY_SET=60; // default setting 65% humidity target on reboot
dBR_MODE=2; // default BR MODE is AUTO
dDEVICE_MODE=1; // This mode defines if device uses remote (MQTT) management or uses local logics - 0 for remote, 1 for local mode. DEFAULT is 0 - remote
// HTTPD
stdoutInit();
ioInit();
httpdInit(builtInUrls, 80);
//MQTT
uart_init(115200, 115200);
CFG_Load();
sleepms(1000);
MQTT_InitConnection(&mqttClient, sysCfg.mqtt_host, sysCfg.mqtt_port, SEC_NONSSL);
//MQTT_InitConnection(&mqttClient, "192.168.11.122", 1880, 0);
MQTT_InitClient(&mqttClient, sysCfg.device_id, sysCfg.mqtt_user, sysCfg.mqtt_pass, sysCfg.mqtt_keepalive, 1);
//MQTT_InitClient(&mqttClient, "client_id", "user", "pass", 120, 1);
// MQTT_InitLWT(&mqttClient, "/lwt", "offline", 0, 0);
MQTT_OnConnected(&mqttClient, mqttConnectedCb);
MQTT_OnDisconnected(&mqttClient, mqttDisconnectedCb);
MQTT_OnPublished(&mqttClient, mqttPublishedCb);
MQTT_OnData(&mqttClient, mqttDataCb);
INFO("device_ID:%s\r\n",sysCfg.device_id);
INFO("MQTTHOST:%s\r\n",sysCfg.mqtt_host);
//DS18B20 timers
os_timer_disarm(&ds18b20_timer);
os_timer_setfn(&ds18b20_timer, (os_timer_func_t *)ds18b20_cb, (void *)0);
os_timer_arm(&ds18b20_timer, DELAY, 1);
// DHT22 initialize
DHTInit(DHT22, DELAY);
os_timer_disarm(&dht22_timer);
os_timer_setfn(&dht22_timer, (os_timer_func_t *)dht22_cb, (void *)0);
os_timer_arm(&dht22_timer, DELAY, 1);
// INPUT PIN initialize
ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts
ETS_GPIO_INTR_ATTACH(read_input_pin, 13); // GPIO13 interrupt handler
PIN_FUNC_SELECT(PIN_GPIO13_MUX, PIN_GPIO13_FUNC);
gpio_output_set(0, 0, 0, BIT13); // Set GPIO13 as input
PIN_PULLUP_EN(PIN_GPIO13_MUX); // Enable pullup
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(13)); // Clear GPIO12 status
gpio_pin_intr_state_set(GPIO_ID_PIN(13), GPIO_PIN_INTR_NEGEDGE); // Interrupt on NEGATIVE GPIO13 edge
ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts
// INFO("Input pin INITIALIZED ! ! !");
// initialize GPIO12
PIN_FUNC_SELECT(PIN_GPIO12_MUX, PIN_GPIO12_FUNC);
GPIO_OUTPUT_SET(PIN_GPIO12, 0);
// INFO("GPIO12 set to OFF\r\n");
// initialize GPIO5
GPIO_OUTPUT_SET(PIN_GPIO5, 0);
// INFO("GPIO5 set to OFF\r\n");
// initialize GPIO14
PIN_FUNC_SELECT(PIN_GPIO14_MUX, PIN_GPIO14_FUNC);
GPIO_OUTPUT_SET(PIN_GPIO14, 0);
// INFO("GPIO14 set to OFF\r\n");
WIFI_Connect(sysCfg.sta_ssid, sysCfg.sta_pwd, wifiConnectCb);
os_printf("\nReady\n");
}
