爆肝7天手搓STM32多功能电子秤

已于 2023-07-28 20:51:41 修改
阅读量107 收藏 2
点赞数 1
文章标签： stm32 嵌入式硬件 单片机
于 2023-07-28 14:56:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/richwerido/article/details/131979710
版权
本文介绍了一个基于STM32微控制器的多功能电子秤项目，该秤使用了DS1302实时时钟、矩阵键盘、摇杆控制以及AT24C02存储器，实现了时间设置、闹钟功能和秤的校准。用户可以通过摇杆在菜单中进行操作，调整时间或设置闹钟，并能对秤进行校准，存储校准参数。
摘要由CSDN通过智能技术生成

大一寒假大年初一闲来无事，7天爆肝实验室祖传作业——多功能电子秤，本来实验室要求电子秤应该用51单片机写，但是学完32后想找个项目练练手，于是用32搓了一台电子秤。

电子秤采用多功能菜单，矩阵键盘与摇杆控制，电子秤可以自校准，用一次函数y=ax+b建模运算，计算后的参数可通过AT24C02储存，带有DS1302万年历，还有闹钟功能。

VID_20230129_180057

下面是主函数多功能菜单代码。

HX为重力秤。

xysw为摇杆控制，x，y为摇杆ADC采集数据。

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "HX.h"
#include "OLED.h"
#include "xysw.h"
#include "ds1302.h"
#include "bigkey.h"
#include "buzzer.h"
#include "alarm.h"
#include "i2c.h"
#include "24c02.h"
char menu[3][15]={"clock setting","alarm","scale"};
uint16_t key,num,wei,p,d,re,d1,c,d,e,f;
uint32_t m,x1,cou,co,n;
int selectx,selecty,temp,temp2,temp3,alarm[3]={0};
 
