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]); } } }
/****************************************************************************** * FunctionName : user_humiture_long_press * Description : humiture key's function, needed to be installed * Parameters : none * Returns : none *******************************************************************************/ LOCAL void ICACHE_FLASH_ATTR user_sensor_long_press(void) { os_printf(" LVZAINA ===> SmartConfig start! \n"); uint32 gpio_status; gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); //clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); user_link_led_timer_init(); smartconfig_stop(); smartconfig_start(smartconfig_done); os_printf(" LVZAINA ===> SmartConfig end! \n"); }
uint8_t platform_sigma_delta_close( uint8_t pin ) { if (pin < 1 || pin > NUM_GPIO) return 0; sigma_delta_stop(); // set GPIO input mode for this pin platform_gpio_mode( pin, PLATFORM_GPIO_INPUT, PLATFORM_GPIO_PULLUP ); // CONNECT GPIO TO PIN PAD 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_SOURCE_MASK)) | GPIO_PIN_SOURCE_SET( GPIO_AS_PIN_SOURCE )); return 1; }
void interrupt_test(){ // disable interrupts ETS_GPIO_INTR_DISABLE(); uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); // publish that button has been pressed INFO("Button pressed!!"); pb1Transmit(); //gpio_pin_intr_state_set(GPIO_ID_PIN(4), GPIO_PIN_INTR_POSEDGE); // enable interrupts ETS_GPIO_INTR_ENABLE(); }
void setSigmaDeltaPrescaler(unsigned char prescaler) { uint8 duty; duty = getSigmaDeltaDuty(); if (GPIO_REG_READ(GPIO_SIGMA_DELTA) & 0x10000) { // check to see if ΣΔ is running GPIO_REG_WRITE(GPIO_SIGMA_DELTA, 0); // turn off ΣΔ GPIO_REG_WRITE(GPIO_SIGMA_DELTA, 0x10000 | (prescaler<<8) | duty); // set Target Prescaler and restore duty } else { GPIO_REG_WRITE(GPIO_SIGMA_DELTA, (prescaler<<8)|duty); // set Target Prescaler and restore duty but leave turned off } }
void ICACHE_RAM_ATTR SoftwareSerial::handle_interrupt(void *arg) { uint32_t gpioStatus = GPIO_REG_READ(GPIO_STATUS_ADDRESS); // Clear the interrupt(s) otherwise we get called again GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpioStatus); ETS_GPIO_INTR_DISABLE(); uint8_t pin = 0; while (gpioStatus) { while(!(gpioStatus & (1 << pin))) pin++; gpioStatus &= ~(1 << pin); if (InterruptList[pin]) { // For some reason there is always an interrupt directly after the // stop bit. Detect that by checking if we have a start bit if (digitalRead(pin) == InterruptList[pin]->m_invert) InterruptList[pin]->rxRead(); } } ETS_GPIO_INTR_ENABLE(); }
uint8_t platform_sigma_delta_setup( uint8_t pin ) { if (pin < 1 || pin > NUM_GPIO) return 0; sigma_delta_setup(); // set GPIO output mode for this pin platform_gpio_mode( pin, PLATFORM_GPIO_OUTPUT, PLATFORM_GPIO_FLOAT ); platform_gpio_write( pin, PLATFORM_GPIO_LOW ); // enable sigma-delta on this 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_SOURCE_MASK)) | GPIO_PIN_SOURCE_SET( SIGMA_AS_PIN_SOURCE )); return 1; }
LOCAL void ICACHE_FLASH_ATTR read_input_pin(void *arg) { uint32 gpio_status; ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts sleepms(15); if(!GPIO_INPUT_GET(PIN_GPIO13)) { button_counter++; console_printf("READ_INPUT_PIN executed..."); console_printf("COUNTER:%d\n",button_counter); os_timer_disarm(&input_pin_timer); // Disarm input pin timer os_timer_setfn(&input_pin_timer, (os_timer_func_t *)handle_pin_press, NULL); // Setup input pin timer os_timer_arm(&input_pin_timer, button_timeout, 1); // Arm input pin timer, 0,5sec, repeat sleepms(button_debounce); // debounce time } gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); //clear interrupt status ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts} }
void some_timerfunc(void *arg) { //Do blinky stuff if (GPIO_REG_READ(GPIO_OUT_ADDRESS) & BIT2) { //Set GPIO2 to LOW gpio_output_set(0, BIT2, BIT2, 0); os_printf("0"); } else { //Set GPIO2 to HIGH gpio_output_set(BIT2, 0, BIT2, 0); os_printf("1"); } if (count++ % 80 == 0) { os_printf("\n"); } }
static void gpio_intr_handler() { uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); //m_printf("gpio_status:%X\n\r",gpio_status); if (gpio_status & BIT(0))// S_REED { debugf("irq00\n\r"); //GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, (gpio_status & BIT(0))); } if(gpio_status & BIT(3))// { debugf("irq03\n\r"); //GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, (gpio_status & BIT(3))); } if (gpio_status & BIT(4))// { debugf("irq04\n\r"); _relay._changeStat(); //GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, (gpio_status & BIT(4))); } if (gpio_status & BIT(13))// { debugf("irq13\n\r"); //GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, (gpio_status & BIT(13))); _relay._changeStat(); } if (gpio_status & BIT(15)) { debugf("irq15\n\r"); //GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, (gpio_status & BIT(13))); } }
static void ICACHE_FLASH_ATTR gpio_intr(void *arg) { uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); if (irparams.rcvstate == STATE_STOP) { return; } static uint32_t start = 0; uint32_t now = system_get_time(); if (irparams.rcvstate == STATE_IDLE) { irparams.rcvstate = STATE_MARK; irparams.rawbuf[irparams.rawlen++] = 20; } else if (irparams.rawlen < RAWBUF) { irparams.rawbuf[irparams.rawlen++] = (now - start) / USECPERTICK + 1; } start = now; os_timer_disarm(&timer); os_timer_arm(&timer, 15, 0); }
LOCAL void gpio_intr(void *arg) { unsigned int gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); if(gpio_status & mExternalIntPins) { dhgpio_extra_int(gpio_status & mExternalIntPins); gpio_status &= ~mExternalIntPins; if(gpio_status == 0) return; } mTriggeredIntrPins |= gpio_status; if(mGPIOTimerArmed) return; os_timer_disarm(&mGPIOTimer); if(mGPIOTimerTimeout) { mGPIOTimerArmed = 1; os_timer_setfn(&mGPIOTimer, (os_timer_func_t *)gpio_timeout, NULL); os_timer_arm(&mGPIOTimer, mGPIOTimerTimeout, 0); } else { gpio_timeout(0); } }
static void ICACHE_FLASH_ATTR udpServerRxCb(void *arg, char *pData, unsigned short len) { int i; for ( i = 0 ; i < len ; i++) { os_printf("%c", pData[i]); } /* Toggle PIN */ if (GPIO_REG_READ(GPIO_OUT_ADDRESS) & RELAY_PIN) { //Set GPIO0 to LOW gpio_output_set(0, RELAY_PIN, BIT0, 0); } else { //Set GPIO0 to HIGH gpio_output_set(RELAY_PIN, 0, RELAY_PIN, 0); } }
bool ICACHE_FLASH_ATTR pwm_add(uint8 channel){ PWM_DBG("--Function pwm_add() is called. channel:%d\n", channel); PWM_DBG("pwm_gpio:%x,pwm_channel_num:%d\n",pwm_gpio,pwm_channel_num); PWM_DBG("pwm_out_io_num[0]:%d,[1]:%d,[2]:%d\n",pwm_out_io_num[0],pwm_out_io_num[1],pwm_out_io_num[2]); PWM_DBG("pwm.duty[0]:%d,[1]:%d,[2]:%d\n",pwm.duty[0],pwm.duty[1],pwm.duty[2]); uint8 i; for(i=0;i<PWM_CHANNEL;i++){ if(pwm_out_io_num[i]==channel) // already exist return true; if(pwm_out_io_num[i] == -1){ // empty exist pwm_out_io_num[i] = channel; pwm.duty[i] = 0; pwm_gpio |= (1 << pin_num[channel]); PIN_FUNC_SELECT(pin_mux[channel], pin_func[channel]); GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel]))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain; pwm_channel_num++; return true; } } return false; }
void ICACHE_FLASH_ATTR gpio_intr_dispatcher(gpio_intr_handler 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 global interrupt ETS_GPIO_INTR_DISABLE(); //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); } //enable interrupt gpio_pin_intr_state_set(GPIO_ID_PIN(pin_num[i]), pin_int_type[i]); //enable global interrupt 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); 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 long release timer 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, 5000, 0); keys->single_key[i]->key_level = 0; keys->single_key[i]->is_long = 0; gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_POSEDGE); if (keys->single_key[i]->press) { // PRESS callback os_timer_disarm(&keys->single_key[i]->key_press); os_timer_setfn(&keys->single_key[i]->key_press, (os_timer_func_t *)keys->single_key[i]->press, NULL); os_timer_arm(&keys->single_key[i]->key_press, 5, 0); } } 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); } } } }
static void ping_intr_handler(void *key) { uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS); if (ping_allEchoPins & gpio_status) { if (ping_currentEchoPin>=0 && (gpio_status & BIT(ping_currentEchoPin))) { // This interrupt was intended for us - clear interrupt status GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(ping_currentEchoPin)); if(!ping_echoStarted) { gpio_pin_intr_state_set(GPIO_ID_PIN(ping_currentEchoPin), GPIO_PIN_INTR_NEGEDGE); ping_timeStamp0 = system_get_time(); ping_echoStarted = true; } else { ping_timeStamp1 = system_get_time(); ping_echoEnded = true; ping_disableInterrupt(ping_currentEchoPin); ping_currentEchoPin = -1; } } else { // This interrupt was intended for us, but not at this moment - clear interrupt status anyway GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & ping_allEchoPins); } } }
void handle_timeout(void *arg) { if (GPIO_REG_READ(GPIO_OUT_ADDRESS) & BIT2) gpio_output_set(0, BIT2, BIT2, 0); //Set GPIO2 to LOW else gpio_output_set(BIT2, 0, BIT2, 0); //Set GPIO2 to HIGH }
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 }
uint32 gpio_output_get(void) { return GPIO_REG_READ(GPIO_OUT_ADDRESS); }
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 } } }
unsigned char getSigmaDeltaDuty(void) { return (unsigned char) (GPIO_REG_READ(GPIO_SIGMA_DELTA) & 0x0ff); // set Target duty cycle }
/* * Sample the value of GPIO input pins and returns a bitmask. * * Only GPIO0-GPIO31 */ uint32 gpio_input_get(void) { return GPIO_REG_READ(GPIO_IN); }
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; }
/* * Sample the value of GPIO input pins and returns a bitmask. * * Only GPIO32-GPIO39 */ uint32 gpio_input_get_high(void) { return GPIO_REG_READ(GPIO_IN1); }
uint8_t relay_get_status() { return (GPIO_REG_READ(GPIO_OUT_ADDRESS) & BIT15) == 0 ? 0 : 1; }
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; }
bool led_is_set (void) { return ((GPIO_REG_READ(GPIO_OUT_ADDRESS) & LED_IO_MASK)) ? true : false; }
static char *states[] = { "UNDEFINED", "GPIO_OUT", "GPIO_OUT_OPENDRAIN", "GPIO_IN", "GPIO_IN_PULLUP", "GPIO_IN_PULLDOWN", "ADC_IN", "AF_OUT", "AF_OUT_OPENDRAIN", "USART_IN", "USART_OUT", "DAC_OUT", "I2C", }; return states[state]; } static void jshDebugPin(Pin pin) { os_printf("PIN: %d out=%ld enable=%ld in=%ld\n", pin, (GPIO_REG_READ(GPIO_OUT_ADDRESS)>>pin)&1, (GPIO_REG_READ(GPIO_ENABLE_ADDRESS)>>pin)&1, (GPIO_REG_READ(GPIO_IN_ADDRESS)>>pin)&1); uint32_t gpio_pin = GPIO_REG_READ(GPIO_PIN_ADDR(pin)); uint32_t mux = READ_PERI_REG(PERIPHS_IO_MUX + 4*pin); os_printf(" dr=%s src=%s func=%ld pull-up=%ld oe=%ld\n", gpio_pin & 4 ? "open-drain" : "totem-pole", gpio_pin & 1 ? "sigma-delta" : "gpio", (mux>>2)&1 | (mux&3), (mux>>7)&1, mux&1); } /** * Set the state of the specific pin. * * The possible states are: * * JSHPINSTATE_UNDEFINED * JSHPINSTATE_GPIO_OUT * JSHPINSTATE_GPIO_OUT_OPENDRAIN
bool ICACHE_FLASH_ATTR ssd1306_init(uint8_t id) { oled_i2c_ctx *ctx = NULL; if ((id != 0) && (id != 1)) goto oled_init_fail; // free old context (if any) ssd1306_term(id); ctx = zalloc(sizeof(oled_i2c_ctx)); if (ctx == NULL) { dmsg_err_puts("Alloc OLED context failed."); goto oled_init_fail; } if (id == 0) { #if (PANEL0_TYPE != 0) #if (PANEL0_TYPE == SSD1306_128x64) ctx->type = SSD1306_128x64; ctx->buffer = zalloc(1024); // 128 * 64 / 8 ctx->width = 128; ctx->height = 64; #elif (PANEL0_TYPE == SSD1306_128x32) ctx->type = SSD1306_128x32; ctx->buffer = zalloc(512); // 128 * 32 / 8 ctx->width = 128; ctx->height = 32; #else #error "Panel 0 undefined" #endif if (ctx->buffer == NULL) { dmsg_err_puts("Alloc OLED buffer failed."); goto oled_init_fail; } ctx->address = PANEL0_ADDR; #if PANEL0_USE_RST // Panel 0 reset PIN_FUNC_SELECT(PANEL0_RST_MUX, PANEL0_RST_FUNC); GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | PANEL0_RST_BIT); GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, PANEL0_RST_BIT); os_delay_us(10000); GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, PANEL0_RST_BIT); #endif #else dmsg_err_puts("Panel 0 not defined."); goto oled_init_fail; #endif } else if (id == 1) { #if (PANEL1_PANEL_TYPE != 0) #if (PANEL1_PANEL_TYPE ==SSD1306_128x64) ctx->type = SSD1306_128x64; ctx->buffer = zalloc(1024); // 128 * 64 / 8 ctx->width = 128; ctx->height = 64; #elif (PANEL1_PANEL_TYPE == SSD1306_128x32) ctx->type = SSD1306_128x32; ctx->buffer = zalloc(512); // 128 * 32 / 8 ctx->width = 128; ctx->height = 32; #else #error "Unknown Panel 1 type" #endif if (ctx->buffer == NULL) { dmsg_err_puts("Alloc OLED buffer failed."); goto oled_init_fail; } ctx->address = PANEL1_ADDR; #if PANEL1_USE_RST // Panel 1 reset PIN_FUNC_SELECT(PANEL1_RST_MUX, PANEL1_RST_FUNC); GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | PANEL1_RST_BIT); GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, PANEL1_RST_BIT); os_delay_us(10000); GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, PANEL1_RST_BIT); #endif #else dmsg_err_puts("Panel 1 not defined."); goto oled_init_fail; #endif } // Panel initialization // Try send I2C address check if the panel is connected i2c_start(); if (!i2c_write(ctx->address)) { i2c_stop(); dmsg_err_puts("OLED I2C bus not responding."); goto oled_init_fail; } i2c_stop(); // Now we assume all sending will be successful if (ctx->type == SSD1306_128x64) { _command(ctx->address, 0xae); // SSD1306_DISPLAYOFF _command(ctx->address, 0xd5); // SSD1306_SETDISPLAYCLOCKDIV _command(ctx->address, 0x80); // Suggested value 0x80 _command(ctx->address, 0xa8); // SSD1306_SETMULTIPLEX _command(ctx->address, 0x3f); // 1/64 _command(ctx->address, 0xd3); // SSD1306_SETDISPLAYOFFSET _command(ctx->address, 0x00); // 0 no offset _command(ctx->address, 0x40); // SSD1306_SETSTARTLINE line #0 _command(ctx->address, 0x20); // SSD1306_MEMORYMODE _command(ctx->address, 0x00); // 0x0 act like ks0108 _command(ctx->address, 0xa1); // SSD1306_SEGREMAP | 1 _command(ctx->address, 0xc8); // SSD1306_COMSCANDEC _command(ctx->address, 0xda); // SSD1306_SETCOMPINS _command(ctx->address, 0x12); _command(ctx->address, 0x81); // SSD1306_SETCONTRAST _command(ctx->address, 0xcf); _command(ctx->address, 0xd9); // SSD1306_SETPRECHARGE _command(ctx->address, 0xf1); _command(ctx->address, 0xdb); // SSD1306_SETVCOMDETECT _command(ctx->address, 0x30); _command(ctx->address, 0x8d); // SSD1306_CHARGEPUMP _command(ctx->address, 0x14); // Charge pump on _command(ctx->address, 0x2e); // SSD1306_DEACTIVATE_SCROLL _command(ctx->address, 0xa4); // SSD1306_DISPLAYALLON_RESUME _command(ctx->address, 0xa6); // SSD1306_NORMALDISPLAY } else if (ctx->type == SSD1306_128x32) { _command(ctx->address, 0xae); // SSD1306_DISPLAYOFF _command(ctx->address, 0xd5); // SSD1306_SETDISPLAYCLOCKDIV _command(ctx->address, 0x80); // Suggested value 0x80 _command(ctx->address, 0xa8); // SSD1306_SETMULTIPLEX _command(ctx->address, 0x1f); // 1/32 _command(ctx->address, 0xd3); // SSD1306_SETDISPLAYOFFSET _command(ctx->address, 0x00); // 0 no offset _command(ctx->address, 0x40); // SSD1306_SETSTARTLINE line #0 _command(ctx->address, 0x8d); // SSD1306_CHARGEPUMP _command(ctx->address, 0x14); // Charge pump on _command(ctx->address, 0x20); // SSD1306_MEMORYMODE _command(ctx->address, 0x00); // 0x0 act like ks0108 _command(ctx->address, 0xa1); // SSD1306_SEGREMAP | 1 _command(ctx->address, 0xc8); // SSD1306_COMSCANDEC _command(ctx->address, 0xda); // SSD1306_SETCOMPINS _command(ctx->address, 0x02); _command(ctx->address, 0x81); // SSD1306_SETCONTRAST _command(ctx->address, 0x2f); _command(ctx->address, 0xd9); // SSD1306_SETPRECHARGE _command(ctx->address, 0xf1); _command(ctx->address, 0xdb); // SSD1306_SETVCOMDETECT _command(ctx->address, 0x40); _command(ctx->address, 0x2e); // SSD1306_DEACTIVATE_SCROLL _command(ctx->address, 0xa4); // SSD1306_DISPLAYALLON_RESUME _command(ctx->address, 0xa6); // SSD1306_NORMALDISPLAY } // Save context ctx->id = id; _ctxs[id] = ctx; ssd1306_clear(id); ssd1306_refresh(id, true); _command(ctx->address, 0xaf); // SSD1306_DISPLAYON return true; oled_init_fail: if (ctx && ctx->buffer) free(ctx->buffer); if (ctx) free(ctx); return false; }