// Perform the onewire reset function. We will wait up to 250uS for
// the bus to come high, if it doesn't then it is broken or shorted
// and we return a 0;
// Returns 1 if a device asserted a presence pulse, 0 otherwise.
uint32 ICACHE_FLASH_ATTR onewire_reset() {
uint32 result;
uint8 retries = 125;
// Disable output on the pin.
GPIO_DIS_OUTPUT(ONEWIRE_PIN);
// Wait for the bus to get high (which it should because of the pull-up resistor).
do {
if (--retries == 0) {
return 0;
}
os_delay_us(2);
} while (!GPIO_INPUT_GET(ONEWIRE_PIN));
// Transmit the reset pulse by pulling the bus low for at least 480 us.
GPIO_OUTPUT_SET(ONEWIRE_PIN, 0);
os_delay_us(500);
// Release the bus, and wait, then check for a presence pulse, which should start 15-60 us after the reset, and will last 60-240 us.
// So 65us after the reset the bus must be high.
GPIO_DIS_OUTPUT(ONEWIRE_PIN);
os_delay_us(65);
result = !GPIO_INPUT_GET(ONEWIRE_PIN);
// After sending the reset pulse, the master (we) must wait at least another 480 us.
os_delay_us(490);
return result;
}
void restoreFactorySettings() {
wifi_station_disconnect();
wifi_set_opmode(0x3); //reset to STA+AP mode
struct softap_config apConfig;
wifi_softap_get_config(&apConfig);
os_strncpy((char*)apConfig.ssid, "smartswitch", 18);
apConfig.authmode = 0; //Disable security
wifi_softap_set_config(&apConfig);
struct station_config stconf;
os_strncpy((char*)stconf.ssid, "", 2);
os_strncpy((char*)stconf.password, "", 2);
wifi_station_set_config(&stconf);
OLED_CLS();
OLED_Print(2, 0, "RESET", 1);
os_printf("Reset completed. Restarting system...\n");
ioOutput(0, GPIO_OUTPUT1);
ioOutput(0, GPIO_OUTPUT2);
while (!GPIO_INPUT_GET(GPIO_BUTTON1)) { os_printf("."); };
while (!GPIO_INPUT_GET(GPIO_BUTTON2)) { os_printf("."); };
system_restart();
}
LOCAL void ICACHE_FLASH_ATTR handle_pin_press() {
console_printf("TIMER EXECUTED\n");
if(button_counter==1){
if(!GPIO_INPUT_GET(PIN_GPIO13)){ // button is pressed once and is still pressed after the timeout
MQTT_Publish(&mqttClient,BR_MODE,"2",1,0,0); // Set overall MODE to OFF
GPIO_OUTPUT_SET(PIN_GPIO5, 0);
MQTT_Publish(&mqttClient,PIN_GPIO5_TOPIC,"OFF",3,0,0);
GPIO_OUTPUT_SET(PIN_GPIO12, 0);
MQTT_Publish(&mqttClient,PIN_GPIO12_TOPIC,"OFF",3,0,0);
GPIO_OUTPUT_SET(PIN_GPIO14, 0);
MQTT_Publish(&mqttClient,PIN_GPIO14_TOPIC,"OFF",3,0,0);
button_counter=0;
}
}
switch(button_counter){
case 1:
if(!GPIO_INPUT_GET(PIN_GPIO5)){
console_printf("FAN STARTED BY BUTTON. Only 1 press detected\n");
GPIO_OUTPUT_SET(PIN_GPIO5, 1);
MQTT_Publish(&mqttClient,PIN_GPIO5_TOPIC,"ON",2,0,0);
MQTT_Publish(&mqttClient,BR_MODE,"4",1,0,0);
} else {
console_printf("FAN STOPPED BY BUTTON. Only 1 press detected\n");
GPIO_OUTPUT_SET(PIN_GPIO5, 0);
MQTT_Publish(&mqttClient,PIN_GPIO5_TOPIC,"OFF",3,0,0);
}
break;
/* GPIO_OUTPUT_SET(PIN_GPIO5, curr_input_pin_state);
MQTT_Publish(&mqttClient,PIN_GPIO13_TOPIC,"ON",2,0,0);
MQTT_Publish(&mqttClient,PIN_GPIO5_TOPIC,"ON",2,0,0);/**/
case 2:
if(!GPIO_INPUT_GET(PIN_GPIO14)){
console_printf("BOILER STARTED BY BUTTON. 2 presses detected\n");
GPIO_OUTPUT_SET(PIN_GPIO14, 1);
MQTT_Publish(&mqttClient,PIN_GPIO14_TOPIC,"ON",2,0,0);
} else {
console_printf("BOILER STOPPED BY BUTTON. 2 presses detected\n");
GPIO_OUTPUT_SET(PIN_GPIO14, 0);
MQTT_Publish(&mqttClient,PIN_GPIO14_TOPIC,"OFF",3,0,0);
MQTT_Publish(&mqttClient,BR_MODE,"2",1,0,0);
}
break;
/* case 3:
if(!GPIO_INPUT_GET(PIN_GPIO12)){
console_printf("HEATING STARTED BY BUTTON. 3 presses detected\n");
GPIO_OUTPUT_SET(PIN_GPIO12, 1);
MQTT_Publish(&mqttClient,PIN_GPIO12_TOPIC,"OFF",3,0,0);
} else {
console_printf("HEATING STOPPED BY BUTTON. 3 presses detected\n");
GPIO_OUTPUT_SET(PIN_GPIO12, 0);
MQTT_Publish(&mqttClient,PIN_GPIO12_TOPIC,"OFF",3,0,0);
}
break;/**/
}
button_counter=0; // zero the counter
os_timer_disarm(&input_pin_timer); // Disarm input pin timer
}
void
supla_esp_gpio_check_switch_cfgbtn(void *timer_arg) {
char v = GPIO_INPUT_GET(GPIO_ID_PIN((int)timer_arg));
if ( v != switch_cfgbtn_last_state ) {
if ( switch_cfgbtn_counter == 0 ) {
os_timer_disarm(&supla_gpio_timer5);
os_timer_setfn(&supla_gpio_timer5, supla_esp_gpio_reset_cfg_counter, NULL);
os_timer_arm (&supla_gpio_timer5, 10000, false);
}
switch_cfgbtn_counter++;
supla_log(LOG_DEBUG, "Switch counter: %i", switch_cfgbtn_counter);
if ( switch_cfgbtn_counter >= 10 ) {
supla_esg_gpio_cfg_pressed();
} else {
supla_esg_gpio_manual_pressed();
}
switch_cfgbtn_last_state = v;
}
switch_cfgbtn_state_check = 0;
}
/******************************************************************************
* FunctionName : user_sensor_init
* Description : init sensor 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 (wifi_get_opmode() != STATIONAP_MODE) {
if (active == 1) {
user_sensor_deep_sleep_init(SENSOR_CONNECT_TIME / 1000);//exceed SENSOR_CONNECT_TIME,sleep directly
} else {
user_sensor_deep_sleep_init(SENSOR_CONNECT_TIME / 1000);//exceed SENSOR_CONNECT_TIME,sleep directly
}
}
}
static void ICACHE_RAM_ATTR platform_gpio_intr_dispatcher (void *dummy){
uint32 j=0;
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
uint32 now = system_get_time();
UNUSED(dummy);
#ifdef GPIO_INTERRUPT_HOOK_ENABLE
if (gpio_status & platform_gpio_hook.all_bits) {
for (j = 0; j < platform_gpio_hook.count; j++) {
if (gpio_status & platform_gpio_hook.entry[j].bits)
gpio_status = (platform_gpio_hook.entry[j].func)(gpio_status);
}
}
#endif
/*
* gpio_status is a bit map where bit 0 is set if unmapped gpio pin 0 (pin3) has
* triggered the ISR. bit 1 if unmapped gpio pin 1 (pin10=U0TXD), etc. Since this
* is the ISR, it makes sense to optimize this by doing a fast scan of the status
* and reverse mapping any set bits.
*/
for (j = 0; gpio_status>0; j++, gpio_status >>= 1) {
if (gpio_status&1) {
int i = pin_num_inv[j];
if (pin_int_type[i]) {
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(j), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(j));
uint32 level = 0x1 & GPIO_INPUT_GET(GPIO_ID_PIN(j));
task_post_high (gpio_task_handle, (now << 8) + (i<<1) + level);
// We re-enable the interrupt when we execute the callback
}
}
}
}
static void ICACHE_FLASH_ATTR resetButtonTimerCallback(void *data)
{
static int previousState = 1;
static int matchingSampleCount = 0;
static int buttonPressCount = 0;
static uint32_t lastButtonTime;
int newState = GPIO_INPUT_GET(RESET_BUTTON_PIN);
if (newState != previousState)
matchingSampleCount = 0;
else if (matchingSampleCount < RESET_BUTTON_THRESHOLD) {
if (++matchingSampleCount == RESET_BUTTON_THRESHOLD) {
if (newState != resetButtonState) {
resetButtonState = newState;
if (resetButtonState == 0) {
uint32_t buttonTime = system_get_time() / 1000;
//os_printf("Reset button press: count %d, last %u, this %u\n", buttonPressCount, (unsigned)lastButtonTime, (unsigned)buttonTime);
if (buttonPressCount == 0 || buttonTime - lastButtonTime > RESET_BUTTON_PRESS_DELTA)
buttonPressCount = 1;
else if (++buttonPressCount == RESET_BUTTON_PRESS_COUNT) {
os_printf("Entering STA+AP mode\n");
wifi_set_opmode(STATIONAP_MODE);
buttonPressCount = 0;
}
lastButtonTime = buttonTime;
}
}
}
}
previousState = newState;
}
static void ICACHE_FLASH_ATTR on_timeout(void *arg)
{
static uint8_t lastPin0 = 0xFF, lastPin1 = 0xFF;
uint8_t pin0 = GPIO_INPUT_GET(PIN0);
uint8_t pin1 = GPIO_INPUT_GET(PIN1);
if ((pin0 != lastPin0 || pin1 != lastPin1) && client != NULL) {
uint8_t data[2];
data[0] = pin0 ? '1' : '0';
data[1] = pin1 ? '1' : '0';
MQTT_Publish(client, settings.mqttTopic, data, 2, 0, 1);
lastPin0 = pin0;
lastPin1 = pin1;
}
}
/******************************************************************************
* FunctionName : i2c_master_getDC
* Description : Internal used function -
* get i2c SDA bit value
* Parameters : NONE
* Returns : uint8 - SDA bit value
*******************************************************************************/
LOCAL uint8 ICACHE_FLASH_ATTR
i2c_master_getDC(void)
{
uint8 sda_out;
sda_out = GPIO_INPUT_GET(GPIO_ID_PIN(I2C_MASTER_SDA_GPIO));
return sda_out;
}
// digitalRead([pin])
void ICACHE_FLASH_ATTR
at_setupReadPinCmd(uint8_t id, char *pPara)
{
int result = 0, err = 0, flag = 0;
uint8 buffer[32] = {0};
pPara++; // skip '='
//get the first parameter (uint8_t)
// digit
flag = at_get_next_int_dec(&pPara, &result, &err);
// flag must be true because there are more parameters
//if ((flag == FALSE) && (result > 0) )
if (err > 0)
{
at_port_print("Bad input");
at_response_error();
return;
}
uint8_t pin = result;
// Don't go any further if the pin is un-usable or non-existant
if (!pinValid(pin))
{
at_response_error();
return;
}
uint8_t value = GPIO_INPUT_GET(pin);
os_sprintf(buffer, "%d\r\n", value);
at_port_print(buffer);
at_response_ok();
}
LOCAL void ICACHE_FLASH_ATTR dht22_cb(void *arg)
{
struct dht_sensor_data* r = DHTRead();
int tempLength=0;
int humLength=0;
float lastTemp = r->temperature;
float lastHum = r->humidity;
if(r->success&&lastTemp>-30&&lastHum>0)
{
//TRANSFORMATION HERE
console_printf("DHT22/Temperature: %d.%d *C, Humidity: %d.%d %%\r\n", (int)(lastTemp),(int)((lastTemp - (int)lastTemp)*100), (int)(lastHum),(int)((lastHum - (int)lastHum)*100));
os_sprintf(DHT22_Temperature,"%d.%d", (int)(lastTemp),(int)((lastTemp - (int)lastTemp)*100));
os_sprintf(DHT22_Humidity,"%d.%d", (int)(lastHum),(int)((lastHum - (int)lastHum)*100));
if(lastTemp>=0) {
if(lastTemp>9)
tempLength=4;
else
tempLength=3;
} else tempLength=5; // assumption - bathroom temperature should not fall under -9 :P
if(lastHum>9) humLength=2;
else if (lastHum==100) humLength=3;
else humLength=1;
// MQTT PUBLISH HERE
MQTT_Publish(&mqttClient,DHT22_MQTT_Temperature,DHT22_Temperature,tempLength,0,0);
MQTT_Publish(&mqttClient,DHT22_MQTT_Humidity,DHT22_Humidity,humLength,0,0);
// MANUAL MODE LOGICS HERE
if (dDEVICE_MODE){
// maintain currently set humidity
if(lastHum<dBR_HUMIDITY_SET&&GPIO_INPUT_GET(PIN_GPIO5)&&!GPIO_INPUT_GET(PIN_GPIO13)) {
GPIO_OUTPUT_SET(PIN_GPIO5, 0);
} else if ((lastHum>dBR_HUMIDITY_SET+7)&&!GPIO_INPUT_GET(PIN_GPIO5)) {
GPIO_OUTPUT_SET(PIN_GPIO5,1);
}
// maintain currently set bathroom temperature
if(lastTemp>=dBR_TEMP_ROOM_SET&&GPIO_INPUT_GET(PIN_GPIO12)){
GPIO_OUTPUT_SET(PIN_GPIO12,0);
} else if ((lastTemp<dBR_TEMP_ROOM_SET-1)&&!GPIO_INPUT_GET(PIN_GPIO12)) {
GPIO_OUTPUT_SET(PIN_GPIO12,1);
}
}
}
else
{
console_printf("Error reading temperature and humidity\r\n");
}
}
void ICACHE_FLASH_ATTR user_btn_short_press()
{
os_printf("ON SHORT PRESS\n");
uint32 iRet = 100;
iRet = GPIO_INPUT_GET(14);
os_printf("OUT: [%d]\n", iRet);
}
esp_comm_gpio_hold_t bootloader_common_check_long_hold_gpio(uint32_t num_pin, uint32_t delay_sec)
{
gpio_pad_select_gpio(num_pin);
if (GPIO_PIN_MUX_REG[num_pin]) {
PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[num_pin]);
}
gpio_pad_pullup(num_pin);
uint32_t tm_start = esp_log_early_timestamp();
if (GPIO_INPUT_GET(num_pin) == 1) {
return GPIO_NOT_HOLD;
}
do {
if (GPIO_INPUT_GET(num_pin) != 0) {
return GPIO_SHORT_HOLD;
}
} while (delay_sec > ((esp_log_early_timestamp() - tm_start) / 1000L));
return GPIO_LONG_HOLD;
}
void
supla_esp_gpio_check_inputs(void *timer_arg) {
#ifdef INPUT_PORT1
char i1 = GPIO_INPUT_GET(GPIO_ID_PIN(INPUT_PORT1));
if ( i1 != input1_last_state ) {
char _input1_last_state = input1_last_state;
input1_last_state = i1;
#ifdef RELAY1_ELLOCK_MEM
if ( i1 == 1 && _input1_last_state == 0 ) {
ellock_input1_state = 1;
}
if ( i1 == 1 ) {
i1 = ellock_input1_state;
};
#endif
#if defined(__BOARD_rs_module) || defined(__BOARD_rs_module_wroom) || defined(__BOARD_jangoe_rs)
supla_esp_channel_value_changed(1, i1 == 1 ? 1 : 0);
#else
supla_esp_channel_value_changed(2, i1 == 1 ? 1 : 0);
#endif
}
#endif
#ifdef INPUT_PORT2
char i2 = GPIO_INPUT_GET(GPIO_ID_PIN(INPUT_PORT2));
if ( i2 != input2_last_state ) {
input2_last_state = i2;
supla_esp_channel_value_changed(3, i2 == 1 ? 1 : 0);
}
#endif
}
void pb1Transmit(){
char tempreg[200];
os_sprintf(tempreg, MQTT_TOPICIN, system_get_chip_id());
if(GPIO_INPUT_GET(4)){
MQTT_Publish(&mqttClient, tempreg, "1-1", strlen("1-1"), 0, 0);
} else {
MQTT_Publish(&mqttClient, tempreg, "1-0", strlen("1-0"), 0, 0);
}
}
//
// Read a bit. Port and bit is used to cut lookup time and provide
// more certain timing.
//
uint32 ICACHE_FLASH_ATTR onewire_read_bit(void) {
uint32 r;
GPIO_OUTPUT_SET(ONEWIRE_PIN, 0);
os_delay_us(3);
GPIO_DIS_OUTPUT(ONEWIRE_PIN);
os_delay_us(10);
r = GPIO_INPUT_GET(ONEWIRE_PIN);
os_delay_us(53);
return r;
}
int supla_ds18b20_read_bit(void)
{
int r;
GPIO_OUTPUT_SET( supla_w1_pin, 0 );
os_delay_us(3);
GPIO_DIS_OUTPUT( supla_w1_pin );
os_delay_us(10);
r = GPIO_INPUT_GET( supla_w1_pin );
os_delay_us(53);
return r;
}
int ICACHE_FLASH_ATTR gpio_read(unsigned pin)
{
if (pin >= GPIO_PIN_NUM)
return -1;
if(pin == 0){
// gpio16_input_conf();
return 0x1 & gpio16_input_get();
}
// GPIO_DIS_OUTPUT(pin_num[pin]);
return 0x1 & GPIO_INPUT_GET(GPIO_ID_PIN(pin_num[pin]));
}
//Template code for the counter on the index page.
int ICACHE_FLASH_ATTR tplCounter(HttpdConnData *connData, char *token, void **arg) {
char buff[128];
if (token==NULL) return HTTPD_CGI_DONE;
if (os_strcmp(token, "counter")==0) {
hitCounter++;
os_sprintf(buff, "%s", GPIO_INPUT_GET(PIRGPIO) == 0 ? "no" : "some" );
}
httpdSend(connData, buff, -1);
return HTTPD_CGI_DONE;
}
/******************************************************************************
* FunctionName : key_5s_cb
* Description : long press 5s timer callback
* Parameters : single_key_param *single_key - single key parameter
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR key_5s_cb(struct single_key_param *single_key) {
os_timer_disarm(&single_key->key_5s);
// low, then restart
if (0 == GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id))) {
single_key->is_long = 1;
if (single_key->long_press) {
single_key->long_press();
}
}
}
void ICACHE_FLASH_ATTR BtnTimer(void *arg) {
static int resetCnt=0;
if (GPIO_INPUT_GET(BTNGPIO)) {
resetCnt++;
}
if (resetCnt>=3) { //3 sec pressed
os_printf("\nAlarm Went off");
os_timer_arm(&Alarmtimer, 250, 1);
alarmstate = 0;
resetCnt=0;
}
}
/******************************************************************************
* FunctionName : key_5s_cb
* Description : long press 5s timer callback
* Parameters : single_key_param *single_key - single key parameter
* Returns : none
*******************************************************************************/
LOCAL void
key_5s_cb(struct single_key_param *single_key)
{
os_timer_disarm(&single_key->key_5s);
//check this gpio pin state
if (0 == GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id))) {
//this gpio has been in low state for 5s, then call long_press function
if (single_key->long_press) {
single_key->long_press();
}
}
}
void dcf_read_timer_cb(void)
{
// Inverted signal, add to low count (lc) when pin is true
if (GPIO_INPUT_GET(2)) {
dcf_lc++;
if (dcf_decoder_readjust) {
dcf_decode_timer_adjust();
dcf_decoder_readjust = false;
}
} else
dcf_hc++;
}
/**
* Uniform way of getting GPIO input value. Handles GPIO 0-16.
* The pin must be initiated with easygpio_pinMode() so that the pin mux is setup as a gpio in the first place.
* If you know that you won't be using GPIO16 then you'd better off by just using GPIO_INPUT_GET().
*/
uint8_t
easygpio_inputGet(uint8_t gpio_pin) {
if (16==gpio_pin) {
return (READ_PERI_REG(RTC_GPIO_IN_DATA) & 1UL);
} else {
#ifdef EASYGPIO_USE_GPIO_INPUT_GET
return GPIO_INPUT_GET(GPIO_ID_PIN(gpio_pin));
#else
// this does *not* work, maybe GPIO_IN_ADDRESS is the wrong address
return ((GPIO_REG_READ(GPIO_IN_ADDRESS) > gpio_pin) & 1UL);
#endif
}
}
/******************************************************************************
* FunctionName : key_5s_cb
* Description : long press 5s timer callback
* Parameters : single_key_param *single_key - single key parameter
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
key_5s_cb(struct single_key_param *single_key)
{
os_printf("-%s-%s \r\n", __FILE__, __func__);
os_timer_disarm(&single_key->key_long);
// low, then restart
if (0 == GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id))) {
if (single_key->long_press) {
single_key->long_press();
}
}
}
static void ICACHE_RAM_ATTR platform_gpio_intr_dispatcher (void *dummy){
uint32 j=0;
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
uint32 now = system_get_time();
UNUSED(dummy);
#ifdef GPIO_INTERRUPT_HOOK_ENABLE
if (gpio_status & platform_gpio_hook.all_bits) {
for (j = 0; j < platform_gpio_hook.count; j++) {
if (gpio_status & platform_gpio_hook.entry[j].bits)
gpio_status = (platform_gpio_hook.entry[j].func)(gpio_status);
}
}
#endif
/*
* gpio_status is a bit map where bit 0 is set if unmapped gpio pin 0 (pin3) has
* triggered the ISR. bit 1 if unmapped gpio pin 1 (pin10=U0TXD), etc. Since this
* is the ISR, it makes sense to optimize this by doing a fast scan of the status
* and reverse mapping any set bits.
*/
for (j = 0; gpio_status>0; j++, gpio_status >>= 1) {
if (gpio_status&1) {
int i = pin_num_inv[j];
if (pin_int_type[i]) {
uint16_t diff = pin_counter[i].seen ^ pin_counter[i].reported;
pin_counter[i].seen = 0x7fff & (pin_counter[i].seen + 1);
if (INTERRUPT_TYPE_IS_LEVEL(pin_int_type[i])) {
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(j), GPIO_PIN_INTR_DISABLE);
}
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(j));
if (diff == 0 || diff & 0x8000) {
uint32 level = 0x1 & GPIO_INPUT_GET(GPIO_ID_PIN(j));
if (!task_post_high (gpio_task_handle, (now << 8) + (i<<1) + level)) {
// If we fail to post, then try on the next interrupt
pin_counter[i].seen |= 0x8000;
}
// We re-enable the interrupt when we execute the callback (if level)
}
} else {
// this is an unexpected interrupt so shut it off for now
gpio_pin_intr_state_set(GPIO_ID_PIN(j), GPIO_PIN_INTR_DISABLE);
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(j));
}
}
}
}
static void ICACHE_FLASH_ATTR resetBtnTimerCb(void *arg) {
static int resetCnt=0;
if (!GPIO_INPUT_GET(BTNGPIO)) {
resetCnt++;
} else {
if (resetCnt>=6) { //3 sec pressed
wifi_station_disconnect();
wifi_set_opmode(0x3); //reset to AP+STA mode
os_printf("Reset to AP mode. Restarting system...\n");
system_restart();
}
resetCnt=0;
}
}
int platform_gpio_read( unsigned pin )
{
// NODE_DBG("Function platform_gpio_read() is called. pin:%d\n",GPIO_ID_PIN(pin_num[pin]));
if (pin >= NUM_GPIO)
return -1;
if(pin == 0){
// gpio16_input_conf();
return 0x1 & gpio16_input_get();
}
// GPIO_DIS_OUTPUT(pin_num[pin]);
return 0x1 & GPIO_INPUT_GET(GPIO_ID_PIN(pin_num[pin]));
}
void supla_ds18b20_reset(void)
{
uint8_t retries = 125;
GPIO_DIS_OUTPUT( supla_w1_pin );
do {
if (--retries == 0) return;
os_delay_us(2);
} while ( !GPIO_INPUT_GET( supla_w1_pin ));
GPIO_OUTPUT_SET( supla_w1_pin, 0 );
os_delay_us(480);
GPIO_DIS_OUTPUT( supla_w1_pin );
os_delay_us(480);
}
FUN_ATTRIBUTE
char * get_plug_state(void)
{
#define MSG "(state \"power\" 256 \"timer\" 4294967296 \"timertodo\" 256\")"
uint8 state = GPIO_INPUT_GET(GPIO_ID_PIN(PLUG_POWR_PIN));
char *msg = (char *)os_zalloc(sizeof(MSG));
if (msg == NULL)
{
return NULL;
}
sprintf(msg, "(state \"power\" %u \"timer\" 0 \"timertodo\" 0)", state);
return msg;
}