int main()
{
	
	OLED_Init();
	i2c_Init();
//	OLED_ShowString(1,4,"multsclae");
//	OLED_ShowString(2,6,"BOS");
	re=0;
	temp2=0;  //设置控制数
	selectx=0;
	selecty=0;
	key=0;
	temp=0;
	 //初始化
	buzzer_Init();
	hx_Init();
	DS1302_Init();
	DS1302_SetTime();
	bigkey_Init();
	xysw_Init();
	alarm_Init();
	
//	Delay_ms(1000);
		while(1)  //进入主界面
	{	
		DS1302_ReadTime();  
		OLED_ShowNum(1,1,DS1302_Time[0]+2000,4); //year
		OLED_ShowString(1,5,"-");
		OLED_ShowNum(1,6,DS1302_Time[1],2);//month
		OLED_ShowString(1,8,"-");
		OLED_ShowNum(1,9,DS1302_Time[2],2);//date
		
		OLED_ShowNum(2,1,DS1302_Time[3],2);	//hour
		OLED_ShowString(2,3,":");
		OLED_ShowNum(2,4,DS1302_Time[4],2);//minate
		OLED_ShowString(2,6,":");
		OLED_ShowNum(2,7,DS1302_Time[5],2);//sound
		OLED_ShowString(2,10,"week");	
		OLED_ShowNum(2,15,DS1302_Time[6],1);//day
		
		OLED_ShowNum(3,1,dr[0],4);  //Y UP MAX
		OLED_ShowNum(3,6,dr[1],4); //X RIGHT MAX
		
		OLED_ShowString(4,11,"menu");
		
		readxy();
		OLED_ShowSignedNum(4,4,x,1);
		OLED_ShowSignedNum(4,6,y,1);
		//进入菜单界面
		if(x==1)
		{
			OLED_Clear();
			while(1)
			{
				readxy();
				OLED_ShowString(1,1,menu[0]);	
				OLED_ShowString(2,1,menu[1]);	
				OLED_ShowString(3,1,menu[2]);				
				if(y==1) selecty++;			
				if(y==-1) selecty--;
				
				if(selectx==-1) selectx=0;  //防控制数溢出
				if(selectx==2) selectx=1;
				if(selecty==0) selecty=1;
				if(selecty==4) selecty=3;
				
				if(selecty)
				{
					if(selecty!=temp) //when selety change clear oled 参数变化刷新一次
					{
						OLED_Clear();
						temp=selecty;
					}
					OLED_ShowString(selecty,15,"<-");
				}
//进入时钟调节界面			
				if(selecty==1&&x==1) //enter clock setting page 
				{
					OLED_Clear();
					selectx=0;
					temp=0;
					while(1)
					{
						readxy();	//read xy					
						if(selectx!=temp) //when selety change clear oled
						{
							OLED_Clear();
							temp=selectx;
						}						
						OLED_ShowNum(1,1,DS1302_Time[0]+2000,4); //year						
						OLED_ShowString(1,5,"-");						
						OLED_ShowNum(1,6,DS1302_Time[1],2);//month						
						OLED_ShowString(1,8,"-");						
						OLED_ShowNum(1,9,DS1302_Time[2],2);//date
								
						OLED_ShowNum(3,3,DS1302_Time[3],2);	//hour		
						OLED_ShowString(3,5,":");		
						OLED_ShowNum(3,6,DS1302_Time[4],2);//minate
						OLED_ShowString(3,8,":");
						OLED_ShowNum(3,9,DS1302_Time[5],2);//sound
						OLED_ShowString(3,11,"week");	
						OLED_ShowNum(3,15,DS1302_Time[6],1);//day	
						
						if(x==1) selectx++; //遥感数据转变为 选择参数
						if(x==-1)  selectx--;
						if(selectx==-1) {selectx=0;x=0;break;} //out  
						
						if(0<selectx&&selectx<4 ) OLED_ShowString(2,selectx*3,"||");
						if(3<selectx&&selectx<8 ) OLED_ShowString(4,(selectx-3)*3,"||");
						if(selectx==8) selectx=7;
						// show over
						//show change
						if(selectx==1&&y==1) //年设置
						{
							OLED_Clear();
							Delay_ms(100);
							OLED_ShowNum(1,1,DS1302_Time[0]+2000,4); //year						
							OLED_ShowString(1,5,"-");						
							OLED_ShowNum(1,6,DS1302_Time[1],2);//month						
							OLED_ShowString(1,8,"-");						
							OLED_ShowNum(1,9,DS1302_Time[2],2);//date
							while(1)
							{
								readxy();
								if(y==1) DS1302_Time[0]++;
								if(y==-1) DS1302_Time[0]--;
								if(x==-1) {x=0;break;}
								if(DS1302_Time[0]>99){DS1302_Time[0]=0;}
								if(DS1302_Time[0]<0){DS1302_Time[0]=99;}
								OLED_ShowNum(1,1,DS1302_Time[0]+2000,4);
							}
						}		
						if(selectx==2&&y==1) //月设置
						{
							OLED_Clear();
							Delay_ms(100);
							OLED_ShowNum(1,1,DS1302_Time[0]+2000,4); //year						
							OLED_ShowString(1,5,"-");						
							OLED_ShowNum(1,6,DS1302_Time[1],2);//month						
							OLED_ShowString(1,8,"-");						
							OLED_ShowNum(1,9,DS1302_Time[2],2);//date							
							while(1)
							{
								readxy();
								if(y==1) DS1302_Time[1]++;
								if(y==-1) DS1302_Time[1]--;
								if(x==-1) {x=0;break;}
								if(DS1302_Time[1]>12){DS1302_Time[1]=1;}
								if(DS1302_Time[1]<1){DS1302_Time[1]=12;}
								OLED_ShowNum(1,6,DS1302_Time[1],2);
							}
						}						
						if(selectx==3&&y==1) //日设置
						{
							OLED_Clear();
							Delay_ms(100);
							OLED_ShowNum(1,1,DS1302_Time[0]+2000,4); //year						
							OLED_ShowString(1,5,"-");						
							OLED_ShowNum(1,6,DS1302_Time[1],2);//month						
							OLED_ShowString(1,8,"-");						
							OLED_ShowNum(1,9,DS1302_Time[2],2);//date							
							while(1)
							{
								readxy();
								if(y==1) DS1302_Time[2]++;
								if(y==-1) DS1302_Time[2]--;
								if(x==-1) {x=0;break;}
								if( DS1302_Time[1]==1 || DS1302_Time[1]==3 || DS1302_Time[1]==5 || DS1302_Time[1]==7 || 
								DS1302_Time[1]==8 || DS1302_Time[1]==10 || DS1302_Time[1]==12)//日越界判断
								{
									if(DS1302_Time[2]<1){DS1302_Time[2]=31;}//大月
									if(DS1302_Time[2]>31){DS1302_Time[2]=1;}
								}
								else if(DS1302_Time[1]==4 || DS1302_Time[1]==6 || DS1302_Time[1]==9 || DS1302_Time[1]==11)
								{
									if(DS1302_Time[2]<1){DS1302_Time[2]=30;}//小月
									if(DS1302_Time[2]>30){DS1302_Time[2]=1;}
								}
								else if(DS1302_Time[1]==2)
								{
										if(DS1302_Time[0]%4==0)
									{
										if(DS1302_Time[2]<1){DS1302_Time[2]=29;}//闰年2月
										if(DS1302_Time[2]>29){DS1302_Time[2]=1;}
									}
									else
									{
										if(DS1302_Time[2]<1){DS1302_Time[2]=28;}//平年2月
										if(DS1302_Time[2]>28){DS1302_Time[2]=1;}
									}
								}
								if( DS1302_Time[1]==1 || DS1302_Time[1]==3 || DS1302_Time[1]==5 || DS1302_Time[1]==7 || 
									DS1302_Time[1]==8 || DS1302_Time[1]==10 || DS1302_Time[1]==12)//日越界判断
								{
									if(DS1302_Time[2]>31){DS1302_Time[2]=1;}//大月
								}
								else if(DS1302_Time[1]==4 || DS1302_Time[1]==6 || DS1302_Time[1]==9 || DS1302_Time[1]==11)
								{
									if(DS1302_Time[2]>30){DS1302_Time[2]=1;}//小月
								}
								else if(DS1302_Time[1]==2)
								{
									if(DS1302_Time[0]%4==0)
									{
										if(DS1302_Time[2]>29){DS1302_Time[2]=1;}//闰年2月
									}
									else
									{
										if(DS1302_Time[2]>28){DS1302_Time[2]=1;}//平年2月
									}
								}
								OLED_ShowNum(1,9,DS1302_Time[2],2);
							}
						}
						if(selectx==4&&y==1) //小时设置
						{
							OLED_Clear();
							Delay_ms(100);
							OLED_ShowNum(3,3,DS1302_Time[3],2);	//hour		
							OLED_ShowString(3,5,":");		
							OLED_ShowNum(3,6,DS1302_Time[4],2);//minate
							OLED_ShowString(3,8,":");
							OLED_ShowNum(3,9,DS1302_Time[5],2);//sound
							OLED_ShowString(3,11,"week");	
							OLED_ShowNum(3,15,DS1302_Time[6],1);//day			
							while(1)
							{
								readxy();
								if(y==1) DS1302_Time[3]++;
								if(y==-1) DS1302_Time[3]--;
								if(x==-1) {x=0;break;}
								if(DS1302_Time[3]<0){DS1302_Time[3]=23;}//时越界判断
								if(DS1302_Time[3]>23){DS1302_Time[3]=0;}//时越界判断
								OLED_ShowNum(3,3,DS1302_Time[3],2);
							}
						}	
						if(selectx==5&&y==1) //分钟设置
						{
							OLED_Clear();
							Delay_ms(100);
							OLED_ShowNum(3,3,DS1302_Time[3],2);	//hour		
							OLED_ShowString(3,5,":");		
							OLED_ShowNum(3,6,DS1302_Time[4],2);//minate
							OLED_ShowString(3,8,":");
							OLED_ShowNum(3,9,DS1302_Time[5],2);//sound
							OLED_ShowString(3,11,"week");	
							OLED_ShowNum(3,15,DS1302_Time[6],1);//day			
							while(1)
							{
								readxy();
								if(y==1) DS1302_Time[4]++;
								if(y==-1) DS1302_Time[4]--;
								if(x==-1) {x=0;break;}
								if(DS1302_Time[4]>59){DS1302_Time[4]=0;}//分越界判断
								if(DS1302_Time[4]<0){DS1302_Time[4]=59;}//分越界判断
								OLED_ShowNum(3,6,DS1302_Time[4],2);
							}
						}
						if(selectx==6&&y==1) //秒设置
						{
							OLED_Clear();
							Delay_ms(100);
							OLED_ShowNum(3,3,DS1302_Time[3],2);	//hour		
							OLED_ShowString(3,5,":");		
							OLED_ShowNum(3,6,DS1302_Time[4],2);//minate
							OLED_ShowString(3,8,":");
							OLED_ShowNum(3,9,DS1302_Time[5],2);//sound
							OLED_ShowString(3,11,"week");	
							OLED_ShowNum(3,15,DS1302_Time[6],1);//day			
							while(1)
							{
								readxy();
								if(y==1) DS1302_Time[5]++;
								if(y==-1) DS1302_Time[5]--;
								if(x==-1) {x=0;break;}
								if(DS1302_Time[5]>59){DS1302_Time[5]=0;}//秒越界判断
								if(DS1302_Time[5]<0){DS1302_Time[5]=59;}//秒越界判断
								OLED_ShowNum(3,9,DS1302_Time[5],2);
							}
						}	
						if(selectx==7&&y==1) //秒设置
						{
							OLED_Clear();
							Delay_ms(100);
							OLED_ShowNum(3,3,DS1302_Time[3],2);	//hour		
							OLED_ShowString(3,5,":");		
							OLED_ShowNum(3,6,DS1302_Time[4],2);//minate
							OLED_ShowString(3,8,":");
							OLED_ShowNum(3,9,DS1302_Time[5],2);//sound
							OLED_ShowString(3,11,"week");	
							OLED_ShowNum(3,15,DS1302_Time[6],1);//day			
							while(1)
							{
								readxy();
								if(y==1) DS1302_Time[6]++;
								if(y==-1) DS1302_Time[6]--;
								if(x==-1) {x=0;break;}
								if(DS1302_Time[6]>7){DS1302_Time[6]=1;}//秒越界判断
								if(DS1302_Time[6]<1){DS1302_Time[6]=7;}//秒越界判断
								OLED_ShowNum(3,15,DS1302_Time[6],1);
							}
						}						
					}
					selectx=0;
					temp=0;
					DS1302_SetTime();
				}
//闹钟调节
				
				if(selecty==2&&x==1) //enter alarm page 
				{
					OLED_Clear();
					while(1)
					{
						//参数变动屏幕刷新
						if(selectx!=temp) //when seletx change clear oled
						{
							OLED_Clear();
							temp=selectx;
						}	
						if(selecty!=temp2) //when selety change clear oled
						{
							OLED_Clear();
							temp2=selecty;
						}
						
						readxy();
						
						OLED_ShowSignedNum(4,1,selectx,2);
						OLED_ShowSignedNum(4,4,selecty,2);						
						OLED_ShowNum(2,3,alarm[0],2);	//hour		
						OLED_ShowString(2,5,":");		
						OLED_ShowNum(2,6,alarm[1],2);//minate
						OLED_ShowString(2,8,":");
						OLED_ShowNum(2,9,alarm[2],2);//sound
						OLED_ShowString(2,12,"go");
						
						if(x==1) selectx++; //遥感数据转变为 选择参数
						if(x==-1)  {selectx--;x=0;}
						  
						if(selectx==-1) {selectx=0;x=0;break;} //out
						if(0<selectx&&selectx<5 ) OLED_ShowString(3,selectx*3,"||");
						if(selectx==5) selectx=4;
						
						// show over
						//show change
	//hour					
						if(selectx==1&&y==1)
						{
							if(0<selectx&&selectx<5 ) OLED_ShowString(3,selectx*3,"| ");
							Delay_ms(100);
							OLED_ShowNum(2,3,alarm[0],2);	//hour		
							OLED_ShowString(2,5,":");		
							OLED_ShowNum(2,6,alarm[1],2);//minate
							OLED_ShowString(2,8,":");
							OLED_ShowNum(2,9,alarm[2],2);//sound
							while(1)
							{
								readxy();
								if(y==1) alarm[0]++;
								if(y==-1) alarm[0]--;
								if(x==-1) {x=0;break;}
								if(alarm[0]>24){alarm[0]=0;}
								if(alarm[0]<0) {alarm[0]=24;}
								OLED_ShowNum(2,3,alarm[0],2);	//hour
							}
						}	
//minate						
						if(selectx==2&&y==1)
						{
							if(0<selectx&&selectx<5 ) OLED_ShowString(3,selectx*3,"| ");
							Delay_ms(100);
							OLED_ShowNum(2,3,alarm[0],2);	//hour		
							OLED_ShowString(2,5,":");		
							OLED_ShowNum(2,6,alarm[1],2);//minate
							OLED_ShowString(2,8,":");
							OLED_ShowNum(2,9,alarm[2],2);//sound
							OLED_ShowString(2,12,"go");
							while(1)
							{
								readxy();
								if(y==1) alarm[1]++;
								if(y==-1) alarm[1]--;
								if(x==-1) {x=0;break;}
								if(alarm[1]>59){alarm[1]=0;}
								if(alarm[1]<0){alarm[1]=59;}
								OLED_ShowNum(2,6,alarm[1],2);	
							}
						}	
	//sound					
						if(selectx==3&&y==1)
						{
							if(0<selectx&&selectx<5 ) OLED_ShowString(3,selectx*3,"| ");
							Delay_ms(100);
							OLED_ShowNum(2,3,alarm[0],2);	//hour		
							OLED_ShowString(2,5,":");		
							OLED_ShowNum(2,6,alarm[1],2);//minate
							OLED_ShowString(2,8,":");
							OLED_ShowNum(2,9,alarm[2],2);//sound
							OLED_ShowString(2,12,"go");
							while(1)
							{
								readxy();
								if(y==1) alarm[2]++;
								if(y==-1) alarm[2]--;
								if(x==-1) {x=0;break;}
								if(alarm[2]>59){alarm[2]=0;}
								if(alarm[2]<0){alarm[2]=59;}								
								OLED_ShowNum(2,9,alarm[2],2);	
							}
						}	
	//go
						if(selectx==4&&y==1)
						{
							if(0<selectx&&selectx<5 ) OLED_ShowString(3,selectx*3,"| ");
							Delay_ms(100);					
							alarm_Enable();		
							
						}	
						
						tim=60*60*alarm[0]+60*alarm[1]+alarm[2];
						OLED_ShowNum(1,3,tim-i2+1,6);
						OLED_ShowNum(3,3,tim,6);
						OLED_ShowNum(3,10,i2,6);
						OLED_ShowString(1,10,"sound");
						if(x==-1) {x=0;break;}
					}
					OLED_Clear();
					selectx=0;
					temp=0;					
				}	
				if(selecty==3&&x==1) //enter scale page  //秤的使用与校准
				{
					selecty=0;
					while(1)
					{
						readxy();
						if(selectx!=temp) //when seletx change clear oled
						{
							OLED_Clear();
							temp=selectx;
						}	
						if(selecty!=temp2) //when selety change clear oled
						{
							OLED_Clear();
							temp2=selecty;
							OLED_ShowString(selecty,15,"<-");
						}
						if(y==1) selecty++;			
						if(y==-1) selecty--;
						if(selecty==0) selecty=1;
						if(selecty==4) selecty=3;
						OLED_ShowSignedNum(4,1,selectx,2);
						OLED_ShowSignedNum(4,4,selecty,2);						
						OLED_ShowString(1,1,"pmscale");
						OLED_ShowString(2,1,"dnscale");
						OLED_ShowString(3,1,"calibration");
						if(selecty==1&&x==1) //进入pm计价秤
						{
							OLED_Clear(); 
							while(1)
							{
								readxy();
								wei=weight();
								OLED_ShowString(1,7,"kg");
								OLED_ShowString(1,3,".");
								OLED_ShowString(2,1,"p=");
								OLED_ShowString(2,5,".");
								OLED_ShowString(2,8,"m=");
								OLED_ShowString(2,13,".");
								OLED_ShowNum(1,1,wei/1000,2);
								OLED_ShowNum(1,4,wei%1000,3);
								key=bigkeyread();
								if(key)
								{
									if(key<11)
									{									
										p*=10;
										p=p+key%10;
										if(p>9999) p/=10;
									}	
									if(key==11)
									{
										p/=10;
									}
								}
								OLED_ShowNum(2,3,p/100,2);
								OLED_ShowNum(2,6,p%1000,2);
								m=p*wei;
								OLED_ShowNum(3,1,m,9);
								OLED_ShowNum(2,10,m/100000,3);
							  OLED_ShowNum(2,14,m/1000,2);
								if(x==-1) {x=0;break;}
								
								if(key!=0) num=key;
								OLED_ShowNum(4,1,num,2);
							}
							OLED_Clear(); 
							OLED_ShowString(selecty,15,"<-");
						}
						if(selecty==2&&x==1) //进入dn计价秤
						{
							OLED_Clear(); 
							while(1)
							{
								readxy();
								wei=weight();
								OLED_ShowString(1,7,"kg");
								OLED_ShowString(1,3,".");
								OLED_ShowString(2,1,"d=");
								OLED_ShowString(2,8,"n=");
								OLED_ShowString(2,13,".");
								OLED_ShowNum(1,1,wei/1000,2);
								OLED_ShowNum(1,4,wei%1000,3);
								key=bigkeyread();
								if(key)
								{
									if(key<11)
									{									
										d*=10;
										d=d+key%10;
										if(d>9999) d/=10;
									}	
									if(key==11)
									{
										d/=10;
									}
								}
								OLED_ShowNum(2,3,d,5);
								n=wei/d*100000;
								OLED_ShowNum(3,1,n,9);	
								OLED_ShowNum(2,10,n/100000,3);
							  OLED_ShowNum(2,14,n/1000,2);
								if(x==-1) {x=0;break;}
								
								if(key!=0) num=key;
								OLED_ShowNum(4,1,num,2);
							}
							OLED_Clear(); 
							OLED_ShowString(selecty,15,"<-");
						}
						if(selecty==3&&x==1) //进入校准模式
						{			
							OLED_Clear(); 
							cou=hx_Read();
							co=cou;
							while(1)
							{								
								readxy();					
								wei=weight();
								OLED_ShowString(1,1,"put thing");
								cou=hx_Read();
								OLED_ShowNum(2,1,d1,6);
								OLED_ShowString(2,7,"g");
								OLED_ShowNum(2,8,x1,8);
								OLED_ShowNum(3,1,cou,15);
								key=bigkeyread();
								if(key)
								{
									if(key<11)
									{									
										d*=10;
										d=d+key%10;
										if(d>9999) d/=10;
									}	
									if(key==11)
									{
										d/=10;
									}
									if(key==13)  //放入数据
									{
										d1=d;
										d=0;
										x1=cou;
									}		
									if((key==14)&&(d1!=0)) //计算模型常量a b 
									{	
										a=(x1-co)/d1;
										b=co/a;	
									}
								}
								OLED_ShowNum(4,1,d,6);	
								OLED_ShowNum(4,8,a,4);
								OLED_ShowNum(4,13,b,4);
								if(x==-1) {x=0;break;}	
								if(x==1)  //把模型常量a b 放入24c02
								{
									AT24C02wdata2(1,a/255);
									AT24C02wdata2(2,a%255);
									AT24C02wdata2(3,b/255);
									AT24C02wdata2(4,b%255);	
									OLED_Clear(); 
									OLED_ShowString(1,1,"ok");								
								}
							}
							OLED_Clear(); 
							OLED_ShowString(selecty,15,"<-");
						}		
						if(x==-1) {x=0;break;}
					}
					selecty=3;
					OLED_Clear();
				}						
				OLED_ShowSignedNum(4,8,selectx,1);
			  OLED_ShowSignedNum(4,10,selecty,1);
				OLED_ShowSignedNum(4,1,x,2);
			  OLED_ShowSignedNum(4,4,y,2);				
				if(x==-1) {x=0;break;}  //退出菜单界面
			}
			OLED_Clear();
		}
		key=bigkeyread();
		if(key!=0) num=key;
		OLED_ShowNum(4,1,num,2);
	}
}

