ESP32 Forum

Code: Select all

//  Main function: Test only without littlevgl yet.
void main( )
{

    lv_area_t area;

    area.x1 = 0x0010;
    area.x2 = 0x013f;    
    area.y1 = 0x0005;    
    area.y2 = 0x01df;   
    
    while(1)
    {
        display_flush ( NULL, &area );   

        // vTaskDelay( 1000 / portTICK_PERIOD_MS );  
    }
}	

void display_flush ( lv_disp_drv_t* drv, lv_area_t* area ) 
{  
    static bool flag = 1;
    flag = !flag;
  
        
    if ( flag == 0 )
    {        
        commands_to_init_pixels_write ( area );    // fills command buffer with some display commands.

        i2s_lcd_write_pixels_a ( (uint32_t) 15360 );          
    }
    else
    {     
        commands_to_init_pixels_write ( area ); 

        i2s_lcd_write_pixels_b ( (uint32_t) 15360 );           
    }
}    


int i2s_lcd_write_pixels_a ( uint32_t length )   // length = bytes number. length <= 15360. 2 bytes per pixel. 
{
    uint32_t i;
    uint8_t* ptr;  

    if ( length > pixels_size_in_bytes )     
    {
        printf( "error: length > pixels_size_in_bytes.\n\n" );
        return -1;
    }     

    ptr = (uint8_t *) &buffer_a;    // buffer_a are lv_color_t(uint16_t) the buffer registered to littlevgl driver.

    for ( i = 0 ; i < length ; i = i + 2 )   
    {        
        buf_a[ i ] = ptr[ i ];                  // buf_a are uint32_t buffer.    
        buf_a[ i + 1 ] = ptr[ i + 1 ];        
    }        
              
    fill_dma_descriptor_a( length );               
    fill_dma_descriptor_command ( 11 );  
    

Are the shared resource i2s0 free ?

If i2s0 is free, blocks access to the i2s peripheral and calls the task "task_send_buffer_a_to_display ()"
to fire the dma transfer. After the dma ends, it releases access to the i2s peripheral within the dma interrupt (i2s is still sending data through the physical port, because of the 64 byte fifo memory).

If i2s0 is not free, the task need waiting here until "dma/i2s" isr subroutine send message(unlock). 
Here the function did not init dma transfer, but need return from this function i think ( confuse ).

    return 2019;
}

////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// tasks can be static inline ?


static inline void task_send_buffer_a_to_display( )   
{
    
    i2s_dma_trans_start_interrupt( (uint32_t) &dma_desc_buf_command );
    while(!I2SX.state.tx_idle);  // Wait the peripheral i2s stay free. It is not worth switching tasks on FreeRtos here because sending 11 bytes takes = ~ 1 us and the TICKRATE is around 1 ms - 10 ms.
    
    pixels_flag = 1;   // Informs that it will transfer pixels and not commands. Reset inside "i2s/dma" isr.

    i2s_dma_trans_start_interrupt( (uint32_t) &dma_desc_buf_a[0] );   
}


Same for "int i2s_lcd_write_pixels_b ( uint32_t length )" and for "static inline void task_send_buffer_b_to_display( )" .


static void IRAM_ATTR i2s_isr ( ) 
{   

    if ( I2SX.int_st.out_eof )
    {

        if ( pixels_flag )  // send pixels flag indication.
        {    
            pixels_flag = 0;          
            
            lv_disp_t * disp = lv_refr_get_disp_refreshing();
            lv_disp_flush_ready(&disp->driver);  


            // Release i2s/dma resource. Cannot use mutex inside isr.
            // xTaskNotifyFromISR();  // Notify the task to init dma transfer immediately if the other buffer is already ready to send.  
        }          

    }
   
    I2SX.int_clr.val = I2SX.int_st.val;
}  

