ESP8266 i NONOS SDK

[squeez]

Witam zbudowałem środowisko do programowania w C tego modułu, jestem na etapie przeglądania przykładów jakie są dostarczane z tym SDK dokłądna wersja to V1.5.4. Środowisko jest poprawne kody się kompilują.

Czy ktoś już robił w czystym C na tym SDK, maiłabym kilka podstawowych pytań

-- EDIT --

Oczywiście pod latarnią najciemniej https://espressif.com/en/support/download/documents zukałem dokumentacji w dziale download i nie znalazłem tam nic, dlatego zapytałem

https://www.espressif.com/sites/default ... nce_en.pdf

[RafPe]

@squeez - tez jestem ciekawy czystego programowania w C - moglbys sie podzielic doswiadczeniami jak Ci poszlo ? Programujesz w Eclipse ? Bazujesz wylacznie na dokumentacji Espressif czy znalazles moze tez cos innego ?

[squeez]

Powracam do tematu.
Znalazłem trochę czasu i pomysł na wykorzystanie ESP8266 wprost jako samoistny twór

Generalnie SDK odpaliłem kompilacja działa, flashowanie też tylko teram mam problem żeby ożenić to z eclipse. Ma ktoś może przykładowy Makefile dla eclipse?
Przerobiłem sporo tych które znalazłem w sieci tylko problem w tym że są dość stare i pewnie działały na wcześniejszych wersjach SDK 0.9.X oraz 1.X ja żeby nie grzebać się w starych wybrałem SDK w wersji 2.X a dokładnie najnowszy na chwilę obecną 2.1.0

Jestem na etapie poznawania tego środowiska i wertuję dokumentację, coś tam już miga, bangla i wysyła ale przydało by się to zrobić nieco bardziej user frendly

[squeez]

Pozwolę sobie zapytać ... czy ktoś robił sprzętowe IR na ESP8266? póki co sam nadajnik.
W dokumencie Technica reference jest wspomniane o tym module ale po przykładowe kody odsyłają do strony producenta. Tam owszem jest ale kategoria IR transmition jest pusta (https://espressif.com/en/support/explore/sample-codes). Z kolei w dokumencie traktującym o API nie ma ani słowa

PWM jaki jest w API średni się nadaje do generowania fali 36kHz. i jak nie znajdę to zostaną mi dwa wyjścia, zrobić to programowo algo na NE555 który będzie generował przebieg a ESP już tylko samą ramkę.

[squeez]

no dobra relacja z placu boju. nadajnik IR odpalony i działa (RC5) do generowania nośnej wykorzystałem timer sprzętowy dostępny z poziomu API, wysłanie jest nieblokujące (bez delay). Teraz kolej na kolejne etapy i jak skończę projekt postaram się zaprezentować.

[squeez]

Kolejna sprawa dwa dni się męczę już
Chcę zrobić komunikację z czujnikiem DTH11. I mam problem.

Czujnik podpięty do GPIO2. Po tych 18ms GPIO konfiguruję jako wejście i przerwanie od zboczy (obojętnie jakiego), w callbacku z przerwania sprawdzam jakie zbocze i zliczam czas od poprzedniego wystąpienia zbocza, wówczas mam dwa czasy l_time i h_time odpowiadające czasom trwania poszczególnych poziomów.
Za zliczanie czasu odpowiada "wewnętrzny" zegar a odczytuję go funkcją system_get_time();

Poniżej nieco kodu, przepraszam za bałagan ale już próbowałem tylko na zboczach opadających lub tylko rosnących i kod może być nieco chaotyczny ale zależało mi żeby odebrać dane a potem się dopisuje

Kod: Zaznacz cały

// struktura na dane wykorzystywane w funkcji
typedef struct
{
   uint8 temp_H;
   uint8 temp_L;
   uint8 humi_H;
   uint8 humi_L;
   uint8 pos;
   uint32 buff;
} T_dht11;

// Funkcja wyzwaljąca odczyt
void ICACHE_FLASH_ATTR
get_dth11(void)
{
   dht11Data.pos = 0;
   os_timer_disarm( &timer_dth11 );
   os_timer_setfn( &timer_dth11, dht11_timer, 0 );
   os_timer_arm( &timer_dth11, 18, 0);

   PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
   GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 0);
}