下面为HX秤代码。

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "24c02.h"

#define sck1 GPIO_SetBits(GPIOA,GPIO_Pin_12)   //sck置1
#define sck0 GPIO_ResetBits(GPIOA,GPIO_Pin_12)  //sck置0
#define dot GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_11) //dot的值

uint16_t a,b;
void hx_Init() //端口初始化 A0 DOT A1 SCK 
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_12;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	a=255*AT24C02rdata(1)+AT24C02rdata(2);
	b=255*AT24C02rdata(3)+AT24C02rdata(4);
}
int i;
uint32_t count;
uint32_t hx_Read() //读取count
{
	sck0;   //变量初始化
	count=0;
	
	while(dot==1);    //等待dot置0
	for(i=0;i<24;i++)  //dot置零后 一边sck置1 一边读取cot返回的数据
	{
		sck1; //sck拉高 让dot发出数据
		Delay_us(1); //等待dot 发出数据
		if(dot==1) {count++;count=count<<1;}   //对dot两种状态分类讨论
		if(dot==0) count=count<<1;
		Delay_us(1); //sck 拉高后不能立即拉低 高电平时长一共2us 
		sck0;   //sck拉低准备下次收数据
		Delay_us(2);  //准备时长2us起步
	}
	sck1; //脉冲发送至25次 让下次增益到128
	Delay_us(2);
	sck0;
	return count;
}
int16_t weight() //count转化为实物重量
{	
	
	return hx_Read()/a-b; //转换函数
}

