bool ets_run(void) { #if USE_ETS_TASK #if SDK_BELOW_1_1_1 ets_isr_attach(10, my_timer_isr, NULL); #endif _ets_run(); #else // ets_timer_init(); *(char*)0x3FFFC6FC = 0; ets_intr_lock(); printf("ets_alt_task: ets_run\n"); #if DEBUG dump_tasks(); #endif ets_intr_unlock(); while (1) { if (!ets_loop_iter()) { //printf("idle\n"); ets_intr_lock(); if (idle_cb) { idle_cb(idle_arg); } asm("waiti 0"); ets_intr_unlock(); } } #endif }
// Byte triples in the buffer are interpreted as R G B values and sent to the hardware as G R B. int ICACHE_FLASH_ATTR ws2812_writergb(uint8_t gpio, char *buffer, size_t length) { // Initialize the output pin: pinMode(gpio, OUTPUT); digitalWrite(gpio, 0); // Ignore incomplete Byte triples at the end of buffer: length -= length % 3; // Rearrange R G B values to G R B order needed by WS2812 LEDs: size_t i; for (i = 0; i < length; i += 3) { const char r = buffer[i]; const char g = buffer[i + 1]; buffer[i] = g; buffer[i + 1] = r; } // Do not remove these: os_delay_us(1); os_delay_us(1); // Send the buffer: ets_intr_lock(); const char * const end = buffer + length; while (buffer != end) { uint8_t mask = 0x80; while (mask) { (*buffer & mask) ? send_ws_1(gpio) : send_ws_0(gpio); mask >>= 1; } ++buffer; } ets_intr_unlock(); }
// Byte triples in the buffer are interpreted as G R B values and sent to the hardware as G R B. int ICACHE_FLASH_ATTR ws2812_writegrb(uint8_t gpio, char *buffer, size_t length) { // Initialize the output pin: pinMode(gpio, OUTPUT); digitalWrite(gpio, 0); // Ignore incomplete Byte triples at the end of buffer: length -= length % 3; // Do not remove these: os_delay_us(1); os_delay_us(1); // Send the buffer: ets_intr_lock(); const char * const end = buffer + length; while (buffer != end) { uint8_t mask = 0x80; while (mask) { (*buffer & mask) ? send_ws_1(gpio) : send_ws_0(gpio); mask >>= 1; } ++buffer; } ets_intr_unlock(); }
bool ets_post(uint8 prio, os_signal_t sig, os_param_t param) { // static unsigned cnt; printf("#%d ets_post(%d, %x, %x)\n", cnt++, prio, sig, param); #if USE_ETS_TASK return _ets_post(prio, sig, param); #else ets_intr_lock(); const int id = prio2id(prio); os_event_t *q = emu_tasks[id].queue; if (emu_tasks[id].i_put == -1) { // queue is full printf("ets_post: task %d queue full\n", prio); return false; } q = &q[emu_tasks[id].i_put++]; q->sig = sig; q->par = param; if (emu_tasks[id].i_put == emu_tasks[id].qlen) { emu_tasks[id].i_put = 0; } if (emu_tasks[id].i_put == emu_tasks[id].i_get) { // queue got full emu_tasks[id].i_put = -1; } //printf("after ets_post: "); dump_task(prio, &emu_tasks[id]); //dump_tasks(); ets_intr_unlock(); return true; #endif }
bool ets_loop_iter(void) { if (query_irq() != 0) { return false; } //static unsigned cnt; bool progress = false; for (volatile struct task_entry *t = emu_tasks; t < &emu_tasks[MP_ARRAY_SIZE(emu_tasks)]; t++) { system_soft_wdt_feed(); ets_intr_lock(); //printf("etc_loop_iter: "); dump_task(t - emu_tasks + FIRST_PRIO, t); if (t->i_get != t->i_put) { progress = true; //printf("#%d Calling task %d(%p) (%x, %x)\n", cnt++, // t - emu_tasks + FIRST_PRIO, t->task, t->queue[t->i_get].sig, t->queue[t->i_get].par); int idx = t->i_get; if (t->i_put == -1) { t->i_put = t->i_get; } if (++t->i_get == t->qlen) { t->i_get = 0; } //ets_intr_unlock(); t->task(&t->queue[idx]); //ets_intr_lock(); //printf("Done calling task %d\n", t - emu_tasks + FIRST_PRIO); } ets_intr_unlock(); } return progress; }
void pp_soft_wdt_feed_local() { struct rst_info rst_info; rst_info.exccause = RSR(EXCCAUSE); rst_info.epc1 = RSR(EPC1); rst_info.epc2 = RSR(EPC2); rst_info.epc3 = RSR(EPC3); rst_info.excvaddr = RSR(EXCVADDR); rst_info.depc = RSR(DEPC); if(wdt_flg == true) { rst_info.reason = REASON_SOFT_WDT_RST; // =3 system_rtc_mem_write(0, &rst_info, sizeof(rst_info)); ets_intr_lock(); Wait_SPI_Idle(flashchip); Cache_Read_Enable_New(); system_restart_local(); } else { rst_info.reason = REASON_WDT_RST; // =1 system_rtc_mem_write(0, &rst_info, sizeof(rst_info)); #if DEF_SDK_VERSION >= 1119 wDev_MacTim1Arm(soft_wdt_interval); #else ets_timer_disarm(SoftWdtTimer); ets_timer_arm_new(SoftWdtTimer, soft_wdt_interval, 0, 1); #endif wdt_flg = true; pp_post(12); } }
// ******* C API functions ************* void __attribute__((noreturn)) TEXT_SECTION_ATTR rtc_time_enter_deep_sleep_final (void) { ets_intr_lock(); Cache_Read_Disable(); rtc_reg_write(0x18,8); rtc_reg_write_and_loop(0x08,0x00100000); // go to sleep __builtin_unreachable(); }
void _pp_task_12(void) { ets_intr_lock(); if(dbg_stop_sw_wdt == false) wdt_flg = false; if(dbg_stop_hw_wdt == false) { WDT_FEED = WDT_FEED_MAGIC; } ets_intr_unlock(); }
void wdt_task(ETSEvent *e) { ets_intr_lock(); if(wdt_flg) { wdt_flg = false; if (RTC_MEM(0) <= RST_EVENT_WDT) RTC_MEM(0) = 0; WDT_FEED = WDT_FEED_MAGIC; } ets_intr_unlock(); }
int do_flash_write(uint32_t addr, uint32_t len, uint32_t erase) { struct uart_buf ub; uint8_t digest[16]; uint32_t num_written = 0, num_erased = 0; struct MD5Context ctx; MD5Init(&ctx); if (addr % FLASH_SECTOR_SIZE != 0) return 0x32; if (len % FLASH_SECTOR_SIZE != 0) return 0x33; if (SPIUnlock() != 0) return 0x34; ub.nr = 0; ub.pr = ub.pw = ub.data; ets_isr_attach(ETS_UART_INUM, uart_isr, &ub); SET_PERI_REG_MASK(UART_INT_ENA(0), UART_RX_INTS); ets_isr_unmask(1 << ETS_UART_INUM); SLIP_send(&num_written, 4); while (num_written < len) { volatile uint32_t *nr = &ub.nr; /* Prepare the space ahead. */ while (erase && num_erased < num_written + SPI_WRITE_SIZE) { const uint32_t num_left = (len - num_erased); if (num_left > FLASH_BLOCK_SIZE && addr % FLASH_BLOCK_SIZE == 0) { if (SPIEraseBlock(addr / FLASH_BLOCK_SIZE) != 0) return 0x35; num_erased += FLASH_BLOCK_SIZE; } else { /* len % FLASH_SECTOR_SIZE == 0 is enforced, no further checks needed */ if (SPIEraseSector(addr / FLASH_SECTOR_SIZE) != 0) return 0x36; num_erased += FLASH_SECTOR_SIZE; } } /* Wait for data to arrive. */ while (*nr < SPI_WRITE_SIZE) { } MD5Update(&ctx, ub.pr, SPI_WRITE_SIZE); if (SPIWrite(addr, ub.pr, SPI_WRITE_SIZE) != 0) return 0x37; ets_intr_lock(); *nr -= SPI_WRITE_SIZE; ets_intr_unlock(); num_written += SPI_WRITE_SIZE; addr += SPI_WRITE_SIZE; ub.pr += SPI_WRITE_SIZE; if (ub.pr >= ub.data + UART_BUF_SIZE) ub.pr = ub.data; SLIP_send(&num_written, 4); } ets_isr_mask(1 << ETS_UART_INUM); MD5Final(digest, &ctx); SLIP_send(digest, 16); return 0; }
int pp_post(int x) { ets_intr_lock(); if(t0x3FFEB460[x] == 0) { ets_intr_unlock(); t0x3FFEB460[x]++; return ets_post(32, x, 0); } ets_intr_unlock(); return 0; }
int pp_post(int x) { int ret = 0; ets_intr_lock(); if(t0x3FFEB020[x] == 0) { t0x3FFEB020[x]++; if(x == 12) { b0x3FFEAE99 = 1; } int ret = ets_post(32, x, 0); if(ret != 0) { ets_intr_lock(); t0x3FFEB020[0] = 0; t0x3FFEB020[x]--; WDT_FEED = WDT_FEED_MAGIC; } } ets_intr_unlock(); return 0; }
int tcpserver_send(struct espconn *conn, void *data, uint16 len, enum Memtype mem) { DEBUG("enter tcpserver_send"); ets_intr_lock(); if (MessageQueue_push(&sendq, conn, data, len, mem) != 0) { ets_intr_unlock(); ets_uart_printf("Failed to push data into send queue.\n"); DEBUG("exit tcpserver_send"); return -1; } ets_intr_unlock(); system_os_post(SERVER_TASK_PRIO, SERVER_SIG_TX, 0); DEBUG("exit tcpserver_send"); return 0; }
//------------------------------------------------------------------------------- // tcp2uart_int_rxtx_disable //------------------------------------------------------------------------------- void ICACHE_FLASH_ATTR tcp2uart_int_rxtx_disable(void) { tcp2uart_conn = NULL; ets_intr_lock(); // ETS_UART_INTR_DISABLE(); MEMW(); UART0_CONF1 &= ~UART_RX_FLOW_EN; // update RST UART0_INT_ENA &= ~(UART_RXFIFO_FULL_INT_ENA | UART_TXFIFO_EMPTY_INT_ENA); //clear rx and tx fifo, not ready uint32 conf0 = UART0_CONF0; UART0_CONF0 = conf0 | UART_RXFIFO_RST | UART_TXFIFO_RST; UART0_CONF0 = conf0 & (~ (UART_RXFIFO_RST | UART_TXFIFO_RST)); // update_rts0(); ets_intr_unlock(); // ETS_UART_INTR_ENABLE(); //? WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR | UART_TXFIFO_EMPTY_INT_CLR); os_timer_disarm(&uart0_tx_buf_timer); os_timer_setfn(&uart0_tx_buf_timer, (os_timer_func_t *)send_tx_buf, NULL); os_timer_disarm(&uart0_rx_buf_timer); os_timer_setfn(&uart0_rx_buf_timer, (os_timer_func_t *)loading_rx_buf, NULL); }
static void ICACHE_FLASH_ATTR tcpserver_recv_cb(void *arg, char *pdata, unsigned short len) { DEBUG("enter tcpserver_recv_cb"); uint32 remote_ip; int remote_port; char *data; ets_uart_printf("tcpserver_recv_cb\n"); remote_port = ((struct espconn *)arg)->proto.tcp->remote_port; remote_ip = *(uint32 *)((struct espconn *)arg)->proto.tcp->remote_ip; ets_uart_printf("Received %d bytes from %s:%d!\n", len, inet_ntoa(remote_ip), remote_port); ets_uart_printf("%s\n", pdata); data = (char *)os_zalloc(len + 1); /* Leave 1 byte for NULL char */ if (data == NULL) { ets_uart_printf("Failed to alloc memory for recieved data.\n\n"); DEBUG("exit tcpserver_recv_cb"); return; } /* Need to copy it because the pdata might get freed after exiting the callback. */ os_memcpy(data, pdata, len); ets_intr_lock(); if (MessageQueue_push(&recvq, (struct espconn *)arg, data, len, HEAP_MEM) != 0) { ets_intr_unlock(); ets_uart_printf("Failed to push recieved message in recv message queue.\n\n"); return; } ets_intr_unlock(); /* Post TCP_SIG_RX to server task. */ system_os_post(SERVER_TASK_PRIO, SERVER_SIG_RX, 0); ets_uart_printf("\n"); DEBUG("exit tcpserver_recv_cb"); }
//=============================================================================== // Timer: UART->TCP (UART->bufo->TCP) // loading_rx_buf() чтение fifo UART rx в буфер передачи TCP // Сигнал CTS/RTS пока не огранизован в связи с неясностью, // на какую ногу модуля его делать //------------------------------------------------------------------------------- void ICACHE_FLASH_ATTR loading_rx_buf(void) { TCP_SERV_CONN *conn = tcp2uart_conn; if(conn == NULL || conn->pbufo == NULL || conn->flag.user_flg1) return; // нет буфера + тест на повторное вхождение conn->flag.user_flg1 = 1; ets_intr_lock(); // ETS_UART_INTR_DISABLE(); MEMW(); UART0_INT_ENA &= ~ UART_RXFIFO_FULL_INT_ENA; // запретить прерывание по приему символа ets_intr_unlock(); // ETS_UART_INTR_ENABLE(); os_timer_disarm(&uart0_rx_buf_timer); if(conn->flag.busy_bufo) { // в данный момент bufo обрабатывается (передается LwIP-у)? // попробовать повторить через время ets_timer_arm_new(&uart0_rx_buf_timer, 10, 0, 0); // 10us conn->flag.user_flg1 = 0; return; } uint8 *pend = conn->pbufo + conn->sizeo; // дополнить буфер передачи символами из rx fifo while((conn->ptrtx + conn->cntro) < pend) { MEMW(); if((UART0_STATUS >> UART_RXFIFO_CNT_S) & UART_RXFIFO_CNT) conn->ptrtx[conn->cntro++] = UART0_FIFO; else break; }
// Start up a waveform on a pin, or change the current one. Will change to the new // waveform smoothly on next low->high transition. For immediate change, stopWaveform() // first, then it will immediately begin. int startWaveform(uint8_t pin, uint32_t timeHighUS, uint32_t timeLowUS, uint32_t runTimeUS) { Waveform *wave = NULL; for (size_t i = 0; i < countof(waveform); i++) { if (((pin == 16) && waveform[i].gpio16Mask==1) || ((pin != 16) && (waveform[i].gpioMask == 1<<pin))) { wave = (Waveform*) & (waveform[i]); break; } } if (!wave) { return false; } // To safely update the packed bitfields we need to stop interrupts while setting them as we could // get an IRQ in the middle of a multi-instruction mask-and-set required to change them which would // then cause an IRQ update of these values (.enabled only, for now) to be lost. ets_intr_lock(); wave->nextTimeHighCycles = MicrosecondsToCycles(timeHighUS) - 70; // Take out some time for IRQ codepath wave->nextTimeLowCycles = MicrosecondsToCycles(timeLowUS) - 70; // Take out some time for IRQ codepath wave->timeLeftCycles = MicrosecondsToCycles(runTimeUS); if (!wave->enabled) { wave->state = 0; // Actually set the pin high or low in the IRQ service to guarantee times wave->nextServiceCycle = GetCycleCount() + MicrosecondsToCycles(1); wave->enabled = 1; if (!timerRunning) { initTimer(); } ReloadTimer(MicrosecondsToCycles(1)); // Cause an interrupt post-haste } // Re-enable interrupts here since we're done with the update ets_intr_unlock(); return true; }
/** Originally from: http://harizanov.com/2014/11/esp8266-powered-web-server-led-control-dht22-temperaturehumidity-sensor-reading/ Adapted from: https://github.com/adafruit/Adafruit_Python_DHT/blob/master/source/Raspberry_Pi/pi_dht_read.c LICENSE: // Copyright (c) 2014 Adafruit Industries // Author: Tony DiCola // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. */ static void ICACHE_FLASH_ATTR pollDHTCb(void * arg){ int counter = 0; int laststate = 1; int i = 0; int bits_in = 0; // int bitidx = 0; // int bits[250]; int data[100]; data[0] = data[1] = data[2] = data[3] = data[4] = 0; //disable interrupts, start of critical section ets_intr_lock(); system_soft_wdt_feed(); /* wdt_feed(); */ // Wake up device, 250ms of high GPIO_OUTPUT_SET(OKA_DHT_IO_NUM, 1); delay_ms(20); // Hold low for 20ms GPIO_OUTPUT_SET(OKA_DHT_IO_NUM, 0); delay_ms(20); // High for 40ms // GPIO_OUTPUT_SET(2, 1); GPIO_DIS_OUTPUT(OKA_DHT_IO_NUM); os_delay_us(40); // Set pin to input with pullup // PIN_PULLUP_EN(PERIPHS_IO_MUX_GPIO2_U); // os_printf("Waiting for GPIO to drop \n"); // wait for pin to drop? while (GPIO_INPUT_GET(OKA_DHT_IO_NUM) == 1 && i < DHT_MAXCOUNT) { if (i >= DHT_MAXCOUNT) { goto fail; } i++; } // os_printf("Reading DHT\n"); // read data! for (i = 0; i < MAXTIMINGS; i++) { // Count high time (in approx us) counter = 0; while (GPIO_INPUT_GET(OKA_DHT_IO_NUM) == laststate) { counter++; os_delay_us(1); if (counter == 1000) break; } laststate = GPIO_INPUT_GET(OKA_DHT_IO_NUM); if (counter == 1000) break; // store data after 3 reads if ((i > 3) && (i % 2 == 0)) { // shove each bit into the storage bytes data[bits_in / 8] <<= 1; if (counter > BREAKTIME) { //os_printf("1"); data[bits_in / 8] |= 1; } else { //os_printf("0"); } bits_in++; } } //Re-enable interrupts, end of critical section ets_intr_unlock(); if (bits_in < 40) { // INFO os_printf("DHT sensor: Got too few bits: %d should be at least 40\n", bits_in); goto fail; } int checksum = (data[0] + data[1] + data[2] + data[3]) & 0xFF; // DEBUG /* os_printf("DHT: %02x %02x %02x %02x [%02x] CS: %02x\n", data[0], data[1],data[2],data[3],data[4],checksum); */ if (data[4] != checksum) { os_printf("DHT sensor: Checksum was incorrect after %d bits. Expected %d but got %d", bits_in, data[4], checksum); goto fail; } reading.humidity = data[0] * 256 + data[1]; reading.temperature = (data[2] & 0x7f) * 256 + data[3]; if (data[2] & 0x80) { reading.temperature *= -1; } /* reading.humidity = (data[0] << 8) | data[1]; */ /* reading.temperature = (data[2] << 7) | data[3]; */ /* reading.humidity = ((int16_t *)data)[0]; */ /* reading.temperature = ((int16_t *)data)[1]; */ /* reading.temperature = scale_temperature(data); */ /* reading.humidity = scale_humidity(data); */ // DEBUG /* os_printf("Temp = %d *C, Hum = %d %% -- 0x%04x\n", reading.temperature, reading.humidity, *(int32_t*)data); */ /* os_printf("Temp = %d *C, Hum = %d %%\n", (int)(reading.temperature * 100), */ /* (int)(reading.humidity * 100)); */ reading.success = 1; if (dht_update_cb) { dht_update_cb(&reading); } return; fail: reading.success = 0; if (dht_update_cb) { dht_update_cb(&reading); } /* os_printf("DHT sensor: Failed to get reading, dying\n"); */ }
// return values: // DHTLIB_OK // DHTLIB_ERROR_TIMEOUT int dht_readSensor(uint8_t pin, uint8_t wakeupDelay) { // INIT BUFFERVAR TO RECEIVE DATA uint8_t mask = 128; uint8_t idx = 0; uint8_t i = 0; // replace digitalRead() with Direct Port Reads. // reduces footprint ~100 bytes => portability issue? // direct port read is about 3x faster // uint8_t bit = digitalPinToBitMask(pin); // uint8_t port = digitalPinToPort(pin); // volatile uint8_t *PIR = portInputRegister(port); // EMPTY BUFFER for (i = 0; i < 5; i++) dht_bytes[i] = 0; // REQUEST SAMPLE // pinMode(pin, OUTPUT); platform_gpio_mode(pin, PLATFORM_GPIO_OUTPUT, PLATFORM_GPIO_PULLUP); DIRECT_MODE_OUTPUT(pin); // digitalWrite(pin, LOW); // T-be DIRECT_WRITE_LOW(pin); // delay(wakeupDelay); for (i = 0; i < wakeupDelay; i++) os_delay_us(1000); // Disable interrupts ets_intr_lock(); // digitalWrite(pin, HIGH); // T-go DIRECT_WRITE_HIGH(pin); os_delay_us(40); // pinMode(pin, INPUT); DIRECT_MODE_INPUT(pin); // GET ACKNOWLEDGE or TIMEOUT uint16_t loopCntLOW = DHTLIB_TIMEOUT; while (DIRECT_READ(pin) == LOW ) // T-rel { os_delay_us(1); if (--loopCntLOW == 0) return DHTLIB_ERROR_TIMEOUT; } uint16_t loopCntHIGH = DHTLIB_TIMEOUT; while (DIRECT_READ(pin) != LOW ) // T-reh { os_delay_us(1); if (--loopCntHIGH == 0) return DHTLIB_ERROR_TIMEOUT; } // READ THE OUTPUT - 40 BITS => 5 BYTES for (i = 40; i != 0; i--) { loopCntLOW = DHTLIB_TIMEOUT; while (DIRECT_READ(pin) == LOW ) { os_delay_us(1); if (--loopCntLOW == 0) return DHTLIB_ERROR_TIMEOUT; } uint32_t t = system_get_time(); loopCntHIGH = DHTLIB_TIMEOUT; while (DIRECT_READ(pin) != LOW ) { os_delay_us(1); if (--loopCntHIGH == 0) return DHTLIB_ERROR_TIMEOUT; } if ((system_get_time() - t) > 40) { dht_bytes[idx] |= mask; } mask >>= 1; if (mask == 0) // next byte? { mask = 128; idx++; } } // Enable interrupts ets_intr_unlock(); // pinMode(pin, OUTPUT); DIRECT_MODE_OUTPUT(pin); // digitalWrite(pin, HIGH); DIRECT_WRITE_HIGH(pin); return DHTLIB_OK; }
void jshInterruptOff() { ets_intr_lock(); }
static void ICACHE_FLASH_ATTR server_task(os_event_t *e) { DEBUG("enter server_task"); static bool sending = false; static bool more_fragments = false; static struct espconn *sending_conn; static uint8 *first_sending_chunk; static uint8 *current_sending_chunk; static uint16 sending_len; static enum Memtype sending_mem; struct espconn *conn; void *data; uint16 len; enum Memtype mem; switch (e->sig) { case SERVER_SIG_RX: ets_intr_lock(); if (MessageQueue_unshift(&recvq, &conn, &data, &len, &mem) == 0) { ets_intr_unlock(); tcpparser_process_data(data, len, conn); if (mem == HEAP_MEM) os_free(data); } else { ets_intr_unlock(); } break; case SERVER_SIG_TX: ets_intr_lock(); if (!sending) { if (MessageQueue_unshift(&sendq, &conn, &data, &len, &mem) == 0) { sending = true; ets_intr_unlock(); if (len <= TCP_MAX_PACKET_SIZE) { more_fragments = false; if (espconn_sent(conn, data, len) != ESPCONN_OK) ets_uart_printf("Failed to send data.\n\n"); if (mem == HEAP_MEM) os_free(data); } else { more_fragments = true; sending_conn = conn; first_sending_chunk = (uint8 *)data; current_sending_chunk = (uint8 *)data; sending_len = len; sending_mem = mem; if (espconn_sent(conn, data, TCP_MAX_PACKET_SIZE) != ESPCONN_OK) ets_uart_printf("Failed to send data.\n\n"); current_sending_chunk += TCP_MAX_PACKET_SIZE; sending_len -= TCP_MAX_PACKET_SIZE; ets_uart_printf("More data to send.\n"); } } else { ets_intr_unlock(); } } else { ets_intr_unlock(); } break; case SERVER_SIG_TX_DONE: ets_intr_lock(); if (sending && more_fragments) { ets_intr_unlock(); if (sending_len <= TCP_MAX_PACKET_SIZE) { more_fragments = false; if (espconn_sent(sending_conn, current_sending_chunk, sending_len) != ESPCONN_OK) ets_uart_printf("Failed to send data.\n\n"); if (sending_mem == HEAP_MEM) os_free(first_sending_chunk); ets_intr_lock(); sending = false; ets_intr_unlock(); } else { more_fragments = true; if (espconn_sent(sending_conn, current_sending_chunk, TCP_MAX_PACKET_SIZE) != ESPCONN_OK) ets_uart_printf("Failed to send data.\n\n"); current_sending_chunk += TCP_MAX_PACKET_SIZE; sending_len -= TCP_MAX_PACKET_SIZE; ets_uart_printf("More data to send.\n"); } } else if (MessageQueue_empty(&sendq)) { sending = false; ets_intr_unlock(); } else { sending = false; ets_intr_unlock(); system_os_post(SERVER_TASK_PRIO, SERVER_SIG_TX, 0); } break; default: break; } DEBUG("exit server_task"); }
void jshInterruptOff() { //os_printf("> jshInterruptOff\n"); ets_intr_lock(); //os_printf("< jshInterruptOff\n"); } // End of jshInterruptOff