// Callback do timera programowego
void ICACHE_FLASH_ATTR
dht11_timer(void* arg)
{
// GPIO jako wejscie
   GPIO_DIS_OUTPUT( GPIO_ID_PIN(2) );
// przerwanie od przerwania (callback)
   ETS_GPIO_INTR_DISABLE();
   ETS_GPIO_INTR_ATTACH( gpio_interrupt_handle, 0 );
   gpio_pin_intr_state_set( GPIO_ID_PIN(2), GPIO_PIN_INTR_ANYEDGE);
   ETS_GPIO_INTR_ENABLE();
}

// Callback przerwania czyli odbieranie danych
void ICACHE_FLASH_ATTR
gpio_interrupt_handle(void)
{
   uint8 h_time, l_time;
   static uint32 lasttime;
   uint32 tmptime;

   uint16 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
   GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status);

   if( gpio_status & BIT(2) )
   {
      tmptime = system_get_time();

      if( GPIO_INPUT_GET( BIT(2) ))
      {
         // narastające
         l_time = tmptime - lasttime;
      } else {
         // opadające
         h_time = tmptime - lasttime;
      }

      lasttime = tmptime;

      // poczatek bitu (stan niski około 50us)
      if ( l_time > 40 && l_time < 60 )
      {
         dht11Data.pos++;
         dht11Data.buff = (dht11Data.buff << 1);
         os_printf(" NB ");
      }

      if( dht11Data.pos )
      {
         // bit 0 (jesli stan wysoki około 20us)
         if( h_time > 18 && h_time < 30 )
         {
            os_printf("0:[%d] ", dht11Data.pos);
         }

         // bit 1 (jeśli stan wysoki około 70us)
         if ( h_time > 62 && h_time < 78 )
         {
            dht11Data.buff |= 1;
            os_printf("1:[%d] ", dht11Data.pos);
         }
      }

      // odebranie "sygnału startowego" około 80 us po nim lecą już bity z danymi
      if( !dht11Data.pos && h_time > 80 && h_time < 93)
      {
         dht11Data.pos = 1;
         dht11Data.buff = 0;
         os_printf("\n\rSYNC: ");
      }
}

Teraz to dostaję, problem w tym że nie to co bym chciał
Kod powyżej generuje w terminalu coś podobnego do tego:

SYNC: 0:[1] 0:[1] 1:[1] 0:[1] 0:[1] 1:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 1:[1] 1:[1] 0:[1] 0:[1] 0:[1] 0:[1] 0:[1] 1:[1]

W nawiasie klamrowym [] jest 1 czyli wartość dht11Data.pos która powinna się zwiększać po każdym bicie, to co jest przed nawiasem to odczytany stan 0 lub 1 jak widać coś tam zlatuje ale zamiast 40 bitów jest 27 czasami 30. Czyli część danych wysyłanych przez czujnik"przepada".

Na funkcje udostępniane przez SDK nie mam wpływu a w dokumentacji też nie znalazłem informacji czy system_get_time() jest "atomowe" tzn może jakieś "wewnętrzne" procesy ESP mają wpływ na wynik tej funkcji albo na przebieg przerwań.

W necie szukałem ale większość dostępnych materiałów dla ESP8266 to Arduino albo LUA, czyste C czyli NONOS albo RTOS jest stosunkowo mało

PS. pozwoliłem sobie edytować post i dodać więcej światła (kodu).

[squeez]

Dobra temat rozwiązany.
Najprawdopodobniej jak robiłem debugowanie po uart w trakcie odbierania danych to wówczas się nie wyrabiał i stąd było to gubienie danych (tak przypuszczam).
Żeby wydłużyć czasy nie zliczam czasu każdego stanu tylko czas pomiędzy zboczami opadającymi i nie robię "debuga na żywo", wówczas zadziałało.

