void ICACHE_FLASH_ATTR init_GPIOs_intr(void)
{
if(GPIO_TEST1 == GPIO_TEST2 || GPIO_TEST1 > 15 || GPIO_TEST1 > 15) {
GPIO_TEST1 = 4;
GPIO_TEST2 = 5;
}
// ets_isr_mask(1 << ETS_GPIO_INUM); // запрет прерываний GPIOs
// чтение пользовательских констант (0 < idx < 4) из записей в Flash
GPIO_INT_Counter1 = read_user_const(1);
GPIO_INT_Counter2 = read_user_const(2);
system_os_task(task_GPIOs_intr, GPIOs_intr_TASK_PRIO, GPIOs_intr_taskQueue, GPIOs_intr_TASK_QUEUE_LEN);
uint32 pins_mask = (1<<GPIO_TEST1) | (1<<GPIO_TEST2);
gpio_output_set(0,0,0, pins_mask); // настроить GPIOx на ввод
set_gpiox_mux_func_ioport(GPIO_TEST1); // установить функцию GPIOx в режим порта i/o
set_gpiox_mux_func_ioport(GPIO_TEST2); // установить функцию GPIOx в режим порта i/o
// GPIO_ENABLE_W1TC = pins_mask; // GPIO OUTPUT DISABLE отключить вывод в портах
ets_isr_attach(ETS_GPIO_INUM, GPIOs_intr_handler, NULL);
gpio_pin_intr_state_set(GPIO_TEST1, GPIO_PIN_INTR_ANYEDGE); // GPIO_PIN_INTR_POSEDGE | GPIO_PIN_INTR_NEGEDGE ?
gpio_pin_intr_state_set(GPIO_TEST2, GPIO_PIN_INTR_ANYEDGE); // GPIO_PIN_INTR_POSEDGE | GPIO_PIN_INTR_NEGEDGE ?
// разрешить прерывания GPIOs
GPIO_STATUS_W1TC = pins_mask;
ets_isr_unmask(1 << ETS_GPIO_INUM);
GPIO_INTR_INIT = 1;
GPIO_INT_init_flg = 1;
os_printf("GPIOs_intr init (%d,%d) ", GPIO_TEST1, GPIO_TEST2);
}
void supla_esp_gpio_init_led(void) {
ETS_GPIO_INTR_DISABLE();
#ifdef LED_RED_PORT
#if LED_RED_PORT != 16
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(LED_RED_PORT));
gpio_pin_intr_state_set(GPIO_ID_PIN(LED_RED_PORT), GPIO_PIN_INTR_DISABLE);
gpio_output_set(0, GPIO_ID_PIN(LED_RED_PORT), GPIO_ID_PIN(LED_RED_PORT), 0);
#endif
#endif
#ifdef LED_GREEN_PORT
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(LED_GREEN_PORT));
gpio_pin_intr_state_set(GPIO_ID_PIN(LED_GREEN_PORT), GPIO_PIN_INTR_DISABLE);
gpio_output_set(0, GPIO_ID_PIN(LED_GREEN_PORT), GPIO_ID_PIN(LED_GREEN_PORT), 0);
#endif
#ifdef LED_BLUE_PORT
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(LED_BLUE_PORT));
gpio_pin_intr_state_set(GPIO_ID_PIN(LED_BLUE_PORT), GPIO_PIN_INTR_DISABLE);
gpio_output_set(0, GPIO_ID_PIN(LED_BLUE_PORT), GPIO_ID_PIN(LED_BLUE_PORT), 0);
#endif
ETS_GPIO_INTR_ENABLE();
}
/******************************************************************************
* FunctionName : key_intr_handler
* Description : key interrupt handler
* Parameters : key_param *keys - keys parameter, which inited by key_init_single
* Returns : none
*******************************************************************************/
LOCAL void
key_intr_handler(struct keys_param *keys)
{
uint8 i;
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
os_printf("-%s-%s \r\n", __FILE__, __func__);
for (i = 0; i < keys->key_num; i++) {
if (gpio_status & BIT(keys->single_key[i]->gpio_id)) {
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(keys->single_key[i]->gpio_id));
if (keys->single_key[i]->key_level == 1) {
// 5s, restart & enter softap mode
os_timer_disarm(&keys->single_key[i]->key_long);
os_timer_setfn(&keys->single_key[i]->key_long, (os_timer_func_t *)key_5s_cb, keys->single_key[i]);
os_timer_arm(&keys->single_key[i]->key_long, keys->single_key[i]->longDelay, 0);
keys->single_key[i]->key_level = 0;
gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_POSEDGE);
} else {
// 50ms, check if this is a real key up
os_timer_disarm(&keys->single_key[i]->key_short);
os_timer_setfn(&keys->single_key[i]->key_short, (os_timer_func_t *)key_50ms_cb, keys->single_key[i]);
os_timer_arm(&keys->single_key[i]->key_short, keys->single_key[i]->shortDelay, 0);
}
}
}
}
LOCAL int ICACHE_FLASH_ATTR dhgpio_set_int(unsigned int disable_mask, unsigned int rising_mask, unsigned int falling_mask, unsigned int both_mask) {
unsigned int tmp = disable_mask;
if(tmp & rising_mask)
return 0;
tmp |= rising_mask;
if(tmp & falling_mask)
return 0;
tmp |= falling_mask;
if(tmp & both_mask)
return 0;
tmp |= both_mask;
if((tmp | DHGPIO_SUITABLE_PINS) != DHGPIO_SUITABLE_PINS)
return 0;
int i;
for(i = 0; i <= DHGPIO_MAXGPIONUM; i++) {
const unsigned int pin = 1 << i;
if(pin & DHGPIO_SUITABLE_PINS == 0)
continue;
else if(pin & disable_mask)
gpio_pin_intr_state_set(GPIO_ID_PIN(i), GPIO_PIN_INTR_DISABLE);
else if(pin & falling_mask)
gpio_pin_intr_state_set(GPIO_ID_PIN(i), GPIO_PIN_INTR_POSEDGE);
else if(pin & rising_mask)
gpio_pin_intr_state_set(GPIO_ID_PIN(i), GPIO_PIN_INTR_NEGEDGE);
else if(pin & both_mask)
gpio_pin_intr_state_set(GPIO_ID_PIN(i), GPIO_PIN_INTR_ANYEDGE);
}
return 1;
}
LOCAL void
key_intr_handler(struct keys_param *keys)
{
uint8 i;
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
for (i = 0; i < keys->key_num; i++) {
if (gpio_status & BIT(keys->single_key[i]->gpio_id)) {
//disable this gpio pin interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(keys->single_key[i]->gpio_id));
if (keys->single_key[i]->key_level == 1) {
// 5s, restart & enter softap mode
os_timer_disarm(&keys->single_key[i]->key_5s);
os_timer_setfn(&keys->single_key[i]->key_5s, (os_timer_func_t *)key_5s_cb, keys->single_key[i]);
os_timer_arm(&keys->single_key[i]->key_5s, LONG_PRESS_TIME, 0);
keys->single_key[i]->key_level = 0;
//enable this gpio pin interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_POSEDGE);
} else {
// 50ms, check if this is a real key up
os_timer_disarm(&keys->single_key[i]->key_50ms);
os_timer_setfn(&keys->single_key[i]->key_50ms, (os_timer_func_t *)key_50ms_cb, keys->single_key[i]);
os_timer_arm(&keys->single_key[i]->key_50ms, 50, 0);
}
}
}
}
void gpio_intr_handler(void *arg)
{
uint8 i;
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
PRINTF("Get into gpio_intr_handler, gpio_status:%d\n", gpio_status);
if (gpio_status & BIT(((struct key_param *)arg)->gpio_id))
{
struct key_param *key = (struct key_param *)arg;
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(key->gpio_id), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(key->gpio_id));
if (key->key_level == 1)
{
// 5s, restart & enter softap mode
os_timer_disarm(&key->key_5s);
os_timer_setfn(&key->key_5s, (os_timer_func_t *)key_5s_cb, key);
os_timer_arm(&key->key_5s, LONG_PRESS_COUNT, 0);
key->key_level = 0;
gpio_pin_intr_state_set(GPIO_ID_PIN(key->gpio_id), GPIO_PIN_INTR_POSEDGE);
}
else
{
// 50ms, check if this is a real key up
os_timer_disarm(&key->key_50ms);
os_timer_setfn(&key->key_50ms, (os_timer_func_t *)key_50ms_cb, key);
os_timer_arm(&key->key_50ms, 50, 0);
}
}
}
void ICACHE_FLASH_ATTR
gpio_init() {
// Configure switch (relays)
INFO("Configure Switch 1 %d\n", SWITCH01_GPIO );
PIN_FUNC_SELECT(SWITCH01_GPIO_MUX, SWITCH01_GPIO_FUNC);
set_switch(SWITCH01_GPIO, 0);
//GPIO_OUTPUT_SET(SWITCH01_GPIO, 0);
INFO("Configure Switch 2 %d\n", SWITCH02_GPIO );
PIN_FUNC_SELECT(SWITCH02_GPIO_MUX, SWITCH02_GPIO_FUNC);
set_switch(SWITCH02_GPIO, 0);
//GPIO_OUTPUT_SET(SWITCH02_GPIO, 0);
INFO("Configure Switch 3 %d\n", SWITCH03_GPIO );
PIN_FUNC_SELECT(SWITCH03_GPIO_MUX, SWITCH03_GPIO_FUNC);
set_switch(SWITCH03_GPIO, 0);
//GPIO_OUTPUT_SET(SWITCH03_GPIO, 0);
//Configure Toggle switches
INFO("Configure Toggle 1 %d\n", TOGGLE01_GPIO );
ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts
ETS_GPIO_INTR_ATTACH(toggle_changed, 0); // GPIO interrupt handler
PIN_FUNC_SELECT(TOGGLE01_GPIO_MUX, TOGGLE01_GPIO_FUNC); // Set function
GPIO_DIS_OUTPUT(TOGGLE01_GPIO); // Set as input
gpio_pin_intr_state_set(GPIO_ID_PIN(TOGGLE01_GPIO), GPIO_PIN_INTR_ANYEDGE); // Interrupt on any edge
//ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts
INFO("Configure Toggle 2 %d\n", TOGGLE02_GPIO );
//ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts
//ETS_GPIO_INTR_ATTACH(toggle_changed); // GPIO interrupt handler
PIN_FUNC_SELECT(TOGGLE02_GPIO_MUX, TOGGLE02_GPIO_FUNC); // Set function
GPIO_DIS_OUTPUT(TOGGLE02_GPIO); // Set as input
gpio_pin_intr_state_set(GPIO_ID_PIN(TOGGLE02_GPIO), GPIO_PIN_INTR_ANYEDGE); // Interrupt on any edge
//ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts
INFO("Configure Toggle 3 %d\n", TOGGLE03_GPIO );
//ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts
//ETS_GPIO_INTR_ATTACH(toggle_changed); // GPIO interrupt handler
PIN_FUNC_SELECT(TOGGLE03_GPIO_MUX, TOGGLE03_GPIO_FUNC); // Set function
GPIO_DIS_OUTPUT(TOGGLE03_GPIO); // Set as input
gpio_pin_intr_state_set(GPIO_ID_PIN(TOGGLE03_GPIO), GPIO_PIN_INTR_ANYEDGE); // Interrupt on any edge
ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts
// Configure push button
// INFO("Confgiure push button %d\n", BUTTON_GPIO );
// ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts
// ETS_GPIO_INTR_ATTACH(button_press, BUTTON_GPIO); // GPIO0 interrupt handler
// PIN_FUNC_SELECT(BUTTON_GPIO_MUX, BUTTON_GPIO_FUNC); // Set function
// GPIO_DIS_OUTPUT(BUTTON_GPIO); // Set as input
// gpio_pin_intr_state_set(GPIO_ID_PIN(BUTTON_GPIO), 2); // Interrupt on negative edge
// ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts
}
void ICACHE_FLASH_ATTR deinit_GPIOs_intr(void)
{
if(GPIO_INT_init_flg) {
ets_isr_mask(1 << ETS_GPIO_INUM); // запрет прерываний GPIOs
gpio_pin_intr_state_set(GPIO_TEST1, GPIO_PIN_INTR_DISABLE);
gpio_pin_intr_state_set(GPIO_TEST2, GPIO_PIN_INTR_DISABLE);
// ets_isr_attach(ETS_GPIO_INUM, NULL, NULL);
GPIO_INTR_INIT = 0;
GPIO_INT_init_flg = 0;
os_printf("GPIOs_intr deinit (%d,%d) ", GPIO_TEST1, GPIO_TEST2);
}
}
// interrupt handler: this function will be executed on any edge of GPIO0
LOCAL void gpio_intr_handler(int *dummy)
{
// clear gpio status. Say ESP8266EX SDK Programming Guide in 5.1.6. GPIO interrupt handler
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
// if the interrupt was by GPIO0
if (gpio_status & BIT(3))
{
uint8_t byte, button, encRet;
encoder_direction_t dir;
// disable interrupt for GPIO0
gpio_pin_intr_state_set(GPIO_ID_PIN(3), GPIO_PIN_INTR_DISABLE);
// Print a debug message
//os_printf("PCF Indicates a pin change : ");
pcf8754_i2c_read_byte(I2C_INPUT_ADDRESS, &byte);
encRet = decode_rotary_encoder(byte, &dir, &button);
if (encRet > 0)
{
if (dir == NO_CHANGE)
os_printf("Button Pressed\r\n");
else
{
switch(dir)
{
case ENCODER_CCW:
os_printf("Counter Clockwise rotation ");
break;
case ENCODER_CW:
os_printf("Clockwise rotation ");
break;
}
if (button)
os_printf(" [Button Pressed]");
os_printf("\r\n");
}
}
//os_printf("0x%x\r\n", byte);
//clear interrupt status for GPIO0
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(3));
// Reactivate interrupts for GPIO0
gpio_pin_intr_state_set(GPIO_ID_PIN(3), GPIO_PIN_INTR_ANYEDGE);
}
}
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));
}
}
}
}
/******************************************************************************
* FunctionName : key_init
* Description : init keys
* Parameters : key_param *keys - keys parameter, which inited by key_init_single
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
key_init(struct keys_param *keys)
{
uint8 i;
os_printf("-%s-%s \r\n", __FILE__, __func__);
ETS_GPIO_INTR_ATTACH(key_intr_handler, keys);
ETS_GPIO_INTR_DISABLE();
for (i = 0; i < keys->key_num; i++) {
keys->single_key[i]->key_level = 1;
PIN_FUNC_SELECT(keys->single_key[i]->gpio_name, keys->single_key[i]->gpio_func);
gpio_output_set(0, 0, 0, GPIO_ID_PIN(keys->single_key[i]->gpio_id));
gpio_register_set(GPIO_PIN_ADDR(keys->single_key[i]->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 gpio14 status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(keys->single_key[i]->gpio_id));
//enable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_ANYEGDE);
}
ETS_GPIO_INTR_ENABLE();
}
/******************************************************************************
* FunctionName : key_init
* Description : init keys
* Parameters : key_param *keys - keys parameter, which inited by key_init_single
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR key_init() {
uint8 i;
ETS_GPIO_INTR_ATTACH(key_intr_handler, &key_parameters);
ETS_GPIO_INTR_DISABLE();
for (i = 0; i < key_parameters.key_num; i++) {
key_parameters.single_key[i]->key_level = 1;
key_parameters.single_key[i]->is_long = 0;
PIN_FUNC_SELECT(key_parameters.single_key[i]->gpio_name, key_parameters.single_key[i]->gpio_func);
// Set GPIO as input
gpio_output_set(0, 0, 0, GPIO_ID_PIN(key_parameters.single_key[i]->gpio_id));
gpio_register_set(
GPIO_PIN_ADDR(key_parameters.single_key[i]->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 gpio14 status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(key_parameters.single_key[i]->gpio_id));
//enable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(key_parameters.single_key[i]->gpio_id), GPIO_PIN_INTR_NEGEDGE);
}
ETS_GPIO_INTR_ENABLE();
}
iram static inline void arm_counter(const gpio_t *gpio)
{
// no use in specifying POSEDGE or NEGEDGE here (bummer),
// they act exactly like ANYEDGE, I assume that's an SDK bug
gpio_pin_intr_state_set(gpio->index, GPIO_PIN_INTR_ANYEDGE);
}
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
}
}
}
}
/*
* Set GPIO mode to output. Optionally in RAM helper because interrupts are dsabled
*/
static void NO_INTR_CODE set_gpio_no_interrupt(uint8 pin, uint8_t push_pull) {
unsigned pnum = pin_num[pin];
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(pnum), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pnum));
// configure push-pull vs open-drain
if (push_pull) {
GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum)),
GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum))) &
(~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain;
} else {
GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum)),
GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pnum))) |
GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //enable open drain;
}
ETS_GPIO_INTR_ENABLE();
}
void ICACHE_FLASH_ATTR user_init()
{
// Initialize the GPIO subsystem.
//UART_init(BIT_RATE_115200, BIT_RATE_115200, 0);
//UART_SetPrintPort(UART0);
stdout_init();
i2c_master_gpio_init();
user_set_station_config();
pcf8754_i2c_write_byte(I2C_INPUT_ADDRESS, 0);
// =================================================
// Initialize GPIO2 and GPIO0 as GPIO
// =================================================
PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_GPIO3);
PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0RXD_U);
gpio_output_set(0, 0, 0, GPIO_ID_PIN(3)); // set set gpio 0 as input
ETS_GPIO_INTR_DISABLE();
// Attach interrupt handle to gpio interrupts.
ETS_GPIO_INTR_ATTACH(gpio_intr_handler, NULL);
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(3)); // clear gpio status
gpio_pin_intr_state_set(GPIO_ID_PIN(3), GPIO_PIN_INTR_ANYEDGE); // clear gpio status.
ETS_GPIO_INTR_ENABLE(); // Enable interrupts by GPIO
// register a callback function to let user code know that system
// initialization is complete
system_init_done_cb(&post_user_init_func);
//Start os task
system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen);
}
LOCAL void
rotary_intr_handler(int8_t key)
{
uint8 direction = 0;
uint32 inputs;
inputs = PIN_IN; //Read input register
//Read rotary state
if (CHECK_BIT(inputs,13) == CHECK_BIT(inputs,12))
direction = 1;
//Not that sure what this does yet and where the register is used for
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(12), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(12));
//Disarm timer
os_timer_disarm(&rotary_debounce_timer);
//Setup timer
os_timer_setfn(&rotary_debounce_timer, (os_timer_func_t *)rotary_debounce, direction);
//Arm the debounce timer
os_timer_arm(&rotary_debounce_timer, 350, 0);
}
// initialization
void IRrecv::enableIRIn() {
// initialize state machine variables
irparams.rcvstate = STATE_IDLE;
irparams.rawlen = 0;
// set pin modes
//PIN_FUNC_SELECT(IR_IN_MUX, IR_IN_FUNC);
GPIO_DIS_OUTPUT(irparams.recvpin);
// Initialize timer
os_timer_disarm(&timer);
os_timer_setfn(&timer, (os_timer_func_t *)read_timeout, &timer);
// ESP Attach Interrupt
ETS_GPIO_INTR_DISABLE();
ETS_GPIO_INTR_ATTACH(gpio_intr, NULL);
gpio_pin_intr_state_set(GPIO_ID_PIN(irparams.recvpin), GPIO_PIN_INTR_ANYEDGE);
ETS_GPIO_INTR_ENABLE();
//ETS_INTR_UNLOCK();
//attachInterrupt(irparams.recvpin, readIR, CHANGE);
//irReadTimer.initializeUs(USECPERTICK, readIR).start();
//os_timer_arm_us(&irReadTimer, USECPERTICK, 1);
//ets_timer_arm_new(&irReadTimer, USECPERTICK, 1, 0);
}
/******************************************************************************
* FunctionName : key_50ms_cb
* Description : 50ms timer callback to check it's a real key push
* Parameters : single_key_param *single_key - single key parameter
* Returns : none
*******************************************************************************/
LOCAL void
key_50ms_cb(struct single_key_param *single_key)
{
os_timer_disarm(&single_key->key_50ms);
//check this gpio pin state
if (1 == GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id))) {
os_timer_disarm(&single_key->key_5s);
single_key->key_level = 1;
gpio_pin_intr_state_set(GPIO_ID_PIN(single_key->gpio_id), GPIO_PIN_INTR_NEGEDGE);
//this gpio has been in low state no more than 5s, then call short_press function
if (single_key->short_press) {
single_key->short_press();
}
} else {
gpio_pin_intr_state_set(GPIO_ID_PIN(single_key->gpio_id), GPIO_PIN_INTR_POSEDGE);
}
}
static void platform_gpio_intr_dispatcher( platform_gpio_intr_handler_fn_t cb){
uint8 i, level;
uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
for (i = 0; i < GPIO_PIN_NUM; i++) {
if (pin_int_type[i] && (gpio_status & BIT(pin_num[i])) ) {
//disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[i]), GPIO_PIN_INTR_DISABLE);
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(pin_num[i]));
level = 0x1 & GPIO_INPUT_GET(GPIO_ID_PIN(pin_num[i]));
if(cb){
cb(i, level);
}
gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[i]), pin_int_type[i]);
}
}
}
void interruptMode(uint8_t pin, GPIO_INT_TYPE type)
{
portENTER_CRITICAL();
pinMode(pin, INPUT);
gpio_pin_intr_state_set(GPIO_ID_PIN(pin), type);
portEXIT_CRITICAL();
}
void gpio_config(GPIO_ConfigTypeDef *pGPIOConfig)
{
uint32 gpio_pin_mask = pGPIOConfig->GPIO_Pin;
uint32 gpio_pin_mask_high = pGPIOConfig->GPIO_Pin_high;
uint32 io_reg;
uint8 io_num = 0;
uint32 pin_reg;
uint32 bit_valid;
if (pGPIOConfig->GPIO_Mode == GPIO_Mode_Input) {
GPIO_AS_INPUT(gpio_pin_mask);
GPIO_AS_INPUT_HIGH(gpio_pin_mask_high);
} else if (pGPIOConfig->GPIO_Mode == GPIO_Mode_Output) {
GPIO_AS_OUTPUT(gpio_pin_mask);
GPIO_AS_OUTPUT_HIGH(gpio_pin_mask_high);
}
do {
bit_valid = (io_num >= 32 ? (gpio_pin_mask_high & (0x1 << (io_num - 32))) : (gpio_pin_mask & (0x1 << io_num)));
if (bit_valid && (io_reg = GPIO_PIN_REG[io_num])) {
if (pGPIOConfig->GPIO_Mode == GPIO_Mode_Input) {
SET_PERI_REG_MASK(io_reg, FUN_IE);
}
//for ESP32 function 2 of every pad is allways GPIO func
PIN_FUNC_SELECT(io_reg, 2);
if (pGPIOConfig->GPIO_Pullup) {
PIN_PULLUP_EN(io_reg);
} else {
PIN_PULLUP_DIS(io_reg);
}
if (pGPIOConfig->GPIO_Pulldown) {
PIN_PULLDWN_EN(io_reg);
} else {
PIN_PULLDWN_DIS(io_reg);
}
if (pGPIOConfig->GPIO_Mode == GPIO_Mode_Out_OD) {
portENTER_CRITICAL();
pin_reg = GPIO_REG_READ(GPIO_PIN_ADDR(io_num));
//pin_reg &= (~GPIO_GPIO_PIN0_PAD_DRIVER);
pin_reg |= GPIO_GPIO_PIN0_PAD_DRIVER;
GPIO_REG_WRITE(GPIO_PIN_ADDR(io_num), pin_reg);
portEXIT_CRITICAL();
}
gpio_pin_intr_state_set(io_num, pGPIOConfig->GPIO_IntrType);
}
io_num++;
} while (io_num < GPIO_PIN_COUNT);
}
/******************************************************************************
* FunctionName : key_50ms_cb
* Description : 50ms timer callback to check it's a real key push
* Parameters : single_key_param *single_key - single key parameter
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
key_50ms_cb(struct single_key_param *single_key)
{
os_timer_disarm(&single_key->key_50ms);
// high, then key is up
if (1 == GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id))) {
os_timer_disarm(&single_key->key_5s);
single_key->key_level = 1;
gpio_pin_intr_state_set(GPIO_ID_PIN(single_key->gpio_id), GPIO_PIN_INTR_NEGEDGE);
if (single_key->short_press) {
single_key->short_press();
}
} else {
gpio_pin_intr_state_set(GPIO_ID_PIN(single_key->gpio_id), GPIO_PIN_INTR_POSEDGE);
}
}
static void GPIOs_intr_handler(void)
{
uint32 gpio_status = GPIO_STATUS;
GPIO_STATUS_W1TC = gpio_status;
if(gpio_status & (1<<GPIO_TEST1)) {
if(++GPIO_INT_Count1 > 10) {
GPIO_INT_Count1 = 0;
system_os_post(GPIOs_intr_TASK_PRIO, GPIOs_intr_SIG_SAVE, 1);
}
gpio_pin_intr_state_set(GPIO_TEST1, GPIO_PIN_INTR_ANYEDGE); // GPIO_PIN_INTR_POSEDGE | GPIO_PIN_INTR_NEGEDGE ?
}
if(gpio_status & (1<<GPIO_TEST2)) {
if(++GPIO_INT_Count2 > 10) {
GPIO_INT_Count2 = 0;
system_os_post(GPIOs_intr_TASK_PRIO, GPIOs_intr_SIG_SAVE, 2);
}
gpio_pin_intr_state_set(GPIO_TEST2, GPIO_PIN_INTR_ANYEDGE); // GPIO_PIN_INTR_POSEDGE | GPIO_PIN_INTR_NEGEDGE ?
}
}
//-----------------------------------------------------------------------------------------
static void dht11_set_standby()
{
os_timer_disarm(&dht11_timer);
sStatus = dht11_standby;
os_timer_disarm(&dht11_timer);
// Disable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_DISABLE);
// GPIO as Output to high level by default.
GPIO_OUTPUT_SET(dht11_gpio,1);
// Read is finish. Signal to aplication
system_os_post(dht11_user_task, dht11_user_task_signal, 0 );
}
void SoftwareSerial::enableRx(bool on) {
if (m_rxValid) {
GPIO_INT_TYPE type;
if (!on)
type = GPIO_PIN_INTR_DISABLE;
else if (m_invert)
type = GPIO_PIN_INTR_POSEDGE;
else
type = GPIO_PIN_INTR_NEGEDGE;
gpio_pin_intr_state_set(GPIO_ID_PIN(m_rxPin), type);
}
}
/*
* Initialise GPIO interrupt mode. Optionally in RAM because interrupts are disabled
*/
void NO_INTR_CODE platform_gpio_intr_init( unsigned pin, GPIO_INT_TYPE type )
{
if (platform_gpio_exists(pin)) {
ETS_GPIO_INTR_DISABLE();
//clear interrupt status
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(pin_num[pin]));
pin_int_type[pin] = type;
//enable interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[pin]), type);
ETS_GPIO_INTR_ENABLE();
}
}
void ICACHE_FLASH_ATTR setup_interrupt(){
uart0_sendStr("setup interrupt\n");
//disable interrupt if it is enabled
ETS_GPIO_INTR_DISABLE();
//setup a interrupt pin for possitive edge front trigger
gpio_pin_intr_state_set(GPIO_ID_PIN(INT_PIN),GPIO_PIN_INTR_POSEDGE);//or GPIO_PIN_INTR_POSEDGE or GPIO_PIN_INTR_HILEVEL
//set callback when interrupt trigeres
ETS_GPIO_INTR_ATTACH(pending_interrupt, 0);
interrupt_set=1;
}
/**
* Detach the interrupt handler from the 'gpio_pin' pin.
*/
bool ICACHE_FLASH_ATTR
easygpio_detachInterrupt(uint8_t gpio_pin) {
if (gpio_pin == 16) {
os_printf("easygpio_setupInterrupt Error: GPIO16 does not have interrupts\n");
return false;
}
// Don't know how to detach interrupt, yet.
// Quick and dirty fix - just disable the interrupt
gpio_pin_intr_state_set(GPIO_ID_PIN(gpio_pin), GPIO_PIN_INTR_DISABLE);
return true;
}
void
supla_esp_gpio_enable_input_port(char port) {
gpio_output_set(0, 0, 0, GPIO_ID_PIN(port));
gpio_register_set(GPIO_PIN_ADDR(port), 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(port));
gpio_pin_intr_state_set(GPIO_ID_PIN(port), GPIO_PIN_INTR_ANYEDGE);
}
