Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
cb3a77b0aThis file is pinned to the selected release. Download the original to open it in your design tool.
/*send_cmd
* @Description: API function of JBD013VGA panel
* @version: 1.3
* @Autor: lmx
* @LastEditors: lmx
*/
#include "jbd013_api.h"
#include "string.h"
/**
* @description: Send command
* @paran:
* @return {*}
* @author: lmx
* @param {u8} cmd:SPI instruction of JBD013VGA panel
* 这段代码定义了一个发送命令的函数,函数名为send_cmd,
* 参数是一个u8类型的变量cmd,表示JBD013VGA面板的SPI指令。
* 在函数中,调用了spi_wr_byte函数,将cmd作为参数传递给该函数,来实现将命令发送给面板。
*/
void send_cmd(u8 cmd)
{
spi_wr_byte(cmd);
}
/**
* @description: Read the ID of the panel
* @paran:
* @return {u32}:ID of the panel
* @author: lmx
* 这段代码定义了一个读取面板ID的函数,函数名为read_id,
* 返回值是一个u32类型的变量,表示面板的ID。
* 函数内部定义了一个u32类型的变量ret和一个长度为3的u8类型数组pBuf。
* 调用了spi_rd_bytes函数,将SPI_RD_ID作为参数传递给该函数,将读取到的ID存储在pBuf数组中。
* 最后,将pBuf数组中的三个元素按照特定的方式合并为一个u32类型的ID,并返回。
*/
u32 read_id(void)
{
u32 ret;
u8 pBuf[3];
spi_rd_bytes(SPI_RD_ID, pBuf, sizeof(pBuf));
ret = pBuf[0] << 16 | pBuf[1] << 8 | pBuf[2];
return ret;
}
/**
* @description: Read the unique ID of the panel
* @paran:
* @return {*}
* @author: lmx
* @param {u8} *pBuf:The receive pointer of uid.
* The corresponding cache space of the pointer should be greater than or equal to 15bytes
* 这段代码定义了一个读取面板唯一ID的函数,函数名为read_uid,
* 没有返回值。函数接受一个u8类型的指针pBuf作为参数,表示唯一ID的接收指针。
* 在函数内部,调用了spi_rd_bytes函数,将SPI_RD_UID作为参数传递给该函数,
* 将读取到的唯一ID存储在pBuf指针指向的内存空间中。
*/
void read_uid(u8 *pBuf)
{
spi_rd_bytes(SPI_RD_UID, pBuf, 15);
}
/**
* @description: Write status register
* @paran:
* @return {*}
* @author: lmx
* @param {u8} regAddr:Register address
* @param {u8} data:Write data
* 这段代码定义了一个写状态寄存器的函数,函数名为wr_status_reg,没有返回值。
* 函数接受两个参数,一个是u8类型的寄存器地址regAddr,另一个是u8类型的写入数据data。
* 在函数内部,调用了spi_wr_bytes函数,将regAddr作为寄存器地址,&data作为写入数据并传递给该函数。
*/
void wr_status_reg(u8 regAddr, u8 data)
{
spi_wr_bytes(regAddr, &data, 1);
}
/**
* @description: Read status register
* @paran:
* @return {u8}:Register data
* @author: lmx
* @param {u8} regAddr:Register address
* 这段代码定义了一个读取状态寄存器的函数,函数名为rd_status_reg,
* 返回值是一个u8类型的寄存器数据。函数接受一个u8类型的寄存器地址regAddr作为参数。
* 在函数内部,调用了spi_rd_byte函数,将regAddr作为寄存器地址传递给该函数,并返回读取到的寄存器数据。
*/
u8 rd_status_reg(u8 regAddr)
{
return spi_rd_byte(regAddr);
}
/**
* @description: Write offset register
* @paran:
* @return {*}
* @author: lmx
* @param {u8} row:Row offset address(0~31)
* @param {u8} col:Col offset address(0~31)
* 这段代码定义了一个写偏移寄存器的函数,函数名为wr_offset_reg,没有返回值。
* 函数接受两个参数,一个是u8类型的行偏移地址row,另一个是u8类型的列偏移地址col。
* 在函数内部,定义了一个长度为2的u8类型数组pBuf,将row和col分别存储在数组中。
* 然后调用了spi_wr_bytes函数,将SPI_WR_OFFSET_REG作为寄存器地址,pBuf作为写入的数据数组,并传递给该函数。
* 接着调用了send_cmd函数发送命令SPI_SYNC,实现偏移寄存器数据的同步。
* 最后,延时1毫秒,等待同步操作完成。
*/
void wr_offset_reg(u8 row, u8 col)
{
u8 pBuf[2];
pBuf[0] = row;
pBuf[1] = col;
spi_wr_bytes(SPI_WR_OFFSET_REG, pBuf, 2);
send_cmd(SPI_SYNC); //Synchronous offset reg data
delay_ms(1); //SYNC needs 1ms time(8MHz system clock) or 0.5ms time(16MHz system clock) to finish operation.
}
/**
* @description: Read offset register
* @paran:
* @return {u16}:returnData = row << 8 | col
* @author: lmx
* 这段代码定义了一个读取偏移寄存器的函数,函数名为rd_offset_reg,返回值是一个u16类型的数据,
* 该数据的值是row左移8位后与col进行按位或操作的结果。函数没有接受任何参数。
* 在函数内部,定义了一个长度为2的u8类型数组pBuf和一个u16类型的变量ret。
* 调用了spi_rd_bytes函数,将SPI_RD_OFFSET_REG作为寄存器地址,pBuf作为接收数据的数组,并传递给该函数。
* 接着,将pBuf数组中的两个元素按照特定的方式合并为一个u16类型的数据,并将其赋值给ret变量,最后返回ret。
*/
u16 rd_offset_reg(void)
{
u8 pBuf[2];
u16 ret;
spi_rd_bytes(SPI_RD_OFFSET_REG, pBuf, sizeof(pBuf));
ret = pBuf[0] << 8 | pBuf[1];
return ret;
}
/**
* @description: Write current register
* @paran:
* @return {*}
* @author: lmx
* @param {u8} param:Write data(0~63)
* 这段代码定义了一个写入电流寄存器的函数,函数名为wr_cur_reg,没有返回值。
* 函数接受一个u8类型的参数param,表示要写入的数据(范围为0~63)。
* 在函数内部,调用了spi_wr_bytes函数,将SPI_WR_CURRENT_REG作为寄存器地址,¶m作为写入的数据并传递给该函数。
*/
void wr_cur_reg(u8 param)
{
spi_wr_bytes(SPI_WR_CURRENT_REG, ¶m, 1);
}
/**
* @description: Read current register
* @paran:
* @return {u8}:Read data
* @author: lmx
* 这段代码定义了一个读取电流寄存器的函数,函数名为rd_cur_reg,返回值是一个u8类型的数据。
* 函数没有接受任何参数。
* 在函数内部,调用了spi_rd_byte函数,将SPI_RD_CURRENT_REG作为寄存器地址传递给该函数,并返回读取到的寄存器数据。
*/
u8 rd_cur_reg(void)
{
return spi_rd_byte(SPI_RD_CURRENT_REG);
}
/**
* @description: Write luminance register
* @paran:
* @return {*}
* @author: lmx
* @param {u16} param:Write data
* When the self refresh frequency is 25Hz, param (0 ~ 21331)
* When the self refresh frequency is 50Hz, param (0 ~ 10664)
* When the self refresh frequency is 75Hz, param (0 ~ 7109)
* When the self refresh frequency is 100Hz, param (0 ~ 5331)
* When the self refresh frequency is 125Hz, param (0 ~ 4264)
* When the self refresh frequency is 150Hz, param (0 ~ 3366)
* When the self refresh frequency is 175Hz, param (0 ~ 2907)
* When the self refresh frequency is 200Hz, param (0 ~ 2558)
* 这段代码定义了一个写亮度寄存器的函数,函数名为wr_lum_reg,没有返回值。
* 函数接受一个u16类型的参数param,表示要写入的数据。
* 在函数内部,定义了一个长度为2的u8类型数组pBuf,
* 将param右移8位后的高8位存储在pBuf数组的第一个元素中,将param的低8位存储在pBuf数组的第二个元素中。
* 然后调用了spi_wr_bytes函数,将SPI_WR_LUM_REG作为寄存器地址,pBuf作为写入的数据数组,并传递给该函数。
*/
void wr_lum_reg(u16 param)
{
u8 pBuf[2];
pBuf[0] = param >> 8;
pBuf[1] = param;
spi_wr_bytes(SPI_WR_LUM_REG, pBuf, 2);
}
/**
* @description: Read luminance register
* @paran:
* @return {u16}:Read data
* @author: lmx
* 这段代码定义了一个读取亮度寄存器的函数,函数名为rd_lum_reg,返回值是一个u16类型的数据。
* 函数没有接受任何参数。在函数内部,定义了一个长度为2的u8类型数组pBuf和一个u16类型的变量ret。
* 调用了spi_rd_bytes函数,将SPI_RD_LUM_REG作为寄存器地址,pBuf作为接收数据的数组,并传递给该函数。
* 接着,将pBuf数组中的两个元素按照特定的方式合并为一个u16类型的数据,并将其赋值给ret变量,最后返回ret。
*/
u16 rd_lum_reg(void)
{
u8 pBuf[2];
u16 ret;
spi_rd_bytes(SPI_RD_LUM_REG, pBuf, sizeof(pBuf));
ret = pBuf[0] << 8 | pBuf[1];
return ret;
}
/**
* @description: Set mirror mode
* @paran:
* @return {*}
* @author: lmx
* @param {u8} param:Set mirror mode
* param = 0:Normal display
* param = 1: Mirror left and right only
* param = 2: Mirror up and down only
* param = 3: Mirror up, down, left and right at the same time
* 这段代码定义了一个设置镜像模式的函数,函数名为set_mirror_mode,没有返回值。
* 函数接受一个u8类型的参数param,表示要设置的镜像模式。在函数内部,调用了send_cmd函数,发送命令SPI_DISPLAY_DEFAULT_MODE。
* 根据param的值,判断是否需要发送SPI_DISPLAY_RL和SPI_DISPLAY_UD命令来设置左右镜像和上下镜像。
* 最后,再发送命令SPI_SYNC进行同步操作,延时1毫秒,等待同步操作完成。
*/
void set_mirror_mode(u8 param)
{
send_cmd(SPI_DISPLAY_DEFAULT_MODE);
if (param == 1 || param == 3)
{
send_cmd(SPI_DISPLAY_RL);
}
if (param == 2 || param == 3)
{
send_cmd(SPI_DISPLAY_UD);
}
send_cmd(SPI_SYNC);
delay_ms(1);
}
/**
* @description: Write the data in cache to 0
* @paran:
* @return {*}
* @author: lmx
* 这段代码定义了一个清空缓存的函数,函数名为clr_cache,没有返回值。
* 在函数内部,定义了一个长度为10的u8类型数组pBuf
* 和三个变量pBufLen、addrStep、rowCnt、colCnt。
* pBufLen的值为pBuf数组的长度,addrStep的值为pBufLen乘以2。
* 调用了memset函数,将pBuf数组的所有元素都设置为0。
* 通过两个嵌套的for循环,将pBuf数组中的数据写入缓存中的每个地址。
* 如果640除以addrStep的余数不为0,则需要额外写入一部分数据以保证完整。
*/
void clr_cache(void)
{
u8 pBuf[10];
u8 addrStep;
u32 pBufLen;
u16 rowCnt;
u16 colCnt;
pBufLen = sizeof(pBuf);
addrStep = pBufLen * 2;
memset(pBuf, 0, pBufLen);
for (rowCnt = 0; rowCnt < 480; rowCnt++)
{
for (colCnt = 0; colCnt < 640; colCnt += addrStep)
{
spi_wr_cache(colCnt, rowCnt, pBuf, pBufLen);
}
if (640 % addrStep != 0)
{
spi_wr_cache((640 - 640 % addrStep), rowCnt, pBuf, 640 % addrStep);
}
}
}
/**
* @description: Display image
* @paran:
* @return {*}
* @author: lmx
* @param {u8} *pBuf:Pointer to image data
* @param {u32} len:Length of image data(0~153600)
* 这段代码定义了一个显示图片的函数,函数名为display_image,没有返回值。
* 函数接受两个参数,一个是u8类型的指针pBuf,表示指向图片数据的指针,
* 另一个是u32类型的变量len,表示图片数据的长度(范围为0~153600)。
* 在函数内部,调用了spi_wr_cache函数,将图片数据写入缓存中。
* 然后调用send_cmd函数发送命令SPI_SYNC,实现缓存数据的同步。最后,延时1毫秒,等待同步操作完成。
*/
void display_image(u8 *pBuf, u32 len,u8 X,u8 Y)
{
spi_wr_cache(X, Y, pBuf, len); //Write data to cache
send_cmd(SPI_SYNC); //Synchronous cache data
delay_ms(1); //SYNC needs 1ms time(8MHz system clock) or 0.5ms time(16MHz system clock) to finish operation.
}
/**
* @description: Reset panel
* @paran:
* @return {*}
* @author: lmx
* 这段代码定义了一个复位面板的函数,函数名为panel_rst,没有返回值。
* 函数内部调用了send_cmd函数两次,分别发送了SPI_RST_EN和SPI_RST命令,实现了面板的复位功能。
* 最后,延时50毫秒,等待面板复位完成。
*/
void panel_rst(void)
{
send_cmd(SPI_RST_EN);
send_cmd(SPI_RST);
delay_ms(50);
}
/**
* @description: Initialize panel
* @paran:
* @return {*}
* @author: lmx
* 这段代码定义了一个初始化面板的函数,函数名为panel_init,没有返回值。
* 在函数内部,首先调用panel_rst函数进行面板复位。然后调用send_cmd函数发送命令SPI_WR_ENABLE,打开状态寄存器的写使能。
* 再调用wr_status_reg函数,写入特定的值0x10到状态寄存器中,以关闭demura。
* 通过调用clr_cache函数,将所有缓存数据清零。
* 接着调用wr_offset_reg函数设置偏移寄存器的值,分别设置四个角以及实际偏移值,将屏幕居中。
* 再调用wr_cur_reg函数设置电流寄存器的值为63。
* 最后,通过调用send_cmd函数发送命令SPI_DISPLAY_ENABLE,打开显示使能。
* 最后发送命令SPI_SYNC进行同步操作,并延时1毫秒,等待同步操作完成。
*/
void panel_init(void)
{
//Reset panel
panel_rst();
//Open status register write enable
send_cmd(SPI_WR_ENABLE);
//Close demura
wr_status_reg(SPI_WR_STATUS_REG1, 0x10);
//Set all cache data to 0
clr_cache();
//Set the offset in the upper left corner
wr_offset_reg(0, 0);
//Set the offset in the upper right corner
wr_offset_reg(0, 20);
//Set the offset in the lower left corner
wr_offset_reg(24, 0);
//Set the offset in the lower right corner
wr_offset_reg(24, 20);
//Set actual offset,center the screen
wr_offset_reg(12, 10);
//Set current reg
wr_cur_reg(63);
//Set display enable
send_cmd(SPI_DISPLAY_ENABLE);
//Synchronous setting
send_cmd(SPI_SYNC);
delay_ms(1);
}
/**
* @description: Get temperature sensor data
* @paran:
* @return {float}:Temperature data(Unit:℃)
* @author: lmx
* @param {u8} sensorId:Temperature sensor ID(Range:0~3)
* 这段代码定义了一个获取温度传感器数据的函数,函数名为get_temperature_sensor_data,
* 返回值为一个float类型的温度数据(单位:℃)。
* 函数接受一个u8类型的参数sensorId,表示温度传感器的ID(范围为0~3)。
* 在函数内部,定义了一个长度为2000的u8类型数组pBuf和一个长度为8的u8类型数组maskBuf,用于存储温度传感器数据和掩码数据。
* 还定义了一些临时变量如tmpNum、isFlag、tmpVal、i、rxBitCnt和bitCnt。
* 通过调用spi_rd_temperature_sensor函数,将sensorId作为参数传递给该函数,
* 读取面板内部温度传感器的数据,并存储在pBuf数组中。
* 接下来,通过for循环和一些逻辑判断的方式解析数据。
* 遍历pBuf数组中的每个元素,如果元素的值大于0,则将其赋值给tmpNum。
* 然后通过嵌套的for循环,遍历tmpNum的每个bit位,
* 根据特定的位操作,解析出温度数据,并将其存储在tmpVal变量中。
* 最后,通过一系列的数学计算,将tmpVal转换为温度数据(单位:℃),并返回。
*/
float get_temperature_sensor_data(u8 sensorId)
{
u8 pBuf[2000];
u8 maskBuf[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
u8 tmpNum;
u8 isFlag;
u16 tmpVal = 0;
u16 i;
char rxBitCnt = -2;
char bitCnt;
spi_rd_temperature_sensor(sensorId, pBuf, sizeof(pBuf)); //Read the data of the temperature sensor inside the panel
for (i = 0, isFlag = 0; i < 2000; i++) //Parsing data
{
if (pBuf[i] > 0)
{
tmpNum = pBuf[i];
for (bitCnt = 7; bitCnt >= 0; bitCnt--)
{
if (rxBitCnt == -2)
{
if (isFlag == 0 && ((tmpNum & maskBuf[bitCnt]) >= 1))
{
isFlag = 1;
}
else if (isFlag == 1 && ((tmpNum & maskBuf[bitCnt]) == 0))
{
isFlag = 2;
}
else if (isFlag == 2 && ((tmpNum & maskBuf[bitCnt]) == 0))
{
isFlag = 3;
}
else if (isFlag == 3 && ((tmpNum & maskBuf[bitCnt]) >= 1))
{
isFlag = 4;
rxBitCnt = 11;
continue;
}
else
{
isFlag = 0;
}
}
if (rxBitCnt >= 0)
{
tmpVal |= (((tmpNum & maskBuf[bitCnt]) >> bitCnt) << rxBitCnt);
rxBitCnt--;
if (rxBitCnt == -1)
break;
}
}
}
else
{
isFlag = 0;
}
if (rxBitCnt == -1)
break;
}
return (float)((tmpVal - 1600.1) / 7.5817); //Return temperature data(Unit:℃)
}