#ifndef __HX_h
#define __HX_h
void hx_Init();
uint32_t hx_Read();
extern uint32_t count;
int16_t weight();
extern uint16_t a,b;
#endif

下面为xysw摇杆代码。

#include "stm32f10x.h"                  // Device header

int dr[2]={0},x,y;

void xysw_Init()
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);	
	
	RCC_ADCCLKConfig(RCC_PCLK2_Div6);  //ADC分频
	
	GPIO_InitTypeDef GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AIN; //模拟输入
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1; 
	GPIO_Init(GPIOB,&GPIO_InitStruct);
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
	GPIO_Init(GPIOA,&GPIO_InitStruct);
	
	ADC_RegularChannelConfig(ADC1,ADC_Channel_8,1,ADC_SampleTime_1Cycles5); //通道顺序 采样 分配
	ADC_RegularChannelConfig(ADC1,ADC_Channel_9,2,ADC_SampleTime_1Cycles5);
	
	ADC_InitTypeDef ADC_InitStruct;
	ADC_InitStruct.ADC_ContinuousConvMode=ENABLE;
	ADC_InitStruct.ADC_DataAlign=ADC_DataAlign_Right;
	ADC_InitStruct.ADC_ExternalTrigConv=ADC_ExternalTrigConv_None;
	ADC_InitStruct.ADC_Mode=ADC_Mode_Independent;
	ADC_InitStruct.ADC_NbrOfChannel=2;
	ADC_InitStruct.ADC_ScanConvMode=ENABLE;
	ADC_Init(ADC1,&ADC_InitStruct);
	
	DMA_InitTypeDef DMA_InitStruct;
	DMA_InitStruct.DMA_BufferSize=2;
	DMA_InitStruct.DMA_DIR=DMA_DIR_PeripheralSRC;
	DMA_InitStruct.DMA_M2M=DMA_M2M_Disable;
	DMA_InitStruct.DMA_MemoryBaseAddr=(uint32_t)dr;
	DMA_InitStruct.DMA_MemoryDataSize=DMA_MemoryDataSize_Word;
	DMA_InitStruct.DMA_MemoryInc=DMA_MemoryInc_Enable;
	DMA_InitStruct.DMA_Mode=DMA_Mode_Circular;
	DMA_InitStruct.DMA_PeripheralBaseAddr=(uint32_t)&ADC1->DR;
	DMA_InitStruct.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Word;
	DMA_InitStruct.DMA_PeripheralInc=DMA_PeripheralInc_Disable;
	DMA_InitStruct.DMA_Priority=DMA_Priority_Medium;
	DMA_Init( DMA1_Channel1,&DMA_InitStruct);

	DMA_Cmd(DMA1_Channel1,ENABLE);
	ADC_DMACmd(ADC1,ENABLE);	
	ADC_Cmd(ADC1,ENABLE);
	
	ADC_ResetCalibration(ADC1);
	while (ADC_GetResetCalibrationStatus(ADC1)==SET);
	ADC_StartCalibration(ADC1);
	while (ADC_GetCalibrationStatus(ADC1)==SET);
	
	ADC_SoftwareStartConvCmd(ADC1,ENABLE);
	
	x=0;
	y=0;
}

