ESP8266: Minimum I2S code

Question: What's the most convoluted way to flash an LED on an ESP8266?
Answer: Using DMA (Direct Memory Access) and to output to a GPIO using the I2S protocol of course!

Outputting memory straight to an LED using I2S 

I2S (not to be confused with I2C!) is an audio protocol for transmitting data streams (link).  Rather than other data transmission protocols where we are required to send data byte by byte, which might result in interrupted transmission, I2S allows us to stick a load of data in memory and the I2S hardware dutifully spits it out directly to a pin with no software intervention (hence Direct Memory Access).  The data is packaged typically in 32-bits, comprised of 16-bits for the left audio channel, and 16-bits for the right audio channel.  The protocol consists of three outputs; the data bits (SD), the data bit-clock (SCLK), and a signal (WS) that toggles every word of data, in order to tell the audio hardware to differentiate between the left and right data-stream.

The ESP8266 has built-in I2S hardware, meaning we can use the protocol to spit out a continuous datastream of whatever we desire!  This has been used to great effect with an ESP8266 MP3 decoder (https://github.com/espressif/ESP8266_MP3_DECODER) and to creative ends to accurately control the timings for addressable WS2812b LEDs (https://electronut.in/nrf52-i2s-ws2812/)

The ESP8266 pins for I2S are:
Data bits (SD) = GPIO3/RX0
Data bit-clock (SCK) = GPIO15
Word select (WS) = GPIO2/TX1

Minimum code
What is the minimum code required for DMA I2S output?  I took my cue from a discussion here. The code didn't work straight away but was easily corrected to work - it is important to check that the output buffers are not full and waiting (with a non_blocking call) until they are available for writing.  Below is all the code we need to output data with the I2S protocol.  In this example, the data rate is set (double words per second, rather than bits per second).  Setting it to 10,000 here means that 10,000 * 32 bits are output per second (=320,000 bits/sec).  In this example we are filling blocks of memory either with runs of 0x00000000 or 0xFFFFFFFF and toggling between them every 4096 double-words.  As the double-word rate is set as 10,000, changing every 4096 double-words will give us a pin toggle every 0.4096 seconds.  Because we are running the counter to 50,000, the flashing will last for 5 seconds.

I2S is started and the buffers are filled with a runs of 0x00000000 and 0xFFFFFFFF.  After programming the ESP8266 in the Arduino GUI, an LED can be hooked up to the data bit pin (GPIO3/RX0 - note you can't of course use this to receive serial UART data at this point).  The result is a flashing LED (wow!) as the runs of 0s and 1s are thrown out of the data stream.  We need to "yield()" every now and then to allow the ESP8266 to run background tasks, otherwise the watchdog will cause a reset.  The outputDMA function is called every 3 seconds from the main loop.

#include <i2s.h>
#include <i2s_reg.h>

#define write_sample(data) while (i2s_write_sample_nb(data)==0)

void setup()
{
    Serial.begin(115200);
    
    pinMode(3, OUTPUT); // Override default Serial initiation
    digitalWrite(3,0); // Set pin low
}

void loop()
{
    static unsigned long last = millis();
    if (millis() - last > 3000) {
      outputDMA();
      last = millis();
    }
}

void outputDMA(void)
{
   i2s_begin();
   i2s_set_rate(10000);

   uint8_t state=0;
   for (int i=0; i<50000;i++) 
   {
    state = (i >> 12)%2; // Toggle every 4096 double-words
    if (state)
      write_sample(0xffffffff);
    else
      write_sample(0x00000000);
      
    if ((i % 1000) == 0) yield(); // without this get WDT resets
   }
   i2s_end();
}

How easy is that?!  Easy-peasy, that's what!  If we want to get a bit more flash (pun not intended), we can use a 5-bit fake pwm as below.  In this case the LED is seen to glow.  Clearly this is all somewhat overkill for something so simple, but with this minimal code framework it should be easy to output other interesting data streams...!

void outputDMA(void)
{
   i2s_begin();
   i2s_set_rate(50000); // Rate set to 50,000 lots of 32-bits per sec

   uint8_t pwm_index=0;
   for (int i=0; i<65536; i++) //(0 - (2^16-1))
   {
    pwm_index = i>>11;
    if (pwm_index>31) pwm_index = 63-pwm_index;
    if (pwm_index<0) pwm_index =0;
    
    write_sample(fakePwm[pwm_index]);
    
   if ((i % 1000) == 0) yield(); // without this get WDT resets
   }
   i2s_end();
}

UPDATE: 

I have now used this I2S technique to send infra-red control signals accurately using the ESP8266, which coupled with Alexa control, enabled the creation of the voice-activated TV and projector control, the "IR-egg"!

Enjoy ESP8266 content? You might also enjoy:

• Using Alexa to control your ESP8266 project
• Update ESP8266 program over WiFi (Over The Air updates)
• Sending Tweets with your ESP8266

Explore my other ESP8266 blog posts here