Implementing HTTP server configuration OLED scrolling display information based on W55MH32Q-EVB
Implementing HTTP server configuration OLED scrolling display information based on W55MH32Q-EVB
COMPONENTS
PROJECT DESCRIPTION
1. Introduction
HTTP (Hypertext Transfer Protocol) is an application-layer protocol for distributed, collaborative, hypermedia information systems. Based on the TCP/IP communication protocol, it transmits data and forms the foundation of data communication on the World Wide Web (WWW). HTTP was initially designed to provide a method for publishing and receiving HTML pages. Resources requested via HTTP or HTTPS are identified by Uniform Resource Identifiers (URIs). This is a brief introduction to the HTTP protocol. For a deeper understanding of this protocol, please refer to the introduction on the Mozilla website: HTTP Overview - HTTP | MDN
The W55MH32Q-EVB is a development board based on the W55MH32L chip. It has a 216MHz clock speed, 1MB of flash memory, and 96KB of SRAM. It also features a complete hardware TCP/IP offloading engine, allowing for Ethernet applications to be implemented with simple socket programming. Features include:
Enhanced, true random number generation, hardware encryption algorithm unit
On-chip 32-bit Arm® Cortex®-M3 core
Microcontroller with 1024KB Flash memory
10/100M Ethernet MAC and PHY, integrated full-hardware TCP/IP protocol stack engine
USB, CAN, 17 timers
3 ADCs, 2 DACs, 12 communication interfaces
Product Link: Product Details
2 Project Environment
2.1 Hardware Preparation
W55MH32Q-EVB module
Several DuPont wires
Switch or router
OLED module
One network cable
2.2 Software Environment
Example Link: https://www.w5500.com/w55mh32.html
Freescale Serial Port Assistant
Keil5
3 Hardware Connection and Solution
3.1 Hardware Connection
1. W55MH32Q-EVB_3.3V ---> OLED_VCC
2. W55MH32Q-EVB_GND ---> OLED_GND
3. W55MH32Q-EVB_SCL ---> OLED_SCL
4. W55MH32Q-EVB_SDA ---> OLED_SDA
3.2 Scheme Diagram
4. Example Modification
This example uses HTTP_Server:
Locate Webpage.h and replace its contents with the following content.
Add a function in oled.c to control the OLED display. By assigning values to the corresponding registers of the OLED, you can achieve OLED scrolling. The code is as follows:
#include "oled.h"
#include "delay.h"
#include "flash.h"
#include "oledfont.h"
#include "stdint.h"
#include "string.h"
#include "w55mh32.h"
unsigned char data[64] = "";
unsigned char is_rolling_flag = 0;
unsigned char display_flag = 0;
unsigned char startup_flag = 1;
void IIC_Start()
{
OLED_SCLK_Set();
OLED_SDIN_Set();
OLED_SDIN_Clr();
OLED_SCLK_Clr();
}
/**********************************************
//IIC Stop
**********************************************/
void IIC_Stop()
{
OLED_SCLK_Set();
// OLED_SCLK_Clr();
OLED_SDIN_Clr();
OLED_SDIN_Set();
}
void IIC_Wait_Ack()
{
// GPIOB->CRH &= 0XFFF0FFFF;
// GPIOB->CRH |= 0x00080000;
// OLED_SDA = 1;
// delay_us(1);
// OLED_SCL = 1;
// delay_us(50000);
/* while(1)
{
if(!OLED_SDA)
{
//GPIOB->CRH &= 0XFFF0FFFF;
//GPIOB->CRH |= 0x00030000;
return;
}
}
*/
OLED_SCLK_Set();
OLED_SCLK_Clr();
}
/**********************************************
// IIC Write byte
**********************************************/
void Write_IIC_Byte(unsigned char IIC_Byte)
{
unsigned char i;
unsigned char m, da;
da = IIC_Byte;
OLED_SCLK_Clr();
for (i = 0; i < 8; i++)
{
m = da;
// OLED_SCLK_Clr();
m = m & 0x80;
if (m == 0x80)
{
OLED_SDIN_Set();
}
else
OLED_SDIN_Clr();
da = da << 1;
OLED_SCLK_Set();
OLED_SCLK_Clr();
}
}
/**********************************************
// IIC Write Command
**********************************************/
void Write_IIC_Command(unsigned char IIC_Command)
{
IIC_Start();
Write_IIC_Byte(0x78); // Slave address,SA0=0
IIC_Wait_Ack();
Write_IIC_Byte(0x00); // write command
IIC_Wait_Ack();
Write_IIC_Byte(IIC_Command);
IIC_Wait_Ack();
IIC_Stop();
}
/**********************************************
// IIC Write Data
**********************************************/
void Write_IIC_Data(unsigned char IIC_Data)
{
IIC_Start();
Write_IIC_Byte(0x78); // D/C#=0; R/W#=0
IIC_Wait_Ack();
Write_IIC_Byte(0x40); // write data
IIC_Wait_Ack();
Write_IIC_Byte(IIC_Data);
IIC_Wait_Ack();
IIC_Stop();
}
void OLED_WR_Byte(unsigned dat, unsigned cmd)
{
if (cmd)
Write_IIC_Data(dat);
else
Write_IIC_Command(dat);
}
void OLED_Set_Pos(unsigned char x, unsigned char y)
{
OLED_WR_Byte(0xb0 + y, OLED_CMD);
OLED_WR_Byte(((x & 0xf0) >> 4) | 0x10, OLED_CMD);
OLED_WR_Byte((x & 0x0f), OLED_CMD);
}
void OLED_Display_On(void)
{
OLED_WR_Byte(0X8D, OLED_CMD);
OLED_WR_Byte(0X14, OLED_CMD); // DCDC ON
OLED_WR_Byte(0XAF, OLED_CMD); // DISPLAY ON
}
void OLED_Display_Off(void)
{
OLED_WR_Byte(0X8D, OLED_CMD);
OLED_WR_Byte(0X10, OLED_CMD); // DCDC OFF
OLED_WR_Byte(0XAE, OLED_CMD); // DISPLAY OFF
}
void OLED_Clear(void)
{
unsigned char i, n;
for (i = 0; i < 8; i++)
{
OLED_WR_Byte(0xb0 + i, OLED_CMD);
OLED_WR_Byte(0x00, OLED_CMD);
OLED_WR_Byte(0x10, OLED_CMD);
for (n = 0; n < 128; n++)
OLED_WR_Byte(0, OLED_DATA);
}
}
void OLED_On(void)
{
unsigned char i, n;
for (i = 0; i < 8; i++)
{
OLED_WR_Byte(0xb0 + i, OLED_CMD);
OLED_WR_Byte(0x00, OLED_CMD);
OLED_WR_Byte(0x10, OLED_CMD);
for (n = 0; n < 128; n++)
OLED_WR_Byte(1, OLED_DATA);
}
}
void OLED_ShowChar(unsigned char x, unsigned char y, unsigned char chr, unsigned char Char_Size)
{
unsigned char c = 0, i = 0;
c = chr - ' ';
if (x > Max_Column - 1)
{
x = 0;
y = y + 2;
}
if (Char_Size == 16)
{
OLED_Set_Pos(x, y);
for (i = 0; i < 8; i++)
OLED_WR_Byte(F8X16[c * 16 + i], OLED_DATA);
OLED_Set_Pos(x, y + 1);
for (i = 0; i < 8; i++)
OLED_WR_Byte(F8X16[c * 16 + i + 8], OLED_DATA);
}
else
{
OLED_Set_Pos(x, y);
for (i = 0; i < 6; i++)
OLED_WR_Byte(F6x8[c][i], OLED_DATA);
}
}
unsigned int oled_pow(unsigned char m, unsigned char n)
{
unsigned int result = 1;
while (n--)
result *= m;
return result;
}
void OLED_ShowString(unsigned char x, unsigned char y, char *chr, unsigned char Char_Size)
{
unsigned char j = 0;
while (chr[j] != '\0')
{
OLED_ShowChar(x, y, chr[j], Char_Size);
x += 8;
if (x > 120)
{
x = 0;
y += 2;
}
j++;
}
}
void OLED_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_SetBits(GPIOB, GPIO_Pin_5 | GPIO_Pin_6);
delay_ms(800);
OLED_WR_Byte(0xAE, OLED_CMD); OLED_WR_Byte(0x00, OLED_CMD);
OLED_WR_Byte(0x10, OLED_CMD);
OLED_WR_Byte(0xB0, OLED_CMD);
OLED_WR_Byte(0x40, OLED_CMD);
OLED_WR_Byte(0x81, OLED_CMD);
OLED_WR_Byte(0xFF, OLED_CMD);
OLED_WR_Byte(0xA1, OLED_CMD);
OLED_WR_Byte(0xA6, OLED_CMD);
OLED_WR_Byte(0xA8, OLED_CMD);
OLED_WR_Byte(0x3F, OLED_CMD);
OLED_WR_Byte(0xC8, OLED_CMD);
OLED_WR_Byte(0xD3, OLED_CMD);
OLED_WR_Byte(0x00, OLED_CMD);
OLED_WR_Byte(0xD5, OLED_CMD);
OLED_WR_Byte(0x80, OLED_CMD);
OLED_WR_Byte(0xD9, OLED_CMD);
OLED_WR_Byte(0xF1, OLED_CMD);
OLED_WR_Byte(0xDA, OLED_CMD);
OLED_WR_Byte(0x12, OLED_CMD);
OLED_WR_Byte(0xDB, OLED_CMD);
OLED_WR_Byte(0x30, OLED_CMD);
OLED_WR_Byte(0x8D, OLED_CMD);
OLED_WR_Byte(0x14, OLED_CMD);
OLED_WR_Byte(0xAF, OLED_CMD);
OLED_Clear();
}
void set_data(unsigned char *dat)
{
memset(data, 0, sizeof(data));
strcpy(data, dat);
}
void set_rolling_flag(unsigned char flag)
{
is_rolling_flag = flag;
}
void set_display_flag(unsigned char flag)
{
display_flag = flag;
}
unsigned char get_display_flag()
{
return display_flag;
}
// Add scroll control function
void OLED_StartHorizontalScroll(unsigned char direction, unsigned char start_page,
unsigned char end_page, unsigned char interval)
{
OLED_WR_Byte(0x2E, OLED_CMD); // Turn off scrolling
// Set scroll direction
OLED_WR_Byte(direction, OLED_CMD); // 0x26 = right scroll, 0x27 = Scroll Left
OLED_WR_Byte(0x00, OLED_CMD); // Virtual byte
OLED_WR_Byte(start_page, OLED_CMD); // Start page (0-7)
OLED_WR_Byte(interval, OLED_CMD); // Scroll interval (0-7, larger values mean slower scrolling)
OLED_WR_Byte(end_page, OLED_CMD); // End page (0-7)
OLED_WR_Byte(0x00, OLED_CMD); // Virtual byte
OLED_WR_Byte(0xFF, OLED_CMD); // Virtual byte
OLED_WR_Byte(0x2F, OLED_CMD); // Start scrolling
}
// Stop scrolling
void OLED_StopScroll(void)
{
OLED_WR_Byte(0x2E, OLED_CMD);
}
void oled_display()
{ unsigned char len = strlen(data);
unsigned char *point = data;
char buff[17] = {0};
OLED_StopScroll();
OLED_Clear();
// clear buff
for (unsigned char i = 0; i < 4; i++)
{
memset(buff, 0, 16);
if (len > 16)
{
strncpy(buff, (char *)point, 16);
OLED_ShowString(0, i * 2, buff, 16);
point += 16;
len -= 16;
}
else
{
strcpy(buff, (char *)point);
OLED_ShowString(0, i * 2, buff, 16);
break;
}
}
if (startup_flag)
{
startup_flag = 0;
} else
{
Flash_Write(data, is_rolling_flag);
}
// Start scrolling (from page 0 to page 7, scrolling left at a medium speed)
if (is_rolling_flag)
OLED_StartHorizontalScroll(0x27, 0, 7, 7);
}
Add the oled.h header file. The code is as follows. You can modify the corresponding macro definitions to customize your pins.
Add a file named flash.c to save the display content to the flash memory. This way, even if the power is turned off and then back on, the previously saved content will still be displayed. The code is as follows:
#include "Flash.h"
#include "w55mh32_flash.h"
unsigned char Flash_Write(char *data1, unsigned char data2)
{
unsigned char status = 0;
unsigned int address = startAddress;
unsigned int rolling = data2;
char str[100] = "";
strcpy(str, data1);
FLASH_Unlock();
status = FLASH_ErasePage(startAddress);
if (FLASH_COMPLETE != status)
return status;
status = FLASH_ProgramWord(address, rolling);
address += 4;
if (FLASH_COMPLETE != status)
return status;
unsigned char i;
for (i = 0; i < strlen(str) && (status == FLASH_COMPLETE); i++)
{
status = FLASH_ProgramWord(address, str[i]);
address += 4;
}
FLASH_ProgramWord(address, '\0');
FLASH_Lock();
return 0;
}
void Flash_Read(char *str, unsigned char *rolling)
{
unsigned int address = startAddress;
char temp = ' ';
*rolling = (unsigned char)*(__IO uint32_t *)address;
address += 4;
for (unsigned char i = 0; i < 64; i++)
{
temp = (char)*(__IO uint32_t *)address;
if (temp == 0)
{
str[i] = '\0';
return;
}
str[i] = temp;
address += 4;
}
}
Add the flash.h header file, as shown in the following code.
The image shows an HTTP webpage where users can enter content and choose whether to scroll the display.
The image shows the page after submission.
The image shows the OLED display result.
6. Summary This article details how to utilize the HTTP function of the W55MH32Q-EVB to retrieve OLED display content using an HTTP server and then display that content on the OLED screen. Thank you for reading! If you have any questions during the reading process, or would like to learn more about this product and its applications, please feel free to leave a message via private message or in the comments section. We will reply to your message as soon as possible to provide you with more detailed answers and assistance!
———————————————— Copyright Notice: This article is an original article by CSDN blogger "Playing with Ethernet," and is licensed under CC 4.0 BY-SA. Please include the original source link and this statement when reprinting.
Original Link: https://blog.csdn.net/2301_81684513/article/details/150491685