Code: Select all

  //copy of the buffer
    for ( i = 0 ; i < length ; i = i + 2 )   
    {        
        buf_a[ i ] = ptr[ i ];                  // buf_a are uint32_t buffer.    
        buf_a[ i + 1 ] = ptr[ i + 1 ];        
    }        
              
    fill_dma_descriptor_a( length );       // filling of the dma descriptor for pixels write.               
    fill_dma_descriptor_command ( 11 );    // filling of the dma descriptor for commands write.


    lv_disp_t * disp = lv_refr_get_disp_refreshing();

    if ( i2s_free )    //  i2s free = 1. i2s not free = 0.
    {
        Blocks access to i2s.

        task_send_buffer_a_to_display( );    // start dma transfer   
   
        lv_disp_flush_ready(&disp->driver); 
    }
    else
    {
        Wait for the i2s module to be free( Stay here until dma isr Task Notification ? ).  
        
        Blocks access to i2s.   

        task_send_buffer_a_to_display( );    // start dma transfer

        lv_disp_flush_ready(&disp->driver);
    }

Code: Select all

volatile lldesc_t dma_descriptor; // assuming one is enough to update entire display, maybe you need some other descriptor that holds some command data or something
volatile bool dma_active;

void my_flush_cb(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
  while (dma_active) { } // busy-wait for any existing DMA operation to finish

  dma_descriptor.addr = color_p;
  dma_descriptor.length = length; // calculated from 'area'
  // (may need to do more calcs here or configure a command to send, but this is still probably a small amount of work

  // set I2S address to &dma_descriptor (can do this once in init if you like)  

  // trigger I2s operation to start
  
  dma_active = true;
  
  lv_disp_flush_ready(); // in a double buffering setup, this tells LVGL it can start using the other buffer for graphics updates.
}

void i2s_isr() {
   if (/*this I2S DMA operation is done*/) {
     dma_active = false;
   }
}

Code: Select all

//DMA idle flag
int dma_idle_flag = 0;
//We used the out_eof interrupt, but the eof interrupt was not generated before the transfer started,
// so we need to start the DMA ourselves for the first transfer.
int trans_set_up_flag = 0;

static inline void task_send_buffer_a_to_display( )   
{
    uint32_t some_thing_from_isr;
    /*
        `some_thing_from_isr` can be a buffer that the CPU can render.
    */
    xQueueReceive(to_task_queue, (void * )&some_thing_from_isr, portMAX_DELAY);
    /*
        do something    
    */
    if(trans_set_up_flag == 1) {
        uint32_t some_thing_to_isr;
        /* `some_thing_to_isr` can be a buffer that has already been rendered.
        */
        xQueueSend(to_isr_queue, &some_thing_to_isr, portMAX_DELAY);
        if(dma_idle_flag == 1) {
            while(!I2SX.state.tx_idle);
            //re-enable out_eof isr
            I2SX.int_ena.out_eof = 1;
        }
    } else {
        trans_set_up_flag = 1;
        /*
            put your code to configure DMA linked list, start DMA transfer.
        */
        I2SX.int_ena.out_eof = 1;
    }
}

static void IRAM_ATTR i2s_isr ( ) 
{   
    portBASE_TYPE high_priority_task_awoken;
    if ( I2SX.int_st.out_eof )
    {
        uint32_t some_thing_from_task;
        //data is not ready
        if(xQueueReceiveFromISR(to_isr_queue, &some_thing_from_task, &high_priority_task_awoken) != pdTRUE) {
            //Disable out_eof interrupt, re-enable in task_send_buffer_a_to_display
            I2SX.int_ena.out_eof = 0;
            dma_idle_flag = 1;
        } else {

            //restart DMA in ISR
            lv_disp_t * disp = lv_refr_get_disp_refreshing();
            lv_disp_flush_ready(&disp->driver);  
            I2SX.int_clr.val = I2SX.int_st.val;
        }
        uint32_t some_thing_to_task;
        xQueueSendFromISR(to_task_queue, (void * )&some_thing_to_task, &high_priority_task_awoken);
    }
        if (high_priority_task_awoken == pdTRUE) {
        portYIELD_FROM_ISR();
    }
} 

