uint32_t mp_hal_ticks_us(void) {
return system_get_time();
}
int _gettimeofday_r(struct _reent *r, struct timeval *tp, void *tzp) {
uint32_t time = system_get_time();
tp->tv_sec = time / 1000000;
tp->tv_usec = time % 1000000;
return 0;
}
uint32_t mp_hal_ticks_ms(void) {
return ((uint64_t)system_time_high_word << 32 | (uint64_t)system_get_time()) / 1000;
}
//-----------------------------------------------------------------------------------------
void static dht11_protocol(uint32 gpio_status,int cause)
{
static int actual_bit;
switch(cause) // 0 = gpio interrupt, 1=timer
{
case 0: // gpio edge
{
// disable interrupt for GPIO
gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_DISABLE);
// clear interrupt status for GPIO
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & GPIO_Pin(dht11_gpio));
// Reactivate interrupts for GPIO0
gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_ANYEGDE);
switch(sStatus)
{
case dht11_connecting:
if(GPIO_INPUT_GET(dht11_gpio))
{
// Rising edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
sStatus = dht11_mark_connecting;
}
break;
case dht11_mark_connecting:
if(!GPIO_INPUT_GET(dht11_gpio))
{
// Falling edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
sStatus = dht11_waiting_bit;
}
break;
case dht11_waiting_bit:
if(GPIO_INPUT_GET(dht11_gpio))
{
// Rising edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
sStatus = dht11_mark_bit;
actual_bit=0;
}
break;
case dht11_mark_bit:
if(! GPIO_INPUT_GET(dht11_gpio))
{
// Falling edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
if(actual_bit >= 40)
{
dht11_set_standby(); // finish OK
}
else
{
last_timer = system_get_time();
sStatus = dht11_read_bit;
}
}
break;
case dht11_read_bit:
if(GPIO_INPUT_GET(dht11_gpio))
{
// Rising edge ?? Error.
dht11_set_read_nok();
dht11_set_standby();
}
else
{
// 26-28 uS means 0. 70 uS means 1
int bit_data = ((system_get_time()-last_timer) > 40) ? 1:0;
int actual_byte = actual_bit / 8;
sRead[actual_byte] <<= 1;
sRead[actual_byte] |= bit_data;
actual_bit++;
sStatus = dht11_mark_bit;
}
break;
case dht11_standby:
case dht11_mark:
default:
dht11_set_standby();
break;
}
}
break;
case 1: //timer
switch(sStatus)
{
case dht11_mark: // end of mark
sStatus = dht11_connecting;
// GPIO as Output to high level by default.
GPIO_OUTPUT_SET(dht11_gpio,1);
GPIO_AS_INPUT(dht11_gpio);
ETS_GPIO_INTR_DISABLE();
gpio_register_set(GPIO_PIN_ADDR(dht11_gpio),
GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE) |
GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE) |
GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE));
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(dht11_gpio));
gpio_pin_intr_state_set(GPIO_ID_PIN(dht11_gpio), GPIO_PIN_INTR_ANYEGDE);
ETS_GPIO_INTR_ENABLE();
os_timer_disarm(&dht11_timer);
os_timer_arm(&dht11_timer,6,0); // maximun frame time 4.8 ms
break;
case dht11_connecting:
case dht11_mark_connecting:
case dht11_waiting_bit:
case dht11_mark_bit:
case dht11_read_bit:
default:
dht11_set_read_nok();
dht11_set_standby();
break;
}
default:
break;
}
}
// internal function to process extracted message from the received socket stream
static void ICACHE_FLASH_ATTR ctrl_stack_process_message(tCtrlMessage *msg)
{
// if we are currently in the authorization mode, process received data differently
if(authMode)
{
// receiving challenge?
// we must answer to it here
if(authPhase == 1)
{
authPhase++;
char challResponse[32];
unsigned char i = 0;
for(i=0; i<4; i++)
{
unsigned long r = system_get_time() + rand(); // TODO: make better random generation here? system_get_time() will probably have only one value in this loop...
os_memcpy(challResponse+(i*4), &r, 4);
}
os_memcpy(challResponse+16, msg->data, 16);
tCtrlMessage msg;
msg.length = 1 + 4 + 32;
msg.header = 0x00; // value not relevant during authentication procedure
msg.TXsender = 0; // value not relevant during authentication procedure
msg.data = challResponse; // contains: random 16 bytes + original challenge value
// We have nothing pending to send? (TXbase is 1 in that case)
if(authSync == 1)
{
msg.header |= CH_SYNC;
}
ctrl_stack_send_msg(&msg);
}
// receiving reply to our response on server's challenge :)
// this means we are authenticated! here we get 4 bytes of data
// containing TXserver value we need to reload. it is saved on Server
// so that we don't wear out our Flash or EEPROM memory. cool feature, right?
// also, here we need to check if Header has SYNC so that we reset TXserver to 0
else if(authPhase == 2)
{
authMode = 0;
if((msg->header) & CH_SYNC)
{
TXserver = 0;
}
else
{
os_memcpy(&TXserver, msg->data, 4);
}
if(ctrlCallbacks->auth_response != NULL)
{
ctrlCallbacks->auth_response();
}
}
}
else
{
// we received an ACK?
if((msg->header) & CH_ACK)
{
// push the received ack to callback
if(ctrlCallbacks->message_acked != NULL)
{
ctrlCallbacks->message_acked(msg);
}
}
// fresh message, acknowledge and push it to the app
else
{
// Reply with an ACK on received message. Mind the global backoff variable!
tCtrlMessage ack;
ack.header = CH_ACK;
if(backoff)
{
ack.header |= CH_BACKOFF;
}
ack.TXsender = msg->TXsender;
ack.length = 1+4; // fixed ACK length, without payload (data)
char TXserver2Save[4]; // will need this bellow
// is this NOT a notification message?
if(!(msg->header & CH_NOTIFICATION))
{
if (msg->TXsender <= TXserver)
{
ack.header &= ~CH_PROCESSED;
//uart0_sendStr("ERROR: Re-transmitted message, ignoring!\r\n");
}
else if (msg->TXsender > (TXserver + 1))
{
// SYNC PROBLEM! Server sent higher than we expected! This means we missed some previous Message!
// This part should be handled on Server's side.
// Server will flush all data after receiving X successive out-of-sync messages from us,
// and he will break the connection. Re-sync should then naturally occur
// in auth procedure as there would be nothing pending in queue to send to us.
ack.header |= CH_OUT_OF_SYNC;
ack.header &= ~CH_PROCESSED;
//uart0_sendStr("ERROR: Out-of-sync message!\r\n");
}
else
{
ack.header |= CH_PROCESSED;
TXserver++; // next package we will receive must be +1 of current value, so lets ++
// Server offers us a feature to store a copy of this TXserver on his side so that
// we don't wear out our Flash or EEPROM memory, lets do that! Thanks Server :)
// Why are we saving this? We might get powered down and we must not loose this value!
// If we do, Server will send it to us when we (re-)connect! Cool.
ack.length += 4; // extend the length of this ACK because we are appending data as well
ack.header |= CH_SAVE_TXSERVER;
os_memcpy(&TXserver2Save, &TXserver, 4);
ack.data = TXserver2Save;
}
// send reply
ctrl_stack_send_msg(&ack);
//uart0_sendStr("ACKed to a msg!\r\n");
}
else
{
ack.header |= CH_PROCESSED; // need this for code bellow to execute
//uart0_sendStr("Didn't ACK because this is a notification-type msg!\r\n");
}
// received a message which is new and as expected?
if(ack.header & CH_PROCESSED)
{
//uart0_sendStr("Got fresh message!\r\n");
// 7-12-2014 pushing system messages to ctrl_platform.c!
// push the received message to callback
if(ctrlCallbacks->message_received != NULL)
{
ctrlCallbacks->message_received(msg);
}
}
}
}
}
// Lua: tmr.now() , return system timer in us
static int tmr_now(lua_State* L){
uint32_t now = 0x7FFFFFFF & system_get_time();
lua_pushinteger(L, now);
return 1;
}
void milisec(uint32_t tempo)
{
uint32_t t = system_get_time() + (tempo*1000);
while(t > system_get_time() )
system_soft_wdt_feed ();
}
void micros_overflow_tick(void* arg) {
uint32_t m = system_get_time();
if(m < micros_at_last_overflow_tick)
++micros_overflow_count;
micros_at_last_overflow_tick = m;
}
unsigned long millis() {
uint32_t m = system_get_time();
uint32_t c = micros_overflow_count + ((m < micros_at_last_overflow_tick) ? 1 : 0);
return c * 4294967 + m / 1000;
}
STATIC mp_obj_t pyb_elapsed_micros(mp_obj_t start) {
uint32_t startMicros = mp_obj_get_int(start);
uint32_t currMicros = system_get_time();
return MP_OBJ_NEW_SMALL_INT((currMicros - startMicros) & 0x3fffffff);
}
uint32_t HAL_GetTick(void) {
return system_get_time() / 1000;
}
STATIC mp_obj_t pyb_micros(void) {
return MP_OBJ_NEW_SMALL_INT(system_get_time());
}
void ZCD_tick(){
u32 T=system_get_time();
register u32 dt1,dt2,dtm=GPIO_INPUT_GET(zeroCrossCalculator.pin_internal_gpio);
register size_t j;
size_t i;
if(dtm==zeroCrossCalculator.last_state) return;//false positive
if(T<zeroCrossCalculator.times[zeroCrossCalculator.current_time]){
for(i=0;i<times_size;++i){
zeroCrossCalculator.times[i]=0;
}
zeroCrossCalculator.current_time=times_size;
zeroCrossCalculator.last_overflow=times_size;
zeroCrossCalculator.delta_inc=0;
}
INCI(zeroCrossCalculator.current_time,times_size);
zeroCrossCalculator.times[zeroCrossCalculator.current_time]=T;
zeroCrossCalculator.last_state=dtm;
if(zeroCrossCalculator.last_overflow>0){ --zeroCrossCalculator.last_overflow;
}else{
i=zeroCrossCalculator.current_time;
dt1=zeroCrossCalculator.times[i];
dt1-=zeroCrossCalculator.times[DECI(i,times_size)];
#ifdef ZCDETECTOR_DEBUG
INCI(zeroCrossCalculator.delta_c,times_size);
zeroCrossCalculator.deltas[zeroCrossCalculator.delta_c]=dt1;
#endif
dt1+=zeroCrossCalculator.delta_inc;
if(dt1<2000){
zeroCrossCalculator.delta_inc=dt1;
DECI(zeroCrossCalculator.current_time,times_size);
}else{
MAYBE_EXIT_TO_BG;
if(dt1>15000){
zeroCrossCalculator.delta_inc=0;
}
for(dt1=0,i=zeroCrossCalculator.current_time,j=1ul<<(times_size_b-1);j;--j){
dt1+=zeroCrossCalculator.times[i];
dt1-=zeroCrossCalculator.times[DECI(i,times_size)];
DECI(i,times_size);
}
dt1+=zeroCrossCalculator.delta_inc;
zeroCrossCalculator.delta_inc=0;
dt1>>=times_size_b-1;
MAYBE_EXIT_TO_BG;
for(dt2=0,i=zeroCrossCalculator.current_time,j=1ul<<(times_size_b-1);j;--j){
dt2+=zeroCrossCalculator.times[DECI(i,times_size)];
dt2-=zeroCrossCalculator.times[DECI(i,times_size)];
}
dt2>>=times_size_b-1;
i=zeroCrossCalculator.current_time;
if(dt1>dt2){
//even if we know for sure which of these is bigger through "last_state" param,
//it is safer to test and swap these two on their own.
//last_state=0 here
SWAP(dt1,dt2);
}
dtm=dt2;
dtm-=dt1;
// dtm>>=1;//my ZCD falls to slow, but regains voltage fast at the very edge.
zeroCrossCalculator.detector_shift=dtm;
dtm=dt2;
dtm+=dt1;
dtm>>=1;
zeroCrossCalculator.halfperiod=dtm;
}
}
MAYBE_EXIT_TO_BG;
// ZCD_planFire();
#ifdef ZCDETECTOR_DEBUG
if(printdebug){
printdebug=0;
for(i=0;i<times_size;++i){
ets_uart_printf("%lx ",zeroCrossCalculator.times[i]);
}
ets_uart_printf("\n");
for(i=0;i<times_size;++i){
ets_uart_printf("%lu ",zeroCrossCalculator.deltas[i]);
}
ets_uart_printf("\nDEBUG: Dt: %lu %lu, lo: %d, s: %d\n",dt1,dt2,zeroCrossCalculator.last_overflow,zeroCrossCalculator.last_state);
ets_uart_printf("DEBUG: T: %lx, ct: %d \n",T,zeroCrossCalculator.current_time);
ets_uart_printf("DEBUG: T/2: %lu, shift: %lu \n",zeroCrossCalculator.halfperiod,zeroCrossCalculator.detector_shift);
}
#endif
}
/******************************************************************************
* FunctionName : mesh_GetStartMs
* Description : Get the time expire since the beginning of mesh initialization
Count in Ms
*******************************************************************************/
uint32 ICACHE_FLASH_ATTR
mesh_GetStartMs()
{
return (system_get_time()-LightMeshProc.start_time)/1000;
}
void mp_hal_delay_us(uint32_t us) {
uint32_t start = system_get_time();
while (system_get_time() - start < us) {
ets_event_poll();
}
}
unsigned long millis(void)
{
return system_get_time() / 1000UL;
}
uint32_t FUNC_FLASHMEM micros()
{
return system_get_time();
}
unsigned long micros(void)
{
return system_get_time();
}
uint32_t mp_hal_ticks_ms(void) {
return system_get_time() / 1000;
}
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);
static uint32_t start = 0;
uint32_t now = system_get_time();
uint32_t delta=(now - start) / USECPERTICK + 1;
switch(irparams.rcvstate){
case STATE_IDLE: //check if val =1
if(0==(gpio_status&(1<<irparams.recvpin)))goto l_Error;
irparams.rcvstate = STATE_MARK;
break;
case STATE_MARK:
//l_Error://check if new cmd come
if (MATCH_MARK(delta, NEC_HDR_MARK)){ // Initial mark
irparams.rcvstate = STATE_SPACE;
break;
}
l_Error:
irparams.rcvstate = STATE_IDLE;
os_timer_disarm(&timer);
return;
case STATE_SPACE:
// Initial space
if (MATCH_SPACE(delta, NEC_HDR_SPACE)) {
irparams.rcvstate = STATE_DATA_MARK;
irparams.BitExpected=NEC_BITS;
irparams.isRepeat=false;
break;
}
if (MATCH_SPACE(delta, NEC_RPT_SPACE)) {
irparams.rcvstate = STATE_REPEAT;
break;
}
goto l_Error;
case STATE_REPEAT:
if (MATCH_SPACE(delta, NEC_BIT_MARK)) {
//repeat previous command need check time out
if((irparams.Rpt_TimeOut-now)>((NEC_RPT_TIMEOUT-1)*USECPERTICK))return;
irparams.isRepeat=true;
irparams.buffer=irparams.PrevValue;
goto l_CMD_RETURN;
}
goto l_Error;
case STATE_DATA_MARK:
if (MATCH_SPACE(delta, NEC_BIT_MARK)) {
irparams.rcvstate = STATE_DATA;
break;
}
goto l_Error;
case STATE_DATA:
irparams.rcvstate = STATE_DATA_MARK;
irparams.buffer<<=1;
irparams.BitExpected--;
if(0==irparams.BitExpected)irparams.rcvstate = STATE_END_OF_MSG;
if (MATCH_SPACE(delta, NEC_ONE_SPACE)) {
irparams.buffer|=1;
break;
}
if (MATCH_SPACE(delta, NEC_ZERO_SPACE)) {
break;
}
goto l_Error;
case STATE_END_OF_MSG:
if (MATCH_SPACE(delta, NEC_BIT_MARK)) {
l_CMD_RETURN:
if(false==irparams.isValueReady)// skip if previous was not readet
irparams.Value=irparams.buffer;
irparams.rcvstate = STATE_IDLE;
irparams.isValueReady=true;
irparams.Rpt_TimeOut=now;
irparams.PrevValue=irparams.buffer;
return;
}
goto l_Error;
}
start = now;
os_timer_disarm(&timer);
os_timer_arm(&timer, 15, 0);
}