Gdyby kogoś interesowało to działający kod:

Kod: Zaznacz cały

void ICACHE_FLASH_ATTR
get_dth11(void)
{
   os_printf("\nBits: %d \n", dht11Data.pos);
   os_printf("H: %d,%d T: %d,%d CRC: %d\n", dht11Data.humi_H, dht11Data.humi_L, dht11Data.temp_H, dht11Data.temp_L, dht11Data.crc);
   dht11Data.pos = 0;
   os_timer_disarm( &timer_dth11 );
   os_timer_setfn( &timer_dth11, dht11_timer, 0 );
   os_timer_arm( &timer_dth11, 18, 0);

   PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
   GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 0);
}

void ICACHE_FLASH_ATTR
dht11_timer(void* arg)
{
   // GPIO jako wejscie z pullup-em
   GPIO_DIS_OUTPUT( GPIO_ID_PIN(2) );

   ETS_GPIO_INTR_DISABLE();
   ETS_GPIO_INTR_ATTACH( gpio_interrupt_handle, 0 );
   gpio_pin_intr_state_set( GPIO_ID_PIN(2), GPIO_PIN_INTR_NEGEDGE);
   ETS_GPIO_INTR_ENABLE();
}


void ICACHE_FLASH_ATTR
gpio_interrupt_handle(void)
{
   uint8 l_time;
   static uint32 lasttime;
   uint32 tmptime;

   uint16 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
   GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status);

   if( gpio_status & BIT(2) )
   {
      tmptime = system_get_time();
      l_time = tmptime - lasttime;
      lasttime = tmptime;

      if( !dht11Data.pos && l_time > 158 && l_time < 178)
      {
         dht11Data.pos = 1;
         dht11Data.buff = 0;
      }

      if(dht11Data.pos)
      {
         if ( l_time > 70 && l_time < 80 )
         {
            dht11Data.pos++;
            dht11Data.buff = (dht11Data.buff << 1);
         }

         if ( l_time > 110 && l_time < 130 )
         {
            dht11Data.pos++;
            dht11Data.buff = (dht11Data.buff << 1);
            dht11Data.buff |= 1;
         }
      }

      if( dht11Data.pos == 33 )
      {
         dht11Data.humi_H = (dht11Data.buff >> 24);
         dht11Data.humi_L = (dht11Data.buff >> 16);
         dht11Data.temp_H = (dht11Data.buff >> 8);
         dht11Data.temp_L = (uint8) (dht11Data.buff);
      }

      if( dht11Data.pos == 41 )
      {
         ETS_GPIO_INTR_DISABLE();
         gpio_pin_intr_state_set( GPIO_ID_PIN(2), GPIO_PIN_INTR_DISABLE);
         ETS_GPIO_INTR_ENABLE();

         dht11Data.crc = (uint8) (dht11Data.buff);
      }
   }
}

Terminal ładnie wypluwa:

Bits: 41
H: 34,0 T: 25,0 CRC: 59

Bits: 41
H: 34,0 T: 25,0 CRC: 59

Bits 41 z tego względu że zliczany jest też bit "synchronizacyjny" a bitów danych jest normalnie 40

[Antystatyczny]

Niestety w rozmowie z tym czujnikiem ramy czasowe są bardzo sztywne (coś jak w 1wire). Każdy callback, każdy skok do funkcji, czy obsługa przerwań powoduje stratę czasu i to Ci może/mogło nazbyt wydłużać czasy trwania bitów lub problemy z "synchronizacją" podczas odczytu. Osobiście jeszcze nie pisałem obsługi tego czujnika, ale od jakiegoś czasu leży u mnie takowy w szufladzie i czeka na swą kolej.

Fajnie, że wrzucasz różne rozwiązania oparte o EPS8266. Dotychczas nie bardzo miałem śmiałość ruszać te moduły, ale sprawiasz, że jestem coraz bliżej przełamania lodów.