void readxy()
{
	if(1000<dr[1]&&dr[1]<3000) {x=0;Delay_ms(20);}
	if(dr[1]>3000) {while(dr[1]>3000);Delay_ms(20);x=1;}
	if(dr[1]<1000) {while(dr[1]<1000);Delay_ms(20);x=-1;}	
		
	if(1000<dr[0]&&dr[0]<3000) {y=0;Delay_ms(20);}
	if(dr[0]>3000) {while(dr[0]>3000);y=1;Delay_ms(20);}
	if(dr[0]<1000) {while(dr[0]<1000);y=-1;Delay_ms(20);}		
}


#ifndef __xysw_h
#define __xysw_h
extern int	dr[2],x,y;

void xysw_Init();
void readxy();

#endif

下面是DS1302代码。

#include "stm32f10x.h"                  // Device header
#include "Delay.h"

#define DS1302_SECOND		0x80
#define DS1302_MINUTE		0x82
#define DS1302_HOUR			0x84
#define DS1302_DATE			0x86
#define DS1302_MONTH		0x88
#define DS1302_DAY			0x8A
#define DS1302_YEAR			0x8C
#define DS1302_WP				0x8E

#define clk  GPIO_Pin_15  //p36
#define dat  GPIO_Pin_13	//p34
#define rst  GPIO_Pin_14	//p35

#define rst1 GPIO_SetBits(GPIOB,rst)
#define rst0 GPIO_ResetBits(GPIOB,rst)
#define clk1 GPIO_SetBits(GPIOB,clk)
#define clk0 GPIO_ResetBits(GPIOB,clk)
#define dat1 GPIO_SetBits(GPIOB,dat)
#define dat0 GPIO_ResetBits(GPIOB,dat)