Code: Select all

    ptr = (uint8_t *) &buffer_a;    // buffer_a are uint16_t.

    for ( i = 11, j = 0 ; i < length + 11 ; i = i + 2, j = j + 2 )    // Takes 1,030 ms when length = 15360 bytes.
    {                                                                                                  
        buf_a[ i ]     = ptr[ j ] | 0x000;    // "buf_a[ i ] = ptr[ j ] | 0x000" to set the bit8 pin (i2s module inverted signal) that is used to control the DC signal.
        buf_a[ i + 1 ] = ptr[ j + 1 ] | 0x000;    // "buf_a[ i + 1 ] = ptr[ j + 1 ] | 0x000" to set the bit8 pin (i2s module inverted signal) that is used to control the DC signal.
    }

    fill_dma_descriptor_a( length + 11 );
 
// i2s are free ????           
    while( i2s_free == 0 );    //  i2s are not free. Put timeout maybe here ?????           
                                        //  Wait for the i2s module to be free( Stay here until dma isr Task Notification ? ).  
       
    i2s_free = 0;    // block i2s/dma resource.
    
    i2s_dma_trans_start_interrupt( (uint32_t) &dma_desc_buf_a[0] );    // start dma transfers ( commands and pixels ).   


    disp = lv_refr_get_disp_refreshing( );    
    lv_disp_flush_ready(&disp->driver); 

Code: Select all

    ptr = (uint8_t *) &buffer_b;    // buffer_b are uint16_t.

    for ( i = 11, j = 0 ; i < length + 11 ; i = i + 2, j = j + 2 )    // Takes 1,030 ms when length = 15360 bytes.
    {                                                                                                  
        buf_b[ i ]     = ptr[ j ] | 0x000;    // "buf_b[ i ] = ptr[ j ] | 0x000" to set the bit8 pin (i2s module inverted signal) that is used to control the DC signal.
        buf_b[ i + 1 ] = ptr[ j + 1 ] | 0x000;    // "buf_b[ i + 1 ] = ptr[ j + 1 ] | 0x000" to set the bit8 pin (i2s module inverted signal) that is used to control the DC signal.
    }

    fill_dma_descriptor_b( length + 11 );
 
// i2s are free ????           
    while( i2s_free == 0 );    //  i2s are not free. Put timeout maybe here ?????           
                                         //  Wait for the i2s module to be free( Stay here until dma isr Task Notification ? ).  
       
    i2s_free = 0;    // block i2s/dma resource.
    
    i2s_dma_trans_start_interrupt( (uint32_t) &dma_desc_buf_b[0] );    // start dma transfers ( commands and pixels ).   


    disp = lv_refr_get_disp_refreshing( );    
    lv_disp_flush_ready(&disp->driver); 

Code: Select all

static void IRAM_ATTR i2s_isr ( )    // All enabled i2s module interrupts points here ???? I think so. 
{   
   
    if ( I2SX.int_st.out_eof )       
    {                             
           
        while(!I2SX.state.tx_idle);    // dma interrupt. i2s still sending bytes through the physical bus, because 64 fifo buffer.
 
        I2SX.conf.tx_start = 0;    
        I2SX.conf.tx_reset = 1;        
        I2SX.conf.tx_reset = 0;    

        i2s_free = 1;    // releases the i2s resource.        
    }
    

    if ( I2SX.int_st.out_dscr_err )
    {
        ESP_EARLY_LOGE ( "I2S_TAG", "dma error, interrupt status: 0x%08x", I2SX.int_st.val );  
     
// Needless to say, it is not advised to use printf and other output functions in ISRs. For debugging purposes, use ESP_EARLY_LOGx  
macros when logging from ISRs. Make sure that both TAG and format string are placed into DRAM in that case.
    }
 
 
    I2SX.int_clr.val = I2SX.int_st.val;
}