[squeez]

Ja przełamywałem lody dwa lata bo jakoś tyle czasu minęło odkąd kupiłem pierwsze dwa moduły ale ostatnio postanowiłem się jedna za to zabrać ale nie jak zazwyczaj jest to robione jako "most" UART - WIFI - UART ale jako samodzielne twory mogące proste rzeczy robić same bez dodatkowych uC.

Bo w sumie tak trochę śmiesznie żeby taki 8 bitowy procek był mózgiem operacji a 32bitowy rdzeń goniony 80 MHz czy nawet 160 MHz ze sporym flashem był "przejściówką"

[squeez]

Gdyby kogoś interesowało wysyłanie w IR protokołem RC5:

Dioda IR podpięta do GPIO5 ale oczywiście można sobie zmienić.

Kod: Zaznacz cały

typedef struct {
   uint16 data;
   int8 pos;
} T_rc5_data;

void ICACHE_FLASH_ATTR
rc5_send(uint8 addr, uint8 data)
{
   static T_rc5_data *tmpdata = &rc5Data;
   static uint8 tog;

   tog = tog^1;

   tmpdata->data = (tog << 11) | (addr << 6) | data;
   tmpdata->data |= 0x3000;
   tmpdata->pos = 13;

   //Timer dla RC5
   hw_timer_init(0, 0);
   hw_timer_set_func( rc5_count );
   hw_timer_arm(10);
}

void rc5_count(void)
{
   static uint8 licznik = 124;
   static T_rc5_data * pdata = &rc5Data;

   uint8 bit = ( pdata->data >> pdata->pos );

   if( licznik-- && (bit & 0x01) )
   {
      if(licznik<63)
      {
         GPIO_OUTPUT_SET(GPIO_ID_PIN(5), licznik%2);
      }

   } else {

      if(licznik>63)
      {
         GPIO_OUTPUT_SET(GPIO_ID_PIN(5), licznik%2);
      }
   }

   if( !licznik )
   {
      licznik = 124;
      GPIO_OUTPUT_SET(GPIO_ID_PIN(5), 0);
      pdata->pos--;
   }

   if( pdata->pos > -1 )
   {
      hw_timer_arm(10);
   } else {
      GPIO_OUTPUT_SET(GPIO_ID_PIN(5), 0);
   }
}

[squeez]

Podbiję temat ale nie chcę zakładać kolejnego bo sprawa dotyczy tego modułu i tegoż samego SDK.

Czy ktoś coś robił na bibliotece JSON-a przygotowanej w tym SDK (NONOS)?

Wczoraj próbowałem prześledzić kody z przykładu IoT tam jest ona wykorzystywana ale żadnych komentarzy a i nie mam żadnego punktu zaczepienia co do przygotowanych przez nich funkcji. niby jest w dokumentacji ale dość kiepsko opisane, bez przykładów a już zdarzyło mi się znaleźć tam kilka błędów.
Google też niewiele mówi o ESP8266 i JSON dla nonOS, dla Arduino to cała mas ale jakoś mi nie po drodze do tego arduino

[squeez]

No dobra to znowu sobie odpowiem
Podarowałem sobie póki co bibliotekę od Espressif-a dotyczącą JSON (może do niej wrócę), ale znalazłem całkiem lekkiego libsa https://github.com/zserge/jsmn

Dostosowałem do ESP, głównie zmieniłem typy zmiennych bo wszędzie były int-y albo uint więc gdzie zakresy były małe dałem uint8_t itp.
Ożeniłem to z MQTT i jak na wstępne testy działa fajnie

Jak by kogoś interesowało to ta biblioteka + prosty przykład parsowania w załączniku poniżej.
Biblioteka jest na licencji MIT więc można korzystać/modyfikować.

jsnm-esp8266.7z

[dambo]

super - sprawdzę potem bibliotekę niestety w kwestii NONOSa się nie umiem wypowiedzieć, bo nie z nim (jeszcze) nie robiłem, ale wątek śledze :p