#define rdat GPIO_ReadInputDataBit(GPIOB,dat)

int DS1302_Time[]={23,2,17,19,20,0,1};

//unsigned char DS1302_Time[7]={0};

void DS1302_Init()
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
	
	GPIO_InitTypeDef	GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
	GPIO_InitStruct.GPIO_Pin=rst|clk|dat;
	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
	GPIO_Init(GPIOB,&GPIO_InitStruct);
	
	rst0;
	clk0;
	dat0;
}
void write(uint16_t command,uint16_t data)
{
	uint16_t i,temp;
	rst1;
	for(i=0;i<8;i++)
	{
		temp=command&(0x01<<i); //一位位的取command的数据
		if(temp) dat1;          //放上数据
		if(temp==0) dat0;
		clk1;   //上升沿发送数
		clk0;
	}
	for(i=0;i<8;i++)
	{
		temp=data&(0x01<<i);
		if(temp) dat1;
		if(temp==0) dat0;
		clk1;  
		clk0;
	}	
	rst0;
	dat0;
}
uint16_t read(uint16_t command)
{
	command|=0x01;
	uint16_t i,temp,data;
	rst1;
	data=0;
	for(i=0;i<8;i++)
	{
		temp=command&(0x01<<i);
		if(temp) dat1;
		if(temp==0) dat0;
		clk0;
		clk1;
	}
	GPIO_InitTypeDef	GPIO_InitStruct;   //定义dat为写入模式
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStruct.GPIO_Pin=dat;
	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
	GPIO_Init(GPIOB,&GPIO_InitStruct);
	for(i=0;i<8;i++)   
	{
		clk1;   //下降沿让1302 把数据放在dat上
		clk0;
		if(rdat) data|=(0x01<<i);
	}	
	rst0;
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;  //定义dat为默认输出模式
	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_10MHz;
	GPIO_InitStruct.GPIO_Pin=dat;
	GPIO_Init(GPIOB,&GPIO_InitStruct);
	return data;  
	dat0;
}
void DS1302_SetTime(void)
{
	write(DS1302_WP,0x00);
	write(DS1302_YEAR,DS1302_Time[0]/10*16+DS1302_Time[0]%10);
	write(DS1302_MONTH,DS1302_Time[1]/10*16+DS1302_Time[1]%10);
	write(DS1302_DATE,DS1302_Time[2]/10*16+DS1302_Time[2]%10);
	write(DS1302_HOUR,DS1302_Time[3]/10*16+DS1302_Time[3]%10);
	write(DS1302_MINUTE,DS1302_Time[4]/10*16+DS1302_Time[4]%10);
	write(DS1302_SECOND,DS1302_Time[5]/10*16+DS1302_Time[5]%10);
	write(DS1302_DAY,DS1302_Time[6]/10*16+DS1302_Time[6]%10);
	write(DS1302_WP,0x80);
}
void DS1302_ReadTime(void)
{
	unsigned char Temp;
	Temp=read(DS1302_YEAR);
	DS1302_Time[0]=Temp/16*10+Temp%16;
	Temp=read(DS1302_MONTH);
	DS1302_Time[1]=Temp/16*10+Temp%16;
	Temp=read(DS1302_DATE);
	DS1302_Time[2]=Temp/16*10+Temp%16;
	Temp=read(DS1302_HOUR);
	DS1302_Time[3]=Temp/16*10+Temp%16;
	Temp=read(DS1302_MINUTE);
	DS1302_Time[4]=Temp/16*10+Temp%16;
	Temp=read(DS1302_SECOND);
	DS1302_Time[5]=Temp/16*10+Temp%16;
	Temp=read(DS1302_DAY);
	DS1302_Time[6]=Temp/16*10+Temp%16;
	
}

#ifndef __ds1302_h
#define __ds1302_h
#define DS1302_SECOND		0x80
#define DS1302_MINUTE		0x82
#define DS1302_HOUR			0x84
#define DS1302_DATE			0x86
#define DS1302_MONTH		0x88
#define DS1302_DAY			0x8A
#define DS1302_YEAR			0x8C
#define DS1302_WP				0x8E
extern  int DS1302_Time[];
void DS1302_Init();
void DS1302_SetTime(void);
void DS1302_ReadTime(void);
uint16_t read(uint16_t command);
void write(uint16_t command,uint16_t data);
#endif

下面是矩阵代码。

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#define p7 GPIO_Pin_0	//p17
#define p6 GPIO_Pin_1
#define p5 GPIO_Pin_2
#define p4 GPIO_Pin_3
#define p3 GPIO_Pin_4
#define p2 GPIO_Pin_5
#define p1 GPIO_Pin_6
#define p0 GPIO_Pin_7

