这里是SwetyCore的博客

Hello World

Sun, 06 Mar 2022 00:00:00 +0000

Welcome to Hugo theme Stack. This is your first post. Edit or delete it, then start writing!

For more information about this theme, check the documentation: https://docs.stack.jimmycai.com/

Want a site like this? Check out hugo-theme-stack-stater

Photo by Pawel Czerwinski on Unsplash

Hello World

Sun, 06 Mar 2022 00:00:00 +0000

Welcome to Hugo theme Stack. This is your first post. Edit or delete it, then start writing!

For more information about this theme, check the documentation: https://docs.stack.jimmycai.com/

Want a site like this? Check out hugo-theme-stack-stater

Photo by Pawel Czerwinski on Unsplash

对于小脚丫驱动 OLED12832（SSD1306）代码的研究笔记

Tue, 07 Dec 2021 23:17:54 +0000

对于小脚丫驱动 OLED12832（SSD1306）代码的研究笔记。

内容为个人理解，不一定正确。

1. 数据手册

SSD1306数据手册/SSD1306规格书与控制芯片手册.zip · SwetyCore/个人网盘01 - Gitee.com

2. 分析

连线

引脚	作用
oled_dcn	这是数据/命令控制引脚。当它被拉高(即连接到VDD)，数据D[7:0]作为数据处理。当它被拉低时，D[7:0]处的数据将被传输到命令寄存器。在I2C模式下，该引脚作为SA0来选择从地址。当选择三线串行接口时，此引脚必须连接到VSS。具体与单片机接口信号的关系请参考定时特性。
oled_dat
oled_csn	这个引脚是芯片选择输入。(低电平有效)

	input				clk,		//12MHz系统时钟
	input				rst_n,		//系统复位，低有效
	
	input [7:0]	        data,		//
	output	reg			oled_csn,	//OLCD液晶屏使能
	output	reg			oled_rst,	//OLCD液晶屏复位
	output	reg			oled_dcn,	//OLCD数据指令控制
	output	reg			oled_clk,	//OLCD时钟信号
	output	reg			oled_dat	//OLCD数据信号

变量对照表

变量名	作用
INIT_DEPTH	初始化的命令的数量
IDLE，MAIN，INIT，SCAN，WRITE ， DELAY	模块工作状态（值）
HIGH/LOW，DATA/CMD	高/低电平，数据/指令选择
[7:0] cmd [24:0]	存储初始化屏幕指令
[39:0] mem [122:0];	存储 5*8 字库
[7:0] y_p，x_ph，x_pl;	定位列页地址，定位行地址低位，定位行地址高位
[(8*21-1):0] char;	存储要显示的字
[7:0] num, char_reg;	要显示的字数量，？将要发送到oled的数据
[4:0] cnt_main, cnt_init, cnt_scan, cnt_write;	各种模块工作状态的子状态（名)
[15:0] num_delay, cnt_delay, cnt;	delay计数，delay设定值，指令发送计数
[5:0] state, state_back;	模块工作状态（名），执行完后要回到的状态

模块状态机分析

空闲(idle状态)

各种变量的初始化

IDLE:begin
	cnt_main <= 1'b0; cnt_init <= 1'b0; cnt_scan <= 1'b0; cnt_write <= 1'b0;
	y_p <= 1'b0; x_ph <= 1'b0; x_pl <= 1'b0;
	num <= 1'b0; char <= 1'b0; char_reg <= 1'b0;
	num_delay <= 16'd5; cnt_delay <= 1'b0; cnt <= 1'b0;
	oled_csn <= HIGH; oled_rst <= HIGH; oled_dcn <= CMD; oled_clk <= HIGH; oled_dat <= LOW;
	state <= MAIN; state_back <= MAIN;
end

屏幕初始化( init 状态)


	INIT:begin	//初始化状态
		case(cnt_init)
			5'd0:	begin oled_rst <= LOW; cnt_init <= cnt_init + 1'b1; end	//复位有效
			//rst 引脚拉低，进入下一个状态。
			5'd1:	begin num_delay <= 16'd25000; state <= DELAY; state_back <= INIT; cnt_init <= cnt_init + 1'b1; end	//延时大于3us
			5'd2:	begin oled_rst <= HIGH; cnt_init <= cnt_init + 1'b1; end	//复位恢复
				//rst 拉高
			5'd3:	begin num_delay <= 16'd25000; state <= DELAY; state_back <= INIT; cnt_init <= cnt_init + 1'b1; end	//延时大于220us
			5'd4:	begin 
			//发送data
				if(cnt>=INIT_DEPTH) begin	//当25条指令及数据发出后，配置完成
cnt <= 1'b0;
cnt_init <= cnt_init + 1'b1;
				end else begin	
cnt <= cnt + 1'b1; num_delay <= 16'd5;
oled_dcn <= CMD; char_reg <= cmd[cnt]; state <= WRITE; state_back <= INIT;
end
				end
			5'd5:	begin cnt_init <= 1'b0; state <= MAIN; end	//初始化完成，返回MAIN状态
			default: state <= IDLE;
		endcase
	end

Main状态

