Recently, the company had a project based on drug detection that required a curve display function. Since this is my weak point, as I have mostly dealt with software applications, logic, frameworks, and architectural design, I entrusted this core functionality to my junior, who is very proficient in the underlying aspects. He helped implement the basic library, and I completed the functionality required for the product based on his library.
Coincidentally, before the project, RT-Thread initiated a DIY project based on RT-Thread Nano Mini Oscilloscope. As a member of the RT-Thread community working group, I was fortunate to see the entire production process of this project and learned some ideas about LCD curve data processing and display.
The activity link is as follows:
[DIY Activity] Let’s make a Mini Oscilloscope based on RT-Thread Nano together!
Completing the curve display roughly requires the following three steps:
-
1. Data Collection -
2. Data Processing -
3. Data Display
Without further ado, let’s first look at the display effect:
In strict terms, the Bear Pi SPI screen is not very suitable for displaying curves. Firstly, the resolution is too low, and the SPI rate is also not high. If the curve display conditions are slightly demanding, it can easily lead to LCD display flickering, which is a very poor experience. However, we still have the capability to implement sensor data display.
So, we need to make some basic optimizations to the screen driver:
1. Optimize LCD Driver
1. Improve Refresh Rate
Since we need to display curves, we can only find ways to improve the screen refresh rate as much as possible. There is a register in the LCD manual that can enhance the refresh rate:
In the LCD driver initialization code, this register is configured to 60Hz by default, which is the value 0x0F.
/* Frame Rate Control in Normal Mode */
LCD_Write_Cmd(0xC6);
// LCD_Write_Data(0x0F); //60HZ
LCD_Write_Data(0x01); //111Hz to improve the refresh rateOriginally set to 0x00 for 119Hz, but after setting it, the LCD went black. Changing it to 0x01 works without issue. I haven’t found the specific reason yet; it may be a bug in the screen firmware. For now, we’ll make do with it. If anyone knows, please share in the comments.
2. Use Register Sending
/**
* @brief LCD low-level SPI send data function
*
* @param data Start address of the data
* @param size Size of data to be sent
*
* @return void
*/
static void LCD_SPI_Send(uint8_t *data, uint16_t size)
{
for(int i = 0 ; i < size ; i++)
{
*((uint8_t*)&hspi2.Instance->DR) = data[i];
while(__HAL_SPI_GET_FLAG(&hspi2, SPI_FLAG_TXE) != 1) {}
}
}
The HAL_SPI_Transmit function from the HAL library is slower, but using register sending is faster.
2. Curve Display Logic
To display curves on the LCD, you might have such questions:
My data may be in the thousands, tens of thousands; how to convert it to the corresponding screen resolution display? Where to start displaying? How to display?
A good approach is to define a fixed-length array, continuously updating data at the tail of the array, and this data will keep pushing forward. This is essentially what we call a FIFO (circular buffer) queue. Then define a new backup buffer to find the maximum and minimum values of the data in this backup buffer, calculate the scaling factor for the LCD resolution, and use the backup buffer for LCD display based on the calculation results. This is scaling according to the actual situation, also called local scaling. Below is the curve data structure for this example:
#define DATA_SIZE 240
/* Curve display area, relative to LCD width, X-axis */
#define PLOT_DISPLAY_AREA_X 51
/* Curve display area, relative to LCD height, Y-axis */
#define PLOT_DISPLAY_AREA_Y 210
#define LCD_X 240
#define LCD_Y 240
/* Curve processing */
typedef struct
{
/* Real-time curve data */
uint16_t rel_data_data[DATA_SIZE];
/* Old curve data */
uint16_t old_plot_data[DATA_SIZE];
/* New curve data */
uint16_t new_plot_data[DATA_SIZE];
} plot_data_handler ;
extern plot_data_handler plot_handler ;
To avoid flickering during a single update, we define three buffers: rel_data_data for updating real-time data, old_plot_data for the old processed display data, and new_plot_data for the newly processed display data, which achieves a double buffering effect.
3. Curve Display Implementation
3.1 Data Sampling Part
Since the curve data cache is empty at the beginning of the display, we need to initialize it to ensure the curve can be displayed directly:
smoke_value = mq2_sensor_interface.get_smoke_value(&mq2_sensor_interface);
for(int i = 0 ; i < DATA_SIZE ; i++)
plot_handler.rel_data_data[i] = smoke_value;
memcpy(plot_handler.new_plot_data, plot_handler.rel_data_data, sizeof(plot_handler.new_plot_data));
memcpy(plot_handler.old_plot_data, plot_handler.new_plot_data, sizeof(plot_handler.new_plot_data));
Next, as mentioned in the display logic, we need a circular buffer to continuously append data:
smoke_value = mq2_sensor_interface.get_smoke_value(&mq2_sensor_interface);
/* Update data to queue */
for(i = 0 ; i <= DATA_SIZE - 2 ; i++)
plot_handler.rel_data_data[i] = plot_handler.rel_data_data[i + 1];
plot_handler.rel_data_data[DATA_SIZE - 1] = smoke_value;
Thus, we have completed the basic data sampling part.
3.2 Data Processing Part
For data processing, I defined the following function to implement:
void LCD_Plot_Remap(uint16_t *cur_data, uint16_t *backup_data, uint16_t cur_data_size)cur_data represents the current real-time data packet.
backup_data represents the backup data packet.
cur_data_size represents the length of the data packet.
The real-time data packet is the unprocessed data packet, while the backup data packet is the processed data packet.
This function mainly completes the search for the maximum and minimum values of the real-time data packet and calculates the scaling factor:
Finding the maximum value:
value = 0;
for(i = 0; i < cur_data_size; i++)
if(cur_data[i] > value)
value = cur_data[i];
max = value;
Finding the minimum value:
value = cur_data[0];
for(i = 0; i < cur_data_size; i++)
if(cur_data[i] < value)
value = cur_data[i];
min = value;
Calculating the scaling factor:
max_min_diff = (float)(max - min);
scale = (float)(max_min_diff / height);
Copying the processed results into the backup data packet.
The complete implementation is as follows:
/*
cur_data: Current curve data packet to be displayed
cur_data_size: Size of the current curve data packet to be displayed
*/
void LCD_Plot_Remap(uint16_t *cur_data, uint16_t *backup_data, uint16_t cur_data_size)
{
uint32_t i = 0;
float temp = 0;
/* Maximum value of the data packet */
uint16_t max = 0;
/* Minimum value of the data packet */
uint16_t min = 0;
float scale = 0.0;
uint16_t value = 0;
float max_min_diff = 0.0;
/* Height of the curve display */
float height = PLOT_DISPLAY_AREA_Y;
char display_rel_buf[20] = {0};
char display_max_buf[20] = {0};
char display_min_buf[20] = {0};
char display_sub_buf[20] = {0};
/* Display X-axis */
for(uint8_t i = PLOT_DISPLAY_AREA_X-1 ; i < 240 ; i++)
LCD_Draw_ColorPoint(i, 239, RED);
/* Display Y-axis */
for(uint8_t i = LCD_Y-PLOT_DISPLAY_AREA_Y ; i < 240 ; i++)
LCD_Draw_ColorPoint(PLOT_DISPLAY_AREA_X-1, i, RED);
value = 0;
for(i = 0; i < cur_data_size; i++)
if(cur_data[i] > value)
value = cur_data[i];
max = value;
value = cur_data[0];
for(i = 0; i < cur_data_size; i++)
if(cur_data[i] < value)
value = cur_data[i];
min = value;
sprintf(display_rel_buf,"%04d",cur_data[DATA_SIZE-1]);
sprintf(display_max_buf,"%04d",max);
sprintf(display_min_buf,"%04d",min);
sprintf(display_sub_buf,"%04d",max-min);
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+10,LCD_X,16,16,"rel:");
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+20+10,LCD_X, 16, 16, display_rel_buf);
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+50+10,LCD_X,16,16,"max:");
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+70+10,LCD_X, 16, 16, display_max_buf);
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+100+10,LCD_X,16,16,"min:");
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+120+10,LCD_X, 16, 16, display_min_buf);
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+150+10,LCD_X,16,16,"sub:");
LCD_ShowString(5,LCD_Y-PLOT_DISPLAY_AREA_Y+170+10,LCD_X, 16, 16, display_sub_buf);
if(min > max)
return ;
max_min_diff = (float)(max - min);
scale = (float)(max_min_diff / height);
if(cur_data_size < DATA_SIZE)
return;
for(i = 0; i < DATA_SIZE; i ++)
{
temp = cur_data[i] - min;
backup_data[i] = DATA_SIZE - (uint16_t)(temp / scale) - 1;
}
}
3.3 Data Display Part
This part should be the most exciting, but its implementation is the simplest, which is to connect each data in the backup data packet obtained from the data processing part with line segments. To make the driver faster, the following processing uses register sending:
/* Display curve */
void LCD_Plot_Display(uint16_t *pData, uint32_t size, uint16_t color)
{
uint32_t i, j;
uint8_t color_L = (uint8_t) color;
uint8_t color_H = (uint8_t) (color >> 8);
if(size < DATA_SIZE) return;
for (i = PLOT_DISPLAY_AREA_X; i < DATA_SIZE - 1; i++)
{
if (pData[i + 1] >= pData[i])
{
LCD_Address_Set(i, pData[i], i, pData[i + 1]);
LCD_DC(1);
for (j = pData[i]; j <= pData[i + 1]; j++)
{
*((uint8_t*) &hspi2.Instance->DR) = color_H;
while (__HAL_SPI_GET_FLAG(&hspi2, SPI_FLAG_TXE) != 1);
*((uint8_t*) &hspi2.Instance->DR) = color_L;
while (__HAL_SPI_GET_FLAG(&hspi2, SPI_FLAG_TXE) != 1);
}
}
else
{
LCD_Address_Set(i, pData[i + 1], i, pData[i]);
LCD_DC(1);
for (j = pData[i + 1]; j <= pData[i]; j++)
{
*((uint8_t*) &hspi2.Instance->DR) = color_H;
while (__HAL_SPI_GET_FLAG(&hspi2, SPI_FLAG_TXE) != 1);
*((uint8_t*) &hspi2.Instance->DR) = color_L;
while (__HAL_SPI_GET_FLAG(&hspi2, SPI_FLAG_TXE) != 1);
}
}
}
}
4. Real-time Curve Display of Sensor Data
The implementation logic is as follows:
while (1)
{
smoke_value = mq2_sensor_interface.get_smoke_value(&mq2_sensor_interface);
/* Update data to queue */
for(i = 0 ; i <= DATA_SIZE - 2 ; i++)
plot_handler.rel_data_data[i] = plot_handler.rel_data_data[i + 1];
plot_handler.rel_data_data[DATA_SIZE - 1] = smoke_value;
/* First, paint the background black */
LCD_Plot_Display(plot_handler.old_plot_data, DATA_SIZE, BLACK);
/* Sensor data processing */
LCD_Plot_Remap(plot_handler.rel_data_data,plot_handler.new_plot_data, DATA_SIZE);
/* Sensor data curve display */
LCD_Plot_Display(plot_handler.new_plot_data, DATA_SIZE, GREEN);
/* Copy the processed backup data to the old backup data */
memcpy(plot_handler.old_plot_data, plot_handler.new_plot_data, sizeof(plot_handler.new_plot_data));
HAL_Delay(10);
}
This section of code has been synchronized to the code repository on Gitee, and the method to obtain it is as follows:
1. Create a new folder
2. Use git clone to remotely obtain the project
Project open-source repository:
https://gitee.com/morixinguan/bear-pi
I will upload all the previous projects and practice routines in the near future to share and communicate with everyone:
Public Account Fan Benefits Moment
I have secured benefits for everyone. Readers of this public account can enjoy a 10% discount when purchasing the Bear Pi development board. If you need to buy the Bear Pi or Tencent IoT development boards, just search on Taobao and tell the customer service that you are a fan of the public account: Embedded Cloud IOT Technology Circle to enjoy a 10% discount!
Past Highlights
Build a simple LCD driver framework by hand!
Experience sharing on solving ADC power display issues in embedded software
The importance of version information, etc. (Taking STM32 product development as an example)
TencentOS tiny hazardous gas detector product-level development heavyweight high-quality update
If you find this article helpful, please click<span>[Looking]</span> and share it, which is also a support for me.