void bigkey_Init()
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef	GPIO_InitStruct;
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_Out_PP;
	GPIO_InitStruct.GPIO_Pin=p3|p2|p1|p0;
	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStruct);
	GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStruct.GPIO_Pin=p7|p6|p5|p4;
	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStruct);	
	
}
uint16_t bigkeyread()
{
	uint16_t keynum;
	keynum=0;
	GPIO_SetBits(GPIOA,p3);
	GPIO_SetBits(GPIOA,p2);
	GPIO_SetBits(GPIOA,p1);
	GPIO_SetBits(GPIOA,p0);
	GPIO_ResetBits(GPIOA,p3);
	if(GPIO_ReadInputDataBit(GPIOA,p7)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p7)==0);Delay_ms(20);keynum=1;}
	if(GPIO_ReadInputDataBit(GPIOA,p6)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p6)==0);Delay_ms(20);keynum=5;}
	if(GPIO_ReadInputDataBit(GPIOA,p5)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p5)==0);Delay_ms(20);keynum=9;}
	if(GPIO_ReadInputDataBit(GPIOA,p4)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p4)==0);Delay_ms(20);keynum=13;}
	GPIO_SetBits(GPIOA,p3);
	GPIO_SetBits(GPIOA,p2);
	GPIO_SetBits(GPIOA,p1);
	GPIO_SetBits(GPIOA,p0);
	GPIO_ResetBits(GPIOA,p2);
	if(GPIO_ReadInputDataBit(GPIOA,p7)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p7)==0);Delay_ms(20);keynum=2;}
	if(GPIO_ReadInputDataBit(GPIOA,p6)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p6)==0);Delay_ms(20);keynum=6;}
	if(GPIO_ReadInputDataBit(GPIOA,p5)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p5)==0);Delay_ms(20);keynum=10;}
	if(GPIO_ReadInputDataBit(GPIOA,p4)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p4)==0);Delay_ms(20);keynum=14;}
	GPIO_SetBits(GPIOA,p3);
	GPIO_SetBits(GPIOA,p2);
	GPIO_SetBits(GPIOA,p1);
	GPIO_SetBits(GPIOA,p0);
	GPIO_ResetBits(GPIOA,p1);
	if(GPIO_ReadInputDataBit(GPIOA,p7)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p7)==0);Delay_ms(20);keynum=3;}
	if(GPIO_ReadInputDataBit(GPIOA,p6)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p6)==0);Delay_ms(20);keynum=7;}
	if(GPIO_ReadInputDataBit(GPIOA,p5)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p5)==0);Delay_ms(20);keynum=11;}
	if(GPIO_ReadInputDataBit(GPIOA,p4)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p4)==0);Delay_ms(20);keynum=15;}
	GPIO_SetBits(GPIOA,p3);
	GPIO_SetBits(GPIOA,p2);
	GPIO_SetBits(GPIOA,p1);
	GPIO_SetBits(GPIOA,p0);
	GPIO_ResetBits(GPIOA,p0);
	if(GPIO_ReadInputDataBit(GPIOA,p7)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p7)==0);Delay_ms(20);keynum=4;}
	if(GPIO_ReadInputDataBit(GPIOA,p6)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p6)==0);Delay_ms(20);keynum=8;}
	if(GPIO_ReadInputDataBit(GPIOA,p5)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p5)==0);Delay_ms(20);keynum=12;}
	if(GPIO_ReadInputDataBit(GPIOA,p4)==0) {Delay_ms(20);while(GPIO_ReadInputDataBit(GPIOA,p4)==0);Delay_ms(20);keynum=16;}
	return keynum;
}

#ifndef __bigkey_h
#define __bigkey_h
void bigkey_Init();
uint16_t bigkeyread();
unsigned char MatrixKey();
#endif

下面是ALLAM代码。

#include "stm32f10x.h"                  // Device header
#include "buzzer.h"
#include "OLED.h"
#include "main.h"
int  i2;
uint16_t tim;
void alarm_Init()
{
	i2=0;
	tim=0;
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);
	
	TIM_InternalClockConfig(TIM2);
	
	TIM_TimeBaseInitTypeDef TIM_Timebaseinitstructure;
	TIM_Timebaseinitstructure.TIM_ClockDivision=TIM_CKD_DIV1;
	TIM_Timebaseinitstructure.TIM_CounterMode=TIM_CounterMode_Up;
	TIM_Timebaseinitstructure.TIM_Period=10000-1;
	TIM_Timebaseinitstructure.TIM_Prescaler=72000-1;
	TIM_Timebaseinitstructure.TIM_RepetitionCounter=0;
	TIM_TimeBaseInit(TIM2,&TIM_Timebaseinitstructure);
	
	TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	
	NVIC_InitTypeDef NVIC_Initstructure;
	NVIC_Initstructure.NVIC_IRQChannel=TIM2_IRQn;
	NVIC_Initstructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_Initstructure.NVIC_IRQChannelPreemptionPriority=2;
	NVIC_Initstructure.NVIC_IRQChannelSubPriority=2;
	
	NVIC_Init(&NVIC_Initstructure);
	
	TIM_Cmd(TIM2,DISABLE);
}
void alarm_Enable()
{
	TIM_Cmd(TIM2,ENABLE);
}
void TIM2_IRQHandler()
{
	if(TIM_GetITStatus(TIM2,TIM_IT_Update)==SET)
	{
		i2++;
		if(i2==tim) {buzzer();i2=0;tim=0;TIM_Cmd(TIM2,DISABLE);OLED_Clear();main();}
		
		TIM_ClearITPendingBit(TIM2,TIM_IT_Update);
	}
}

#ifndef __alarm_h
#define __alarm_h
void alarm_Init();
extern uint16_t tim;
extern int	i2;
void alarm_Enable();

#endif