SCAN:begin	//刷屏状态，从RAM中读取数据刷屏
	if(cnt_scan == 5'd11) begin
		if(num) cnt_scan <= 5'd3;
		else cnt_scan <= cnt_scan + 1'b1;
	end else if(cnt_scan == 5'd12) cnt_scan <= 1'b0;
	else cnt_scan <= cnt_scan + 1'b1;
	case(cnt_scan)
		5'd 0:	begin oled_dcn <= CMD; char_reg <= y_p; state <= WRITE; state_back <= SCAN; end		//定位列页地址
		5'd 1:	begin oled_dcn <= CMD; char_reg <= x_pl; state <= WRITE; state_back <= SCAN; end	//定位行地址低位
		5'd 2:	begin oled_dcn <= CMD; char_reg <= x_ph; state <= WRITE; state_back <= SCAN; end	//定位行地址高位

		5'd 3:	begin num <= num - 1'b1;end
		5'd 4:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
		5'd 5:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
		5'd 6:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
		5'd 7:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][39:32]; state <= WRITE; state_back <= SCAN; end
		5'd 8:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][31:24]; state <= WRITE; state_back <= SCAN; end
		5'd 9:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][23:16]; state <= WRITE; state_back <= SCAN; end
		5'd10:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][15: 8]; state <= WRITE; state_back <= SCAN; end
		5'd11:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][ 7: 0]; state <= WRITE; state_back <= SCAN; end
   	5'd12:	begin state <= MAIN; end
   	default: state <= IDLE;
   endcase

end
```

Delay状态？

DELAY:begin	//延时状态
	if(cnt_delay >= num_delay) begin
		cnt_delay <= 16'd0; state <= state_back; 
	end else cnt_delay <= cnt_delay + 1'b1;
end
				default:state <= IDLE;

Write状态

WRITE:begin	//WRITE状态，将数据按照SPI时序发送给屏幕
	if(cnt_write >= 5'd17) cnt_write <= 1'b0;
	else cnt_write <= cnt_write + 1'b1;
	case(cnt_write)
		5'd 0:	begin oled_csn <= LOW; end	//9位数据最高位为命令数据控制位
		5'd 1:	begin oled_clk <= LOW; oled_dat <= char_reg[7]; end	//先发高位数据
		5'd 2:	begin oled_clk <= HIGH; end
		5'd 3:	begin oled_clk <= LOW; oled_dat <= char_reg[6]; end
		5'd 4:	begin oled_clk <= HIGH; end
		5'd 5:	begin oled_clk <= LOW; oled_dat <= char_reg[5]; end
		5'd 6:	begin oled_clk <= HIGH; end
		5'd 7:	begin oled_clk <= LOW; oled_dat <= char_reg[4]; end
		5'd 8:	begin oled_clk <= HIGH; end
		5'd 9:	begin oled_clk <= LOW; oled_dat <= char_reg[3]; end
		5'd10:	begin oled_clk <= HIGH; end
		5'd11:	begin oled_clk <= LOW; oled_dat <= char_reg[2]; end
		5'd12:	begin oled_clk <= HIGH; end
		5'd13:	begin oled_clk <= LOW; oled_dat <= char_reg[1]; end
		5'd14:	begin oled_clk <= HIGH; end
		5'd15:	begin oled_clk <= LOW; oled_dat <= char_reg[0]; end	//后发低位数据
		5'd16:	begin oled_clk <= HIGH; end
		5'd17:	begin oled_csn <= HIGH; state <= DELAY; end	//
		default: state <= IDLE;
	endcase
end

上升沿发送数据，共发送八位。

Scan

SCAN:begin	//刷屏状态，从RAM中读取数据刷屏
	if(cnt_scan == 5'd11) begin
		if(num) cnt_scan <= 5'd3;
		else cnt_scan <= cnt_scan + 1'b1;
	end else if(cnt_scan == 5'd12) cnt_scan <= 1'b0;
	else cnt_scan <= cnt_scan + 1'b1;
	case(cnt_scan)
		5'd 0:	begin oled_dcn <= CMD; char_reg <= y_p; state <= WRITE; state_back <= SCAN; end		//定位列页地址
		5'd 1:	begin oled_dcn <= CMD; char_reg <= x_pl; state <= WRITE; state_back <= SCAN; end	//定位行地址低位
		5'd 2:	begin oled_dcn <= CMD; char_reg <= x_ph; state <= WRITE; state_back <= SCAN; end	//定位行地址高位

		5'd 3:	begin num <= num - 1'b1;end
		5'd 4:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
		5'd 5:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
		5'd 6:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8(占三位？？？)
		5'd 7:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][39:32]; state <= WRITE; state_back <= SCAN; end
		5'd 8:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][31:24]; state <= WRITE; state_back <= SCAN; end
		5'd 9:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][23:16]; state <= WRITE; state_back <= SCAN; end
		5'd10:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][15: 8]; state <= WRITE; state_back <= SCAN; end
		5'd11:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][ 7: 0]; state <= WRITE; state_back <= SCAN; end
		5'd12:	begin state <= MAIN; end
		default: state <= IDLE;
	endcase
end

mem[char[(num*8)+:8]][ 7: 0] 的理解:

mem为字库（二维列表）

char存有字符串八位二进制 ASCI 表示

假设 char 为"—————-" (16个“ - ”)

“-”的asci码为45 对应 mem[ 45] = {8'h08, 8'h08, 8'h08, 8'h08, 8'h08}; // 45 -

此时 num 为16，[(num*8)+:8] 即为从 16*8 位置开始，取8位，刚好是 45 。

然后 num 逐次减一直至取完第一个字符的 ASCI 码。

3. 原代码

module oled12832
(
	input				clk,		//12MHz系统时钟
	input				rst_n,		//系统复位，低有效
	
	input [7:0]	        data,		//
	
	output	reg			oled_csn,	//OLCD液晶屏使能
	output	reg			oled_rst,	//OLCD液晶屏复位
	output	reg			oled_dcn,	//OLCD数据指令控制
	output	reg			oled_clk,	//OLCD时钟信号
	output	reg			oled_dat	//OLCD数据信号
);
	
	localparam INIT_DEPTH = 16'd25; //LCD初始化的命令的数量
	localparam IDLE = 6'h1, MAIN = 6'h2, INIT = 6'h4, SCAN = 6'h8, WRITE = 6'h10, DELAY = 6'h20;
	localparam HIGH	= 1'b1, LOW = 1'b0;
	localparam DATA	= 1'b1, CMD = 1'b0;
	
	reg   [7:0] cmd [24:0];
	reg   [39:0] mem [122:0];
	reg	[7:0]	y_p, x_ph, x_pl;
	reg	[(8*21-1):0] char;
	reg	[7:0]	num, char_reg;				//
	reg	[4:0]	cnt_main, cnt_init, cnt_scan, cnt_write;
	reg	[15:0]	num_delay, cnt_delay, cnt;
	reg	[5:0] 	state, state_back;
	
	always@(posedge clk or negedge rst_n) begin
		if(!rst_n) begin
			cnt_main <= 1'b0; cnt_init <= 1'b0; cnt_scan <= 1'b0; cnt_write <= 1'b0;
			y_p <= 1'b0; x_ph <= 1'b0; x_pl <= 1'b0;
			num <= 1'b0; char <= 1'b0; char_reg <= 1'b0;
			num_delay <= 16'd5; cnt_delay <= 1'b0; cnt <= 1'b0;
			oled_csn <= HIGH; oled_rst <= HIGH; oled_dcn <= CMD; oled_clk <= HIGH; oled_dat <= LOW;
			state <= IDLE; state_back <= IDLE;
		end else begin
			case(state)
				IDLE:begin
						cnt_main <= 1'b0; cnt_init <= 1'b0; cnt_scan <= 1'b0; cnt_write <= 1'b0;
						y_p <= 1'b0; x_ph <= 1'b0; x_pl <= 1'b0;
						num <= 1'b0; char <= 1'b0; char_reg <= 1'b0;
						num_delay <= 16'd5; cnt_delay <= 1'b0; cnt <= 1'b0;
						oled_csn <= HIGH; oled_rst <= HIGH; oled_dcn <= CMD; oled_clk <= HIGH; oled_dat <= LOW;
						state <= MAIN; state_back <= MAIN;
					end
				MAIN:begin
						if(cnt_main >= 5'd6) cnt_main <= 5'd5;
						else cnt_main <= cnt_main + 1'b1;
						case(cnt_main)	//MAIN状态
							5'd0:	begin state <= INIT; end
							5'd1:	begin y_p <= 8'hb0; x_ph <= 8'h10; x_pl <= 8'h00; num <= 5'd16; char <= "----------------";state <= SCAN; end
							5'd2:	begin y_p <= 8'hb1; x_ph <= 8'h10; x_pl <= 8'h00; num <= 5'd16; char <= " voltage:  . V  ";state <= SCAN; end
							5'd3:	begin y_p <= 8'hb2; x_ph <= 8'h10; x_pl <= 8'h00; num <= 5'd16; char <= "                ";state <= SCAN; end
							
							5'd4:	begin y_p <= 8'hb3; x_ph <= 8'h10; x_pl <= 8'h00; num <= 5'd16; char <= "----------------";state <= SCAN; end
							
							//5'd5:	begin y_p <= 8'hb0; x_ph <= 8'h15; x_pl <= 8'h00; num <= 5'd 1; char <= data[3:0]; state <= SCAN; end
							//5'd5:	begin y_p <= 8'hb1; x_ph <= 8'h15; x_pl <= 8'h00; num <= 5'd 3; char <={data[7:4],"."data[3:0]}; state <= SCAN; end
							5'd5:	begin y_p <= 8'hb1; x_ph <= 8'h15; x_pl <= 8'h00; num <= 5'd 1; char <=data[7:4]; state <= SCAN; end
							5'd6:	begin y_p <= 8'hb1; x_ph <= 8'h16; x_pl <= 8'h00; num <= 5'd 1; char <=data[3:0]; state <= SCAN; end
							//5'd6:	begin y_p <= 8'hb3; x_ph <= 8'h15; x_pl <= 8'h00; num <= 5'd 1; char <= "O"; state <= SCAN; end

							default: state <= IDLE;
						endcase
					end
				INIT:begin	//初始化状态
						case(cnt_init)
							5'd0:	begin oled_rst <= LOW; cnt_init <= cnt_init + 1'b1; end	//复位有效
							5'd1:	begin num_delay <= 16'd25000; state <= DELAY; state_back <= INIT; cnt_init <= cnt_init + 1'b1; end	//延时大于3us
							5'd2:	begin oled_rst <= HIGH; cnt_init <= cnt_init + 1'b1; end	//复位恢复
							5'd3:	begin num_delay <= 16'd25000; state <= DELAY; state_back <= INIT; cnt_init <= cnt_init + 1'b1; end	//延时大于220us
							5'd4:	begin 
										if(cnt>=INIT_DEPTH) begin	//当25条指令及数据发出后，配置完成
											cnt <= 1'b0;
											cnt_init <= cnt_init + 1'b1;
										end else begin	
											cnt <= cnt + 1'b1; num_delay <= 16'd5;
											oled_dcn <= CMD; char_reg <= cmd[cnt]; state <= WRITE; state_back <= INIT;
										end
									end
							5'd5:	begin cnt_init <= 1'b0; state <= MAIN; end	//初始化完成，返回MAIN状态
							default: state <= IDLE;
						endcase
					end
				SCAN:begin	//刷屏状态，从RAM中读取数据刷屏
						if(cnt_scan == 5'd11) begin
							if(num) cnt_scan <= 5'd3;
							else cnt_scan <= cnt_scan + 1'b1;
						end else if(cnt_scan == 5'd12) cnt_scan <= 1'b0;
						else cnt_scan <= cnt_scan + 1'b1;
						case(cnt_scan)
							5'd 0:	begin oled_dcn <= CMD; char_reg <= y_p; state <= WRITE; state_back <= SCAN; end		//定位列页地址
							5'd 1:	begin oled_dcn <= CMD; char_reg <= x_pl; state <= WRITE; state_back <= SCAN; end	//定位行地址低位
							5'd 2:	begin oled_dcn <= CMD; char_reg <= x_ph; state <= WRITE; state_back <= SCAN; end	//定位行地址高位
							
							5'd 3:	begin num <= num - 1'b1;end
							5'd 4:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
							5'd 5:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
							5'd 6:	begin oled_dcn <= DATA; char_reg <= 8'h00; state <= WRITE; state_back <= SCAN; end	//将5*8点阵编程8*8
							5'd 7:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][39:32]; state <= WRITE; state_back <= SCAN; end
							5'd 8:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][31:24]; state <= WRITE; state_back <= SCAN; end
							5'd 9:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][23:16]; state <= WRITE; state_back <= SCAN; end
							5'd10:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][15: 8]; state <= WRITE; state_back <= SCAN; end
							5'd11:	begin oled_dcn <= DATA; char_reg <= mem[char[(num*8)+:8]][ 7: 0]; state <= WRITE; state_back <= SCAN; end
							5'd12:	begin state <= MAIN; end
							default: state <= IDLE;
						endcase
					end
				WRITE:begin	//WRITE状态，将数据按照SPI时序发送给屏幕
						if(cnt_write >= 5'd17) cnt_write <= 1'b0;
						else cnt_write <= cnt_write + 1'b1;
						case(cnt_write)
							5'd 0:	begin oled_csn <= LOW; end	//9位数据最高位为命令数据控制位
							5'd 1:	begin oled_clk <= LOW; oled_dat <= char_reg[7]; end	//先发高位数据
							5'd 2:	begin oled_clk <= HIGH; end
							5'd 3:	begin oled_clk <= LOW; oled_dat <= char_reg[6]; end
							5'd 4:	begin oled_clk <= HIGH; end
							5'd 5:	begin oled_clk <= LOW; oled_dat <= char_reg[5]; end
							5'd 6:	begin oled_clk <= HIGH; end
							5'd 7:	begin oled_clk <= LOW; oled_dat <= char_reg[4]; end
							5'd 8:	begin oled_clk <= HIGH; end
							5'd 9:	begin oled_clk <= LOW; oled_dat <= char_reg[3]; end
							5'd10:	begin oled_clk <= HIGH; end
							5'd11:	begin oled_clk <= LOW; oled_dat <= char_reg[2]; end
							5'd12:	begin oled_clk <= HIGH; end
							5'd13:	begin oled_clk <= LOW; oled_dat <= char_reg[1]; end
							5'd14:	begin oled_clk <= HIGH; end
							5'd15:	begin oled_clk <= LOW; oled_dat <= char_reg[0]; end	//后发低位数据
							5'd16:	begin oled_clk <= HIGH; end
							5'd17:	begin oled_csn <= HIGH; state <= DELAY; end	//
							default: state <= IDLE;
						endcase
					end
				DELAY:begin	//延时状态
						if(cnt_delay >= num_delay) begin
							cnt_delay <= 16'd0; state <= state_back; 
						end else cnt_delay <= cnt_delay + 1'b1;
					end
				default:state <= IDLE;
			endcase
		end
	end
	
	//OLED配置指令数据
	always@(posedge rst_n)
		begin
			cmd[ 0] = {8'hae}; 
			cmd[ 1] = {8'h00}; 
			cmd[ 2] = {8'h10}; 
			cmd[ 3] = {8'h00}; 
			cmd[ 4] = {8'hb0}; 
			cmd[ 5] = {8'h81}; 
			cmd[ 6] = {8'hff}; 
			cmd[ 7] = {8'ha1}; 
			cmd[ 8] = {8'ha6}; 
			cmd[ 9] = {8'ha8}; 
			cmd[10] = {8'h1f}; 
			cmd[11] = {8'hc8};
			cmd[12] = {8'hd3};
			cmd[13] = {8'h00};
			cmd[14] = {8'hd5};
			cmd[15] = {8'h80};
			cmd[16] = {8'hd9};
			cmd[17] = {8'h1f};
			cmd[18] = {8'hda};
			cmd[19] = {8'h00};
			cmd[20] = {8'hdb};
			cmd[21] = {8'h40};
			cmd[22] = {8'h8d};
			cmd[23] = {8'h14};
			cmd[24] = {8'haf};
		end 
		
	//5*8点阵字库数据
	always@(posedge rst_n)
		begin
			mem[  0] = {8'h3E, 8'h51, 8'h49, 8'h45, 8'h3E};   // 48  0
			mem[  1] = {8'h00, 8'h42, 8'h7F, 8'h40, 8'h00};   // 49  1
			mem[  2] = {8'h42, 8'h61, 8'h51, 8'h49, 8'h46};   // 50  2
			mem[  3] = {8'h21, 8'h41, 8'h45, 8'h4B, 8'h31};   // 51  3
			mem[  4] = {8'h18, 8'h14, 8'h12, 8'h7F, 8'h10};   // 52  4
			mem[  5] = {8'h27, 8'h45, 8'h45, 8'h45, 8'h39};   // 53  5
			mem[  6] = {8'h3C, 8'h4A, 8'h49, 8'h49, 8'h30};   // 54  6
			mem[  7] = {8'h01, 8'h71, 8'h09, 8'h05, 8'h03};   // 55  7
			mem[  8] = {8'h36, 8'h49, 8'h49, 8'h49, 8'h36};   // 56  8
			mem[  9] = {8'h06, 8'h49, 8'h49, 8'h29, 8'h1E};   // 57  9
			mem[ 10] = {8'h7C, 8'h12, 8'h11, 8'h12, 8'h7C};   // 65  A
			mem[ 11] = {8'h7F, 8'h49, 8'h49, 8'h49, 8'h36};   // 66  B
			mem[ 12] = {8'h3E, 8'h41, 8'h41, 8'h41, 8'h22};   // 67  C
			mem[ 13] = {8'h7F, 8'h41, 8'h41, 8'h22, 8'h1C};   // 68  D
			mem[ 14] = {8'h7F, 8'h49, 8'h49, 8'h49, 8'h41};   // 69  E
			mem[ 15] = {8'h7F, 8'h09, 8'h09, 8'h09, 8'h01};   // 70  F

			mem[ 32] = {8'h00, 8'h00, 8'h00, 8'h00, 8'h00};   // 32  sp 
			mem[ 33] = {8'h00, 8'h00, 8'h2f, 8'h00, 8'h00};   // 33  !  
			mem[ 34] = {8'h00, 8'h07, 8'h00, 8'h07, 8'h00};   // 34  
			mem[ 35] = {8'h14, 8'h7f, 8'h14, 8'h7f, 8'h14};   // 35  #
			mem[ 36] = {8'h24, 8'h2a, 8'h7f, 8'h2a, 8'h12};   // 36  $
			mem[ 37] = {8'h62, 8'h64, 8'h08, 8'h13, 8'h23};   // 37  %
			mem[ 38] = {8'h36, 8'h49, 8'h55, 8'h22, 8'h50};   // 38  &
			mem[ 39] = {8'h00, 8'h05, 8'h03, 8'h00, 8'h00};   // 39  '
			mem[ 40] = {8'h00, 8'h1c, 8'h22, 8'h41, 8'h00};   // 40  (
			mem[ 41] = {8'h00, 8'h41, 8'h22, 8'h1c, 8'h00};   // 41  )
			mem[ 42] = {8'h14, 8'h08, 8'h3E, 8'h08, 8'h14};   // 42  *
			mem[ 43] = {8'h08, 8'h08, 8'h3E, 8'h08, 8'h08};   // 43  +
			mem[ 44] = {8'h00, 8'h00, 8'hA0, 8'h60, 8'h00};   // 44  ,
			mem[ 45] = {8'h08, 8'h08, 8'h08, 8'h08, 8'h08};   // 45  -
			mem[ 46] = {8'h00, 8'h60, 8'h60, 8'h00, 8'h00};   // 46  .
			mem[ 47] = {8'h20, 8'h10, 8'h08, 8'h04, 8'h02};   // 47  /
			mem[ 48] = {8'h3E, 8'h51, 8'h49, 8'h45, 8'h3E};   // 48  0
			mem[ 49] = {8'h00, 8'h42, 8'h7F, 8'h40, 8'h00};   // 49  1
			mem[ 50] = {8'h42, 8'h61, 8'h51, 8'h49, 8'h46};   // 50  2
			mem[ 51] = {8'h21, 8'h41, 8'h45, 8'h4B, 8'h31};   // 51  3
			mem[ 52] = {8'h18, 8'h14, 8'h12, 8'h7F, 8'h10};   // 52  4
			mem[ 53] = {8'h27, 8'h45, 8'h45, 8'h45, 8'h39};   // 53  5
			mem[ 54] = {8'h3C, 8'h4A, 8'h49, 8'h49, 8'h30};   // 54  6
			mem[ 55] = {8'h01, 8'h71, 8'h09, 8'h05, 8'h03};   // 55  7
			mem[ 56] = {8'h36, 8'h49, 8'h49, 8'h49, 8'h36};   // 56  8
			mem[ 57] = {8'h06, 8'h49, 8'h49, 8'h29, 8'h1E};   // 57  9
			mem[ 58] = {8'h00, 8'h36, 8'h36, 8'h00, 8'h00};   // 58  :
			mem[ 59] = {8'h00, 8'h56, 8'h36, 8'h00, 8'h00};   // 59  ;
			mem[ 60] = {8'h08, 8'h14, 8'h22, 8'h41, 8'h00};   // 60  <
			mem[ 61] = {8'h14, 8'h14, 8'h14, 8'h14, 8'h14};   // 61  =
			mem[ 62] = {8'h00, 8'h41, 8'h22, 8'h14, 8'h08};   // 62  >
			mem[ 63] = {8'h02, 8'h01, 8'h51, 8'h09, 8'h06};   // 63  ?
			mem[ 64] = {8'h32, 8'h49, 8'h59, 8'h51, 8'h3E};   // 64  @
			mem[ 65] = {8'h7C, 8'h12, 8'h11, 8'h12, 8'h7C};   // 65  A
			mem[ 66] = {8'h7F, 8'h49, 8'h49, 8'h49, 8'h36};   // 66  B
			mem[ 67] = {8'h3E, 8'h41, 8'h41, 8'h41, 8'h22};   // 67  C
			mem[ 68] = {8'h7F, 8'h41, 8'h41, 8'h22, 8'h1C};   // 68  D
			mem[ 69] = {8'h7F, 8'h49, 8'h49, 8'h49, 8'h41};   // 69  E
			mem[ 70] = {8'h7F, 8'h09, 8'h09, 8'h09, 8'h01};   // 70  F
			mem[ 71] = {8'h3E, 8'h41, 8'h49, 8'h49, 8'h7A};   // 71  G
			mem[ 72] = {8'h7F, 8'h08, 8'h08, 8'h08, 8'h7F};   // 72  H
			mem[ 73] = {8'h00, 8'h41, 8'h7F, 8'h41, 8'h00};   // 73  I
			mem[ 74] = {8'h20, 8'h40, 8'h41, 8'h3F, 8'h01};   // 74  J
			mem[ 75] = {8'h7F, 8'h08, 8'h14, 8'h22, 8'h41};   // 75  K
			mem[ 76] = {8'h7F, 8'h40, 8'h40, 8'h40, 8'h40};   // 76  L
			mem[ 77] = {8'h7F, 8'h02, 8'h0C, 8'h02, 8'h7F};   // 77  M
			mem[ 78] = {8'h7F, 8'h04, 8'h08, 8'h10, 8'h7F};   // 78  N
			mem[ 79] = {8'h3E, 8'h41, 8'h41, 8'h41, 8'h3E};   // 79  O
			mem[ 80] = {8'h7F, 8'h09, 8'h09, 8'h09, 8'h06};   // 80  P
			mem[ 81] = {8'h3E, 8'h41, 8'h51, 8'h21, 8'h5E};   // 81  Q
			mem[ 82] = {8'h7F, 8'h09, 8'h19, 8'h29, 8'h46};   // 82  R
			mem[ 83] = {8'h46, 8'h49, 8'h49, 8'h49, 8'h31};   // 83  S
			mem[ 84] = {8'h01, 8'h01, 8'h7F, 8'h01, 8'h01};   // 84  T
			mem[ 85] = {8'h3F, 8'h40, 8'h40, 8'h40, 8'h3F};   // 85  U
			mem[ 86] = {8'h1F, 8'h20, 8'h40, 8'h20, 8'h1F};   // 86  V
			mem[ 87] = {8'h3F, 8'h40, 8'h38, 8'h40, 8'h3F};   // 87  W
			mem[ 88] = {8'h63, 8'h14, 8'h08, 8'h14, 8'h63};   // 88  X
			mem[ 89] = {8'h07, 8'h08, 8'h70, 8'h08, 8'h07};   // 89  Y
			mem[ 90] = {8'h61, 8'h51, 8'h49, 8'h45, 8'h43};   // 90  Z
			mem[ 91] = {8'h00, 8'h7F, 8'h41, 8'h41, 8'h00};   // 91  [
			mem[ 92] = {8'h55, 8'h2A, 8'h55, 8'h2A, 8'h55};   // 92  .
			mem[ 93] = {8'h00, 8'h41, 8'h41, 8'h7F, 8'h00};   // 93  ]
			mem[ 94] = {8'h04, 8'h02, 8'h01, 8'h02, 8'h04};   // 94  ^
			mem[ 95] = {8'h40, 8'h40, 8'h40, 8'h40, 8'h40};   // 95  _
			mem[ 96] = {8'h00, 8'h01, 8'h02, 8'h04, 8'h00};   // 96  '
			mem[ 97] = {8'h20, 8'h54, 8'h54, 8'h54, 8'h78};   // 97  a
			mem[ 98] = {8'h7F, 8'h48, 8'h44, 8'h44, 8'h38};   // 98  b
			mem[ 99] = {8'h38, 8'h44, 8'h44, 8'h44, 8'h20};   // 99  c
			mem[100] = {8'h38, 8'h44, 8'h44, 8'h48, 8'h7F};   // 100 d
			mem[101] = {8'h38, 8'h54, 8'h54, 8'h54, 8'h18};   // 101 e
			mem[102] = {8'h08, 8'h7E, 8'h09, 8'h01, 8'h02};   // 102 f
			mem[103] = {8'h18, 8'hA4, 8'hA4, 8'hA4, 8'h7C};   // 103 g
			mem[104] = {8'h7F, 8'h08, 8'h04, 8'h04, 8'h78};   // 104 h
			mem[105] = {8'h00, 8'h44, 8'h7D, 8'h40, 8'h00};   // 105 i
			mem[106] = {8'h40, 8'h80, 8'h84, 8'h7D, 8'h00};   // 106 j
			mem[107] = {8'h7F, 8'h10, 8'h28, 8'h44, 8'h00};   // 107 k
			mem[108] = {8'h00, 8'h41, 8'h7F, 8'h40, 8'h00};   // 108 l
			mem[109] = {8'h7C, 8'h04, 8'h18, 8'h04, 8'h78};   // 109 m
			mem[110] = {8'h7C, 8'h08, 8'h04, 8'h04, 8'h78};   // 110 n
			mem[111] = {8'h38, 8'h44, 8'h44, 8'h44, 8'h38};   // 111 o
			mem[112] = {8'hFC, 8'h24, 8'h24, 8'h24, 8'h18};   // 112 p
			mem[113] = {8'h18, 8'h24, 8'h24, 8'h18, 8'hFC};   // 113 q
			mem[114] = {8'h7C, 8'h08, 8'h04, 8'h04, 8'h08};   // 114 r
			mem[115] = {8'h48, 8'h54, 8'h54, 8'h54, 8'h20};   // 115 s
			mem[116] = {8'h04, 8'h3F, 8'h44, 8'h40, 8'h20};   // 116 t
			mem[117] = {8'h3C, 8'h40, 8'h40, 8'h20, 8'h7C};   // 117 u
			mem[118] = {8'h1C, 8'h20, 8'h40, 8'h20, 8'h1C};   // 118 v
			mem[119] = {8'h3C, 8'h40, 8'h30, 8'h40, 8'h3C};   // 119 w
			mem[120] = {8'h44, 8'h28, 8'h10, 8'h28, 8'h44};   // 120 x
			mem[121] = {8'h1C, 8'hA0, 8'hA0, 8'hA0, 8'h7C};   // 121 y
			mem[122] = {8'h44, 8'h64, 8'h54, 8'h4C, 8'h44};   // 122 z
		end
	
endmodule

用ESP32制做网络时钟

Sun, 01 Aug 2021 00:00:00 +0000

介绍

效果展示

介绍
- 显示时间
- 根据IP定位显示天气
- 利用Smart Config进行微信扫码联网

制作过程

材料表
- ESP32开发板 *1
- 母对母杜邦线 *7
- 2.0寸主控IC为ILI9225的TFT显示屏 *1
- Micro USB数据线 *1
工具
- Arduino IDE
- Visual Studio Code
- Python3 环境
- msys2
- 图片编辑工具（我这里用的是自带的画图）
- Img2Lcd 某宝客服赠送的工具
- FontSmaller 字体文件子集化工具
- FontLabTypeTool 付费软件
硬件连接表

ESP32 TFT屏幕

3V3 VCC

GND GND

25 RS

15 CS

14 CLK

13 SDA

26 EST

ESP32	TFT屏幕
3V3	VCC
GND	GND
25	RS
15	CS
14	CLK
13	SDA
26	EST

库文件

#include <Arduino_GFX_Library.h>
#include <ArduinoJson.h>
#include <HTTPClient.h>
#include <time.h>
#include <SPI.h>

程序编写

WIFI连接

在一般情况下，如果直接将WiFi的SSID和密码写入到代码中将不利于切换网络，因此我们使用WiFi Smart Config来进行配网，代码在Arduino的示例程序里找到。

时间同步

由于ESP32断电并不会保存时间，因此每次上电都需要从网络获取时间。

利用 configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);来同步时间，相关代码如下：

const char* ntpServer = "pool.ntp.org";
const long  gmtOffset_sec = 28800;
const int   daylightOffset_sec = 0;


configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);

void GetTime()
{
    struct tm timeinfo;
  	if (!getLocalTime(&timeinfo)) {
    	return;
  	}
    Serial.println(&timeinfo, "%A, %Y-%m-%d %H:%M:%S");
}

位置获取

由于当时并没有申请IP定位的相关API，加上之前学习爬虫时偶然在NetWork里面发现了BiliBili的相关接口：

http://api.bilibili.com/x/web-interface/zone

参考链接

API请求方式及响应参考：通过ip确定地理位置
JSON数据解析：ArduinoJson: Efficient JSON serialization for embedded C++

相关代码如下：

float lat = 0.0;	//latitude 唯独
float lon = 0.0;	//longitude 经度
String city = "";	//城市名称

void getlocation() {
  DynamicJsonDocument doc(1024);
  HTTPClient http;
  http.begin("http://api.bilibili.com/x/web-interface/zone");
  int httpCode = http.GET();
  if (httpCode == 200)
  {
    Serial.println("Get OK");
    String resBuff = http.getString();
    Serial.println(resBuff);
    deserializeJson(doc, resBuff);
    JsonObject root = doc.as<JsonObject>();
    city = root["data"]["city"].as<String>();
    lat = root["data"]["latitude"];
    lon = root["data"]["longitude"];

    Serial.print(lat);
    Serial.print(lon);
    Serial.println(city);
  }
  else {
    Serial.println("Location get error!");
  }


  http.end(); // 结束当前连接
}

天气获取

API来源的原因同上，选自win10上的天气资讯里抓到的API：

https://api.msn.cn/weather/current

请求方式：GET

查询字符串参数：

KEY	VALUE	备注
latLongList:	33.13815,111.49078	经纬度
locale:	zh-cn	地区
units:	C
appId:	9e21380c-ff19-4c78-b4ea-19558e93a5d3
apiKey:	j5i4gDqHL6nGYwx5wi5kRhXjtf2c5qgFX9fzfk0TOo
ocid:	msftweather
wrapOData:	FALSE

示例：

curl 'https://api.msn.cn/weather/current?latLongList=34%2C112&locale=zh-cn&units=C&appId=9e21380c-ff19-4c78-b4ea-19558e93a5d3&apiKey=j5i4gDqHL6nGYwx5wi5kRhXjtf2c5qgFX9fzfk0TOo&ocid=msftweather&wrapOData=false'

响应参考

{
    "responses": [
        {
            "weather": [
                {
                    "current": {
                        "baro": 973, 
                        "cap": "阴", 
                        "capAbbr": "多云", 
                        "daytime": "n", 
                        "dewPt": 22, 
                        "feels": 22, 
                        "rh": 80, 
                        "icon": 32, 
                        "pvdrIcon": "32", 
                        "urlIcon": "http://img-s-msn-com.akamaized.net/tenant/amp/entityid/AAehyQC.img", 
                        "sky": "", 
                        "temp": 25, 
                        "vis": 6, 
                        "windDir": 180, 
                        "windSpd": 61, 
                        "created": "2021-08-02T00:04:38+08:00", 
                        "pvdrCap": "多云", 
                        "pvdrWindDir": "南风", 
                        "pvdrWindSpd": "6-7级", 
                        "aqi": 34, 
                        "aqiSeverity": "空气优", 
                        "richCaps": [ ], 
                        "alertCount": 0
                    }, 
                    "provider": {
                        "name": "中国天气网", 
                        "url": "http://www.weather.com.cn/weather/101180708.shtml"
                    }
                }
            ], 
            "source": {
                "id": "101180708", 
                "coordinates": {
                    "lat": 33.1379738, 
                    "lon": 111.491
                }, 
                "location": {
                    "Name": "xichuan", 
                    "StateCode": "河南", 
                    "CountryName": "china", 
                    "CountryCode": "CN", 
                    "TimezoneName": "Asia/Shanghai", 
                    "TimezoneOffset": "08:00:00"
                }, 
                "utcOffset": "08:00:00", 
                "countryCode": "CN"
            }
        }
    ], 
    "units": {
        "system": "Metric", 
        "pressure": "百帕", 
        "temperature": "‎°C", 
        "speed": "公里/小时", 
        "height": "毫米", 
        "distance": "公里", 
        "time": "s"
    }, 
    "copyright": "Copyright © 2021 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.", 
    "latLongIdMap": {
        "33.13815,111.49078": "101180708"
    }
}

信息解析&获取方式同IP地理位置查询。

信息显示

这里用到了 Arduino GFX 库

参考链接：Arduino_GFX

初始化：

Arduino_DataBus *bus = new Arduino_ESP32SPI(25 /* RS */, 15 /* CS */,  14/* SCK */, 13 /* MOSI */, -1 /* MISO */, HSPI /* spi_num */);

Arduino_GFX *gfx = new Arduino_ILI9225(bus, 26 /* RST */, 1);
void setup(void)
{
  Serial.begin(115200);
  gfx->begin();
}

清除屏幕：gfx->fillScreen(color);

输出文字：

  gfx->setCursor(10, 10);	// 设置光标位置，参考点为首个字体的左下角
  gfx->setFont(&pf_min_ys10pt8b);	// 选择字体，若没有则使用默认字体
  gfx->setTextColor(RED);	// 选择字体颜色
  gfx->println("Hello World!"); 	// 输出到屏幕上

显示图片：

1
2

gfx->draw24bitRGBBitmap(x,y,bitmap,width,height);	// 显示彩图
gfx->drawXBitmap(x,y,gImage_code,width,height,WHITE);	// 显示黑白二色图（二维码）

问题

如何显示中文？

自定义中文字库。

官方提供了转换的工具：Adafruit-GFX-Library/fontconvert ，按照fontconvert_win.md文档即可编译成功。

使用方法：./fontconvert fontfile size [first] [last]

但是，由于中文字库太过庞大，想要全部应用单靠小小的ESP32是无法承受的，因此我们需要精简，我的思路如下：

找出可能要显示的文字：(这里我用Python作为工具进行实现)

a = "朗晴少云晴间多云多云阴有风平静微风和风清风强风劲风疾风大风烈风风暴狂爆风飓风热带风暴霾中度霾重度霾严重霾阵雨雷阵雨雷阵雨并伴有冰雹小雨中雨大雨暴雨大暴雨特大暴雨强阵雨强雷阵雨极端降雨毛毛雨细雨雨小雨中雨中雨大雨大雨暴雨暴雨大暴雨大暴雨特大暴雨雨雪天气雨夹雪阵雨夹雪冻雨雪阵雪小雪中雪大雪暴雪小雪中雪中雪大雪大雪暴雪浮尘扬沙沙尘暴强沙尘暴龙卷风雾浓雾强浓雾轻雾大雾特强浓雾热冷省市南阳镇江优良轻度污染东西北空气"
# 对字符串a进行去重
a=set(a)
b=""
for i in a:     
    print(i,end="")
    b = b + i
# 去重之后：少天冻雾冷!西空热云阴狂特间重降度静大爆伴多冰微浮朗扬气雪劲阵中有小染暴阳飓浓严平卷轻极夹毛雹雨省镇江雷清优北沙烈带并污龙东疾良尘强细霾晴风端和市南
# 对字符串的Unicode码进行排序
ls=[]
for i in b:
    ls.append(ord(i))
ls.sort()

由于字体转换工具的局限性，它截取的字体必须是连续的，即按照Unicode码从[first]到[last]进行转换，然而我们需要的字的Unicode码跨度很大（从[" “(32)]到[“龙”(40857)]），转换后的.h文件大小高达2Mb，因此还需要再进行缩减。

由于英文及其符号的Unicode码是连在一起的（从32到126）因此我们可以按照一定的规则将ttf文件中我们需要的字的Unicode码进行修改，在126之后进行追加我称之为字体映射[doge]，然后再在程序里写一个解析的函数即可。

得到映射关系及部分解析代码的python程序如下：

sum=0
ys={}
for i in ls:
    if i in range(0x4e1c,ls[len(ls)-1]+1):
        sum+=1
        print(f"{chr(i)}:{hex(i)}:{hex(126+sum)} ")		# 映射关系
        ys[chr(i)]=chr(126 + sum)
        print(f'txt.replace("{chr(i)}", "\\{str(hex(126+sum))[1:]}");')		# 解析代码

'''
输出示例:
东:0x4e1c:0x7f 
txt.replace("东", "\x7f");
严:0x4e25:0x80 
txt.replace("严", "\x80");
中:0x4e2d:0x81 
txt.replace("中", "\x81");
云:0x4e91:0x82 
txt.replace("云", "\x82");
..........
飓:0x98d3:0xc6 
txt.replace("飓", "\xc6");
龙:0x9f99:0xc7 
txt.replace("龙", "\xc7");
'''
# 很明显的从4w多缩减到了199

解析的函数：

void printcn(String txt) {
  // Serial.println(txt);

  txt.replace("东", "\x7f");
  txt.replace("严", "\x80");
  txt.replace("中", "\x81");
  txt.replace("云", "\x82");
  txt.replace("优", "\x83");

  gfx->println(txt);
}

得到映射关系后我们就可以对ttf文件进行修改了，利用[FontSmaller 字体文件子集化工具]将需要的文件进行简化，再用[FontLabTypeTool字体编辑器]工具对其Unicode进行修改，最后使用编译好的字体转换工具进行转换即可得到.h文件 ./fontconvert fontfile 10 32 199

如何得到bitmapArray？

我用了两张图，第一张是Smart Config的二维码，因为只有黑白，所以很容易就实现了显示：

设定参考：

选项	选择
输出数据类型:	C语言数组(*.c)
扫描模式:	水平扫描
输出灰度:	单色
字节内象素数据反序	是

*需要修改生成的.c中的char[]类型为uint8_t[]类型

第二张是彩色的UI背景图，使用ppt以及画图进行制作。

然而彩色的UI背景图就不是那么容易了，无论我用这个软件怎么设置，在屏幕中显示的都只有混乱，因此只能找别的软件了。在我翻遍了github之后，找到了一个py文件（淦忘了那个py文件的具体出处链接了）运行后终于成功显示出了上下颠倒，红色变蓝色（后来百度到是因为R通道和B通道被交换了）的图片，既然py文件代码看不懂，那就主动转换源文件来 负负得正

转换源图片为负的python代码：(拿出了还没有入门的opencv知识)

import cv2

img1 = cv2.imread("./IMG/bg.bmp")

b, g, r = cv2.split(img1)
img1 = cv2.merge([r, g, b])  # 通道转换

img1 = cv2.flip(img1, 0)  # 垂直翻转


cv2.imwrite("out.jpeg", img1)	# 输出转换后的图片

注意：输出的图片还要另存为24色的bmp文件（利用win自带的画图的另存为）

然后利用找到的py程序输出bitmap数组：(程序经过了我部分魔改，很抱歉我找不到程序的原作者了啊啊啊啊)

import os
import shutil

img_out_c = list()

sum = 0


def img_to_c_string(image_path, img_name):
    with open(image_path, 'rb') as img_file:
        binary_file = img_file.read()

        # img data
        img_out_c.append(
            "/*********************************************************************\n*\n*  name: %s\n*/" % (img_name))
        img_out_c.append("static const uint8_t %s_%s[%s] = {" % (
            img_name[-3:], img_name[:-4].replace(' ', '_').replace('-', '_'), os.path.getsize(image_path)))

        for x in range(int(len(binary_file) / 20)):
            part = binary_file[20 * x: 20 * x + 20]
            img_out_c.append("    0x" + ", 0x".join(format(x, "02X") for x in part) + ',')
            print("    0x" + ", 0x".join(format(x, "02X") for x in part) + ',')
            print("\n\n")
        if len(binary_file) % 20 != 0:
            part = binary_file[int(len(binary_file) / 20) * 20:len(binary_file)]
            img_out_c.append("    0x" + ", 0x".join(format(x, "02X") for x in part))
        img_out_c.append("};\n")


def generate_c_code(env_dir):
    out_path = os.path.join(env_dir, "img_out.h")
    if os.path.isfile(out_path):
        os.remove(out_path)
    with open(out_path, 'w') as c_file:
        for bmp_line in img_out_c:
            c_file.write(bmp_line + '\n')
        c_file.write('\n')


if __name__ == '__main__':
    env_dir = os.path.dirname(os.path.realpath(__file__))
    bmp_dir = os.path.join(env_dir, "IMG")
    if os.path.exists(bmp_dir):
        bmp_list = os.listdir(bmp_dir)
        for img_file in bmp_list:
            bmp_path = os.path.join(bmp_dir, img_file)
            print(bmp_path)
            img_to_c_string(bmp_path, img_file)
        generate_c_code(env_dir)

之后把想要的功能全部实现一波就行了！！！

最后附上我写的虽然满是bug但总算完成了基本功能的项目源码：SwetyCore/Esp32NetworkClock: 一个基于Esp32制作的可以显示天气的时钟 (github.com) 欢迎前来Star！！

本项目所用API仅为学习研究所用!

Python爬取新浪财经的部分表格

Thu, 01 Jul 2021 00:00:00 +0000

前言

需求：根据提供的股票代码将网站财务摘要_新浪网的资产负债表，利润表，现金流量表三个表格保村到本地。

过程解析

得到需求后当然是打开浏览器，然后根据传统艺能打开 DevTools 就是一顿分析，很快嗷，就得到了爬取的思路。

获取相关页面：对 http://vip.stock.finance.sina.com.cn/q/go.php/vInvestConsult/kind/scbhz/index.phtml?symbol={股票代码} 发送get请求，得到搜索结果。用xpath//a[@target="_blank"] 来匹配到财务摘要的页面。
匹配相关信息：在财务摘要页面用 //*[@id="toolbar"]/div[1]/h1/a 来获取公司名称，正则匹配 stockid/(.*?)/ctrl 来获取stockid。
获取下载链接并下载：其中，资产负债表，利润表，现金流表的下载链接分别是 http://money.finance.sina.com.cn/corp/go.php/vDOWN_BalanceSheet/displaytype/4/stockid/{stockId}/ctrl/all.phtml http://money.finance.sina.com.cn/corp/go.php/vDOWN_ProfitStatement/displaytype/4/stockid/{stockId}/ctrl/all.phtml http://money.finance.sina.com.cn/corp/go.php/vDOWN_CashFlow/displaytype/4/stockid/{stockId}/ctrl/all.phtml

遇到的问题&吐槽

获取页面和匹配信息都没什么难度，令人迷惑的是当我在浏览器里试图下载 excel 文件的时候，突然弹出了登录框提示登陆才能下载，当时猜测完了可能又要搞模拟登陆了（心里不由得想起了被各种加密支配的恐惧）。但当我真正登陆上去点击下载后，才发现不就一固定链接嘛还搞得那么神秘。

项目地址：

ubuntu和fedora下的fcitx输入法问题

Sun, 04 Apr 2021 00:00:00 +0000

前言

ubuntu 和 fedora 的默认中文输入法均为 ibus，但是这个输入法对与 jetbrains 家的ide均不是特别友好，经常出现输入时候卡顿严重的问题，就不得不安装其他输入法代替。
但是 fcitx 输入法并不是开箱即用的，安装好之后还需要配置一些东西才能让它正常工作。

步骤

1.安装 fcitx：
sudo apt install fcitx-sunpinyin
sudo dnf install fcitx-sunpinyin
可选安装 fcitx-config-tool
2.配置:
对于 ubuntu 或者其他部分发行版需要添加环境变量。
sudo vim /etc/profile
在末尾加上

1
2
3

export GTK_IM_MODULE=fcitx
export QT_IM_MODULE=fcitx
export XMODIFIERS="@im=fcitx"

注销再登陆即可

但是对于 fedora，我发现只增加环境变量就不好使了，重启之后依然无法输入中文。
经过一番折腾后发现需要配置输入法
alternatives --config xinputrc
之后选择 fcitx 即可。

基于Arduino制作的宿舍NFC门禁

Sun, 04 Apr 2021 00:00:00 +0000

前言

众所周知，在学校里钥匙可能忘带，但是手机却不可能会不带，再加上偶然刷到了自制宿舍NFC门禁的帖子，就想整一个试一试。

材料

Arduino UNO *1
充电宝 *1
MFRC522 （nfc模块） *1
28BYJ4 （5V步进电机） *1
ULN2003驱动板 *1

连线

Github：戳我传送

[Warning]：出于安全性考虑，此项目仅供学习和娱乐

Python lxml 库的使用

Fri, 26 Mar 2021 00:00:00 +0000

前言：

在开发自动健康打卡的过程中，因为 post 不止提交有当日体温，还带有最近动态等个人信息，最初是用 json 文件来存储信息，但是这样每次信息更新都要重新手动更新 json 文件很不方便，而且只能自己一个人用。

用法：

这里贴上一个我当时看的教程连接：>点我传送<

需要提取的信息大致分为以下这几类
1.input/number类型：<input id="ykt" class="weui_input" type="text" name="ykt" placeholder="请输入学号" value="1234567890" readonly="readonly"> </div>
<input class="weui_input" type="number" id="nl" name="nl" placeholder="请输入年龄" maxlength="3" required="" value="18">
2.radio类型： <input class="weui-check" name="xb" type="radio" disabled="disabled" value="女"> 女Female</div>
3.select_type：<select id="qtyc" class="select_type" name="qtyc"><option value="" selected="selected"></option><option value="无">无 None</option><option value="不发烧但咳嗽">不发烧但咳嗽 No fever but cough</option><option value="不发烧但腹泻">不发烧但腹泻 No fever but diarrhea</option></select>

解决方案
1.导入 lxml
from lxml import etree
2.利用 etree.HTML，将字符串解析为 HTML 文档 html = etree.HTML(text)
3.xpath 匹配

result=html.xpath('//input[@type="text"]')
html.xpath('//input[@type="number"]')
html.xpath('//input[@type="radio" and @checked="checked"]') # 多个属性匹配（类型是radio并且被选中）
# 上面几个返回的是所有匹配到的结果【list】可以用for遍历。

for i in result:
    key = i.xpath('./@name')[0]
    value = i.xpath('./@value')[0]

这样就获取到了表单所需要的key和对应的value。
下面是select_type的：
selects = html.xpath('//select[@class="select_type"]')
    for select in selects:
        option = select.xpath('./option[@selected="true"]')[0]

        key = option.xpath('../@name')[0]
        value = option.xpath('./@value')[0]

至此，自动提取已经填过的表单项目的任务已经完成。

Python实现博客文章的上传

Fri, 26 Mar 2021 00:00:00 +0000

前言

在我刚开始创建这个博客的时候，每次发文章都需要将整个项目pull下来再push上去，十分不方便，于是就想做一个能够不用git就实现的快速文章上传工具，去网络上一搜，果然有个github3的模块可以实现。

过程

导入模块：

import github3

实现登陆：

def connect_to_github():
	try:
		gh=login(token=input("Input your token:"))
		repo=gh.repository("SwetyCore","swetycore.github.io")
		branch=repo.branch("main")
		return gh, repo, branch
	except Exception as msg:
		print(f'Token error!!!\n{msg}\nPlease retry.')
		connect_to_github()

上传文章：

def store_data(data,filename):
	gh, repo, branch = connect_to_github()
	remote_path = f"_posts/{filename}"
	repo.create_file(remote_path, "Commite message", data)
	print("upload success")
	return

吐槽

为什么网上的相关教程这么少哇

网上的教程中的tree = branch.commit.commit.tree.recurse()已经不再适用。所以判断文件是否存在应该改为

def is_file_exists(filepath):
	gh, repo, branch = connect_to_github()
	tree = branch.commit.commit.tree.to_tree().recurse()
	for filename in tree.tree:
		if filepath in filename.path:
			return True
		else:
			return False

上传文件不能重名！！！！(以后再想办法解决吧【恼】)

Python 模拟登陆

Thu, 25 Mar 2021 00:00:00 +0000

前言：

这个东西其实在寒假期间就写好了，但是每天都需要手动的健康打卡，但是自己又是非常的懒，一不小心睡过头或者玩过头了就把这件事忘的一干二净，当时虽然已经学了一点爬虫的方法，但是也只会爬点文字，图片一类的东西，对于需要登陆才能获取到信息的网站没有一点办法。自动打卡首先需要登陆综合门户，那就硬着头皮面向百度编程吧[无奈]

过程解析:

初次请求登录门户(get):

https://pass.ujs.edu.cn/cas/login

请求验证码(get):

https://pass.ujs.edu.cn/cas/captcha.html

再次用请求登录门户 (post) ,并提交登录表单.

三次请求如果都成功并且无错误,应该返回成功登陆后的界面.

post表单内容解析：

username: 1234567890
password: gfgwDALwERl0MuTBfg+U/m81JBDbksfasfTj8msH9HqqKztL+3lIhePVsFD5GXoDi7DYyQs7YoeN1Yz0RlMhegECvXfiIsQ=
captchaResponse: aphc
lt: LT-958050-a0kzJW9kweaskdgfHJdaY1Ug7oHe2eQ1611227557350-OC02-cas
dllt: userNamePasswordLogin
execution: e2s1
_eventId: submit
rmShown: 1

username: 学号
password: 加密后的密码
captchaResponse: 验证码
lt: 一串奇怪的字符,在第一次请求的 response 里面,可以用正则表达式 <input name="lt" type="hidden" value="(.*?)"/> 匹配到.
dllt: 固定值
execution: 奇怪的字符,使用正则表达式 <input name="execution" type="hidden" value="(.*?)"/> 匹配
_eventId: 固定值
rmShown: 固定值

密码加密解析:

只是将网页的js代码稍作整理提取,有兴趣的大佬可以研究一下具体的加密过程(其实是我不会). 其中的加密函数 _etd2() 需要两个参数:

密码
pwdDefaultEncryptSalt

其中pwdDefaultEncryptSalt可以用正则表达式 var pwdDefaultEncryptSalt = "(.*?)"; 匹配.

我已经将加密的代码整理为两个js文件,使用时候只需要运行jiami.js里面的 _etd2() 函数并且传入相应的参数,获取函数返回值即可.

注意事项

三次请求应该是同一个 session 完成

请求示例:

~~详见login.py~~

重写了 login.py ,建议使用 loginRe.py

调用登陆模块示例:

import loginRe
import getpass

if __name__ == '__main__':
   username = input('学号: ')
   pwd = getpass.getpass("密码: ")
   lg = loginRe.Login('6e9b090sdad5c1234d0bbb88de18097eb')
   lg.Login(username=username, password=pwd)

tip:

阿里云 ocr 识别请自行申请接口 key. 戳我传送

模拟登陆的用途:应该没什么用吧 (bushi)

仅供学习交流,请不要用于其他方面!!!!

希望不至于被叫去喝茶 (逃)

总结：

虽然这个项目的难度并不高，但是我对于需要登陆的爬虫的第一次尝试。我竟然笨到研究了三天才整完。项目详见 Jiangda-Portal-Automatic-Login。

Links

Mon, 01 Jan 0001 00:00:00 +0000

友链，但是目前是空白的 :(

Search

Mon, 01 Jan 0001 00:00:00 +0000

这里是SwetyCore的博客

Archives

Hello World

Hello World

对于小脚丫驱动 OLED12832（SSD1306）代码的研究笔记

对于小脚丫驱动 OLED12832（SSD1306）代码的研究笔记。

1. 数据手册

2. 分析

连线

变量对照表

模块状态机分析

空闲(idle状态)

屏幕初始化( init 状态)

Main状态

Delay状态？

Write状态

Scan

3. 原代码

用ESP32制做网络时钟

介绍

制作过程

程序编写

Python爬取新浪财经的部分表格

前言

过程解析

遇到的问题&吐槽

ubuntu和fedora下的fcitx输入法问题

前言

步骤

基于Arduino制作的宿舍NFC门禁

前言

材料

连线

Python lxml 库的使用

前言：

用法：

Python实现博客文章的上传

前言

过程

吐槽

Python 模拟登陆

前言：

过程解析:

post表单内容解析：

密码加密解析:

注意事项

请求示例:

tip:

总结：

Links

Search