richwerido
关注
基于STM32设计的数字电子秤
12-29 1万+
当前项目是采用采用STM32+称重模块+OLED实现了简单的电子秤项目，称重模块上采用24位的ADC芯片，精度较高。实现了称重，校准、去皮等功能。
基于STM32的智能电子秤原理图PCB程序设计
weixin_44116175的博客
05-17 7367
硬件设计 （末尾附文件） 本次设计以STM32单片机为核心，利用压力传感器监测货物的压力并转换成电流输出给AD芯片，HX711转换模块将模拟量转换成数字量并输出给单片机，STM32单片机通过公式计算出具体的货物重量，采用按键矩阵对结果进行加减乘除，得出总价或者其他的结果。LCD1602液晶屏上显示检测到的货物重量、单价和总价。 设计思路 以STM32为中央处理器，通过压力传感器监测货物对其造成的压力，并以电流变化输出给HX711AD模块，hx711AD芯片将模拟量转换成数字量并发送给单片机，经单片机计算后，
基于STM32的智能电子秤设计
热门推荐
m0_60790717的博客
11-01 1万+
本次设计采用STM32单片机作为处理器，控制各个传感器和外设，采用LCD1602液晶屏作为显示器，显示检测到的重量，压力传感器用于称重，通过检测物体对传感器造成的压力，通过公式计算得出物体的重量，此外通过16个按键组成矩阵键盘，可以输入数字，并进行加减乘除操作，通过重量和单价计算出总价。
【毕业设计】基于stm32的智能电子秤系统 - 物联网 嵌入式 单片机
m0_71572576的博客
08-25 7191
🔥 这两年开始毕业设计和毕业答辩的要求和难度不断提升，传统的毕设题目缺少创新和亮点，往往达不到毕业答辩的要求，这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的是🚩基于stm32的智能电子秤系统🥇学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：3分🧿基于stm32的智能电子秤设计，有很多功能，称重，报警，蓝牙app连接，语音播报，去皮等。
基于STM32的电子秤制作
a666266777的博客
12-09 2801
如果需要准确的输出数据速率，可将外部 输入时钟通过一个 20pF 的隔直电容连接到 XI 管脚上，或将晶振连接到 XI 和 XO 管脚上。这 种情况下，芯片内的时钟振荡器电路会自动关闭，晶振时钟或外部输入时钟电路被采用。当数据输出管脚 DOUT 为高电平时，表明 A/D 转换器还未准备好输出数据，此时串口时 钟输入信号 PD_SCK 应为低电平。其中第一个时钟脉冲 的上升沿 将读出输出 24 位数据的最高位 （MSB），直至第 24 个时钟脉冲完成，24 位输 出数据从最高位至最低位逐位输出完成。
基于STM32f103的电子秤系统设计
不去幼儿园的博客
03-30 3197
本次设计的基于STM32f103的电子秤系统主要从系统整体设计、硬件电路设计，系统软件设计，三部分进行详细阐述。硬件电路设计主要是基于嵌入式STM32f103为核心的控制单元来实现数据的处理，采用压力传感器对数据进行采集，使用电子秤专用24位AD转换芯片HX711对传感器采集到的模拟量进行AD转换，转换后的数据送到STM32f103进行处理显示，数据显示由LCD1602液晶实现，通过按键实现功能的选择，并且加入了LED闪烁和蜂鸣器报警等。本次课程设计的电子秤反应灵敏、准确度高、显示直观、性能稳定,、操作简单
基于STM32单片机的电子秤（Proteus仿真+程序）
bxy415655001的博客
11-04 5776
10、基于STM32单片机的电子秤
基于stm32单片机电子秤设计
qq_34711957的博客
10-19 3846
开源资料：链接：https://pan.baidu.com/s/1CRUI036fSKXzzBTyXWKNyg?模块:采用STM32F103C8T6+LCD1602液晶显示+4*4矩阵按键+电子秤+hx711压力传感器。资料：提供程序源码，图纸，以及使用视频；2.按键可以设置当前物品单价带，支持小数点输入。4.按键确认按键液晶显示当前重量，单价，总价。基于STM32F103C8T6计价电子秤。3.具有基础电子秤去皮清零功能。1.液晶显示当前重量大小。
基于STM32单片机的电子秤仿真设计
weixin_44116175的博客
06-21 5360
硬件设计 （末尾附文件） 代码设计 HX711： #include "bsp_hx711.h" #include "bsp_delay.h" #define CLR_HX711_SCK (GPIO_ResetBits(HX711_SCK_PORT, HX711_SCK_PIN)) #define SET_HX711_SCK (GPIO_SetBits(HX711_SCK_PORT, HX711_SCK_PIN)) #define HX711_DOUT_R (GPIO_ReadInputDataBit(
关于用stm32去做电子秤的一些问题
qq_46058973的博客
12-01 3035
关于用stm32去做电子秤的一些问题 刚开始是用51写的，lcd1602显示，写的也算可以，数据显示的也很稳定，后来想做的项目51实现不了，就想着用32去实现，可这就出现了一些问题，我用的是正点原子的mini板子，hx711压力传感 第一个问题就是，程序下进去后，再复位或者断开电源，lcd就不显示内容了，后里发现是主函数的uart_init 函数，不能去掉，因为在 LCD_Init 函数里面调用了 printf，所以一旦你去掉这个初始化，就会死机了，就不再会显示 第二就是显示数字不稳定，因为这是24位的，很
基于STM32的电子秤-HX711模块-OLED显示
08-01
《基于STM32的电子秤设计与实现——以HX711模块及OLED显示为例》 在现代科技生活中，电子秤已经广泛应用于各种场景，从家庭厨房到商业零售，其精准、便捷的特点深受青睐。本文将深入探讨一个基于STM32微控制器的5KG...
基于STM32的电子时钟设计
10-10
【STM32基础介绍】 ...总的来说，基于STM32的电子时钟设计融合了嵌入式系统、微控制器编程、数字信号处理、硬件设计等多个领域的知识，是一个综合性的实践项目，对学习和提升嵌入式系统开发能力大有裨益。
STM32F4x7+freertos+lwip+ssl+MQTT-(MDK5)稳定可靠
12-11
这是公司实际项目工程（编译器用DK5）,STM32F4x7+freertos+lwip+ssl+MQTT，其中MQTT自己花了一个礼拜移植，可以同时发布消息和订阅消息（发布主题：DongLuTest，订阅主题：mymqttsubtest），经过长期测试MQTT运行...
0.3 学习Stm32经历过的磨难
2302_79677613的博客
08-27 1502
MDK报错 Browse information not available
江协科技stm32————11-4 SPI通信协议
zgwws_的博客
09-04 1145
SPI1挂载在APB2是，PCLK是72MSPI2挂载在APB1是，PCLK是36M只了解SPI做主机的情况，一般采样全双工可以使用DMA自动搬运数据I2S（音频传输）全双工通信：SPI可以同时发送和接收数据。主从模式：设备可以配置为主模式（提供时钟信号）或从模式（接收时钟信号）。时钟极性和相位：通过配置时钟极性（CPOL）和相位（CPHA），用户可以选择何时进行数据采样和发送。数据帧格式：数据帧可以配置为8位或16位，并且可以选择MSB（最高有效位）优先或LSB（最低有效位）优先发送数据。
STM32-HAL库开发快速入门
xuhc_zd的博客
09-06 1061
STM32-HAL库开发：记录使用HAL库开发时候如何配置STM32的各个外设-
STM32关于keil使用过程中遇到的问题
最新发布
xuhc_zd的博客
09-09 497
STM32开发工具keil使用过程中遇到的问题
STM32双轮平衡小车（基于STM32F103C8T6HAL库）
xuhc_zd的博客
09-07 1112
STM32双轮平衡小车：电机控制、编码器测速、PID控制
stm32之SPI通信外设
Mr_Jaychong的博客
09-09 799
本文主要探讨stm32之SPI通信外设的相关概念以及基本结构等，最后详细地分析了SPI外设的时序，为进一步学习SPI通信打下基础。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值