3KG电子称 自动灌装C语言 编程

最新推荐文章于 2022-03-15 12:34:20 发布
最新推荐文章于 2022-03-15 12:34:20 发布
阅读量409 收藏
点赞数
分类专栏： 显示 液晶显示
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czhaii/article/details/104308796
版权

//***********3KG电子称测试程序**HX711电路板*****************
//******2013 6 23 13:10 L714 自动称重测试 版本V1.0
/***3.2  1.4 0.7 3.1 ***********************/
/***0.6  0.5 0.4 rst ***********************/
/*******************************************/
/***设定 返回 ******************************/
/***重量 位选 清零 复位*********************/
/********-------------------------**********/
/*******|设定 00000 |***********************/
/*******|实际 00000 |***********************/
/*******|产量 0000  |***********************/
/*******|灌装 00285 |***********************/
/********-------------------------**********/
                  #include       <reg52.h>
                  #include       <intrins.h>
                  #define        uint unsigned int 
                  #define        uchar unsigned char 
                  uchar          code disdt[10]={0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9};
                  uint           val,val1,val2,val3;      /*设定重量 实际重量 灌装结束重量 产量 */
                  uint           a,l,m,n,k,s,w,ww;             /****个十百代码缓冲**/
                  sbit           Buzzer=P1^1;
                  sbit           OUT1=P1^0;  
                  sbit           OUT2=P1^1;
                  sbit           OUT3=P1^3;  
                  unsigned long  HX711_Buffer = 0;
                  unsigned int   Weight_Maopi = 0,WeiDATA =0;
                  uint           t0,t1,t2,t3,t4,ta,tb,tc,td,te,t01,t02,t03,t04;
                  uchar             TBIT;                   //光标地址计数器
                  sbit           HX711_DOUT=P3^3; 
                  sbit           HX711_SCK=P3^4; 
                  sbit           RS=P3^5; 
                  sbit           RW=P3^6; 
                  sbit           E=P3^7; 
                  sbit           SDA=P1^7;               /****EEPROM数据****/
                  sbit           SCL=P1^6;               /****EEPROM脉冲****/
                  sbit           SETWEIGHT=P3^2;          //重量设定
                  sbit           BACK=P1^4;              //重量设定
                  sbit           WEIGHTSET=P0^6;          //重量
                  sbit           WEIGHTBIT=P0^5;          //重量位选
                  sbit           WEIGHTCLR=P3^1;          //归零
                  sbit           TOTALCLR=P0^4;          //产量清零
                  sbit           MUTALAIR=P0^7;          //手动灌装
                  sbit           Filling=P0^0;              //灌装P0^0;     
                  #define         Lcd_Bus P2 
                  bdata          char com_data;   
                  sbit           mos_bit=com_data^7;     /****高位****/
                  sbit           low_bit=com_data^0;     /****低位****/
/**************************************/
                 void start()
                 {
                   SDA=1;_nop_();_nop_();_nop_();_nop_();
                   SCL=1;_nop_();_nop_();_nop_();_nop_();
                   SDA=0;_nop_();_nop_();_nop_();_nop_();
                   SCL=0;_nop_();_nop_();_nop_();_nop_();
                  }
/***************************************/
                 void stop()
                 {
                   SDA=0;_nop_();_nop_();_nop_();_nop_();
                   SCL=1;_nop_();_nop_();_nop_();_nop_();
                   SDA=1;_nop_();_nop_();_nop_();_nop_();
                  }
/***************************************/
                 void ack()
                 {
                   SCL=1;_nop_();_nop_();_nop_();_nop_();
                   SCL=0;_nop_();_nop_();_nop_();_nop_();
                  }
/***************************************/
                 void shift8(char a)
                  {
                    data uchar i;
                    com_data=a;
                    for(i=0;i<8;i++)
                     {
                       SDA=mos_bit;
                       SCL=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
                       SCL=0;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
                       com_data=com_data*2;
                      }
                    }
/***************************************/
                 void delay_iic(int v)
                     {
                       int i;
                       for(i=1;i<v;i++){;}
                      } 
/***************************************/
                 uchar rd_24c01(char a)
                   {
                     data uint i,command;
                     SDA=1;_nop_();_nop_();_nop_();_nop_();
                     SCL=0;_nop_();_nop_();_nop_();_nop_();
                     start();
                     command=160;
                     shift8(command);                            /*****写入160*****/
                     ack();
                     shift8(a);
                     ack();
                     start();
                     command=161;
                     shift8(command);                            /*****写入161*****/
                     ack();
                     SDA=1;_nop_();_nop_();_nop_();_nop_();
                     for(i=0;i<8;i++)
                     {
                      com_data=com_data*2;
                      SCL=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
                      low_bit=SDA;
                      SCL=0;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
                     }
                    stop();
                    return(com_data);
                  }
/***************************************/
                 void wr_24c01(char a,char b)
                  {
                    data uint command;
                    _nop_();_nop_();_nop_();_nop_();_nop_();
                    SDA=1;_nop_();_nop_();_nop_();_nop_();
                    SCL=0;_nop_();_nop_();_nop_();_nop_();
                    start();
                    command=160;
                    shift8(command);                             /*****写入160*****/
                    ack();
                    shift8(a);                                   /*****写入 a *****/
                    ack();
                    shift8(b);                                   /*****写入 b *****/
                    ack();
                    stop();
                    _nop_();_nop_();_nop_();_nop_();_nop_();
                  }
/*********写入EEPROM 运行总时*****************************/
               void writea(void)
                  { 
                   wr_24c01(1,a);delay_iic(200);                 /*写入万位*/
                   wr_24c01(2,l);delay_iic(200);                 /*写入千位*/
                   wr_24c01(3,m);delay_iic(200);                 /*写入百位*/
                   wr_24c01(4,n);delay_iic(200);                 /*写入十位*/
                   wr_24c01(5,s);delay_iic(200);                 /*写入个位*/
                  }  
 /**************************************/
               void red24 (void)
                  { 
                     a=rd_24c01(1);delay_iic(25);                  /*数据万位*/
                   l=rd_24c01(2);delay_iic(25);                  /*数据千位*/
                   m=rd_24c01(3);delay_iic(25);                  /*数据百位*/
                   n=rd_24c01(4);delay_iic(25);                  /*数据十位*/
                   s=rd_24c01(5);delay_iic(25);                  /*数据个位*/
                   val1=a*10000+l*1000+m*100+n*10+s;/*x置初值合并A数据 百位乘百 十位乘十*/
                  }
/*------------------检查忙位--------------------------*/ 
                void chk_busy() 
                   { 
                    RS=0; 
                    RW=1; 
                    E=1; 
                    Lcd_Bus=0xff; 
                    while((Lcd_Bus&0x80)==0x80); 
                    E=0; 
                   } 
/*------------------延时子程序------------------------*/ 
                void delay(unsigned int t) 
                   { 
                    uint i,j; 
                    for(i=0;i<t;i++) 
                    for(j=0;j<20;j++); 
                   }                
/*------------------写命令到LCD-----------------------*/ 
                void write_com(uchar cmdcode) 
                  { 
                    chk_busy(); 
                    RS=0; 
                    RW=0; 
                    E=1; 
                    Lcd_Bus=cmdcode; 
                    delay(3);                            /*在数据写入的时候加入适当的延时*/ 
                    E=0; 
                    delay(3); 
                   } 
/*-------------------写数据到LCD----------------------*/ 
                void write_data(unsigned char Dispdata) 
                  { 
                    chk_busy(); 
                    RS=1; 
                    RW=0; 
                    E=1; 
                    Lcd_Bus=Dispdata; 
                    delay(3);                           /*在数据写入的时候加入适当的延时 */
                    E=0; 
                    delay(3); 
                  } 
/*------------------显示文字--------------------------*/ 
             void   displaywriting()                                     
               {                                               
                write_com(0x80);                              
                write_data(0xC9);                           
                write_data(0xE8);                 
                write_com(0x81);                               
                write_data(0xB6);
                write_data(0xA8);                  //设定  
                write_com(0x82); 
                write_data(0xA3);
                write_data(0xBA);                  /*---:----*/ 
                write_com(0x90);                              
                write_data(0xD6);                           
                write_data(0xD8);                 
                write_com(0x91);                               
                write_data(0xC1);
                write_data(0xBF);                  //实际 改皮重
                write_com(0x92); 
                write_data(0xA3);
                write_data(0xBA);                  /*---:----*/ 
                write_com(0x88);                              
                write_data(0xB2);                           
                write_data(0xFA);                 
                write_com(0x89);                               
                write_data(0xC1);
                write_data(0xBF);                  //产量
                write_com(0x8A); 
                write_data(0xA3);
                write_data(0xBA);                  /*---:----*/ 
               } 
/*------------------显示灌装---------------------------------*/ 
             void     disfilling()
               { 
                write_com(0x98);                              
                write_data(0xB9);                           
                write_data(0xE0);                 
                write_com(0x99);                               
                write_data(0xD7);
                write_data(0xB0);                  //灌装
               } 
/*------------------清除灌装---------------------------------*/ 
             void  clrfilling()
               { 
                write_com(0x98);                              
                write_data(0xB6);                           
                write_data(0xA0);                 
                write_com(0x99);                               
                write_data(0xB6);
                write_data(0xA0);                  //清除显示灌装
               } 
/*------------------显示设定重量数据--------------------------*/ 
            void   displaya()                                     
               {                                               
                write_com(0x83);                              
                write_data(0xA3);                           
                write_data(disdt[a]);                      
                write_com(0x84);                               
                write_data(0xA3);
                write_data(disdt[l]);        
                write_com(0x85);                             
                write_data(0xA3); 
                write_data(disdt[m]);    
                write_com(0x86);                               
                write_data(0xA3);
                write_data(disdt[n]);        
                write_com(0x87);                             
                write_data(0xA3); 
                write_data(disdt[s]);
                }  
/*------------------显示实际重量数据--------------------------*/ 
             void   displayb()                                     
               {                                               
                write_com(0x93);                              
                write_data(0xA3);                           
                write_data(disdt[t0]);                      
                write_com(0x94);                               
                write_data(0xA3);
                write_data(disdt[t1]);        
                write_com(0x95);                             
                write_data(0xA3); 
                write_data(disdt[t2]);    
                write_com(0x96);                               
                write_data(0xA3);
                write_data(disdt[t3]);        
                write_com(0x97);                             
                write_data(0xA3); 
                write_data(disdt[t4]); 
               }  
/*------------------显示结束重量数据--------------------------*/ 
             void   displayc()                                     
               {                                               
                write_com(0x9a);                              
                write_data(0xA3);                           
                write_data(disdt[ta]);                      
                write_com(0x9b);                               
                write_data(0xA3);
                write_data(disdt[tb]);        
                write_com(0x9c);                             
                write_data(0xA3); 
                write_data(disdt[tc]);    
                write_com(0x9d);                               
                write_data(0xA3);
                write_data(disdt[td]);        
                write_com(0x9e);                             
                write_data(0xA3); 
                write_data(disdt[te]); 
               }  
/*------------------显示产量--------------------------*/ 
             void   displayd()                                     
               {                                               
                write_com(0x8c);                              
                write_data(0xA3);                           
                write_data(disdt[t01]);                      
                write_com(0x8d);                               
                write_data(0xA3);
                write_data(disdt[t02]);        
                write_com(0x8e);                             
                write_data(0xA3); 
                write_data(disdt[t03]);    
                write_com(0x8f);                               
                write_data(0xA3);
                write_data(disdt[t04]); 
                }       
/*------------------初始化LCD屏-----------------------*/ 
           void lcdreset() 
               {
                delay(300);
                RW=0; 
                delay(10);                                       /*选择基本指令集 */
                write_com(0x30);                                 /*选择8bit数据流 */
                delay(50); 
                write_com(0x0F);                                 /*开显示(无游标、不反白) */
                delay(50); 
                write_com(0x01);                                 /*清除显示，并且设定地址指针为00H */
                delay(50); 
                write_com(0x04);                                 /*游标的移动方向及指定显示的移位*/ 
                delay(50); 
               } 
/*******************************************/
              void Delay__hx711_us(void)
              {
               _nop_();
               _nop_();
              }
/*******************************************/
              void Delay_ms(unsigned int n)
              {
               unsigned int  i,j;
               for(i=0;i<n;i++)
               for(j=0;j<123;j++);
              }
/*******************************************/
              unsigned long HX711_Read(void)    //增益128
              {
               unsigned long count; 
               unsigned char i; 
                 HX711_DOUT=1; 
               Delay__hx711_us();
                 HX711_SCK=0; 
                 count=0; 
                 while(HX711_DOUT); 
                 for(i=0;i<24;i++)
               { 
                HX711_SCK=1; 
                count=count<<1; 
                HX711_SCK=0; 
                if(HX711_DOUT)
                count++; 
               } 
                HX711_SCK=1; 
               Delay__hx711_us();
               HX711_SCK=0;  
               return(count);
              }
/*******************************************/
              void Get_Weight()
              {
               HX711_Buffer=HX711_Read();
               HX711_Buffer=HX711_Buffer/100;
               if(HX711_Buffer > Weight_Maopi)            
               {
                WeiDATA=HX711_Buffer;
                WeiDATA=WeiDATA- Weight_Maopi;                //获取实物的AD采样数值。
                WeiDATA=(unsigned int)((float)WeiDATA/13.2+0.05);     //计算实物的实际重量
                if(WeiDATA>25000 )
                 {
                 Buzzer=0;                //打开警报    
                 }
                else
                 {
                  Buzzer=1;                //关闭警报
                 }
               }
             else if(HX711_Buffer<Weight_Maopi-30)
               {
                Buzzer=0;                //负重量报警
               }
              }
/*******************************************/
              void Get_Maopi()
              {
               unsigned char i=0;
               unsigned int Temp_Weight=0;
               Weight_Maopi=0;
               for( i=0;i<10;i++)
               {
                HX711_Buffer=HX711_Read();
                Temp_Weight=HX711_Buffer/100;
                 if(Temp_Weight>Weight_Maopi)
                 {
                  Weight_Maopi=Temp_Weight;     
                 }
                }        
               } 
/**************设定重量处理*****************************/
               void  dispose1()
               {
                a=val1/10000;                                    /*除以10000*/
                l=(val1-a*10000)/1000;                           /*除以1000*/
                m=(val1-a*10000-l*1000)/100;                     /*减t1x1000再除以100*/
                n=(val1-a*10000-l*1000-m*100)/10;                /*减t1x1000再减t2X100*/
                s=val1-a*10000-l*1000-m*100-n*10;                /*分离千 百 十 个三位*/
               }   
/***************实际重量处理****************************/
              void   dispose2()
               {      
                t0=WeiDATA/10000;
                t1=WeiDATA%10000/1000 ;
                t2=WeiDATA%1000/100 ;
                t3=WeiDATA%100/10;
                t4=WeiDATA%10;
                }
/***************实际重量处理****************************/
              void   dispose3()
               {      
                ta=val2/10000;
                tb=val2%10000/1000 ;
                tc=val2%1000/100 ;
                td=val2%100/10;
                te=val2%10;
                }
/************************产量处理**********************/       
                void  addtotal()
                {
                 if(val3>9999){val3=0;}                 /*大于9999归零*/
                 t01=val3/1000;                          /*除以1000*/
                 t02=(val3-t01*1000)/100;                 /*减t1x1000再除以100*/
                 t03=(val3-t01*1000-100*t02)/10;           /*减t1x1000再减t2X100*/
                 t04=val3-t01*1000-100*t02-10*t03;          /*分离千 百 十 个三位*/
                 }           
/*--------------显示万位--------------------------*/
              void   TenThousands() 
                {  
                 write_com(0x83);                                /*地址*/
                 write_data(0xA3);                               /*半个字符*/
                 write_data(disdt[a]);                           /*万位*/  
                } 
/*--------------显示千位---------------------------*/
             void   Thousands() 
                {  
                 write_com(0x84);                                 /*地址*/
                 write_data(0xA3);                                /*半个字符*/
                 write_data(disdt[l]);                           /*千位*/  
                } 
/*--------------显示百位---------------------------*/
             void   hundreds()
                {  
                 write_com(0x85);                                 /*地址*/
                 write_data(0xA3);                                /*半个字符*/
                 write_data(disdt[m]);                           /*百位*/ 
                } 
/*--------------显示十位---------------------------*/                
             void   decade()
               {
                write_com(0x86);                                 /*地址*/
                write_data(0xA3);                                /*半个字符*/
                write_data(disdt[n]);                           /*十位*/
               }
/*--------------显示个位---------------------------*/
           void    single()
                {  
                 write_com(0x87);                                 /*地址*/
                 write_data(0xA3);                                /*半个字符*/
                 write_data(disdt[s]);                           /*个位*/ 
                } 
/*---------------显示位选光标-------------------*/
              void displaybit()
                {     
                 switch(TBIT)
                 {
                   case 1:                                          /*光标个位显示*/
                  {
                   single();                                       /*个位数据显示*/
                   //decade();                                       /*十位数据显示光标自动后移一位*/
                   break;                                           /*子程序返回*/
                  }
                  case 2:                                          /*光标十位显示*/
                  {
                   decade();                                       /*十位数据显示*/
                   //hundreds();                                       /*百位数据显示光标自动后移一位*/
                   break; /*子程序返回*/
                  }
                  case 3:                                          /*光标百位显示*/
                  {
                   hundreds();                                       /*百位数据显示*/
                   //Thousands();                                       /*千位数据显示光标自动后移一位*/
                   break; /*子程序返回*/
                  }
                  case 4:                                          /*光标千位显示*/
                  {
                   Thousands();                                       /*千位数据显示*/
                   //TenThousands();                                 /*万位数据显示光标自动后移一位*/
                   break; /*子程序返回*/
                  }
                  case 5:                                          /*光标千位显示*/
                   {
                   TenThousands();                                   /*万位数据显示*/
                   //write_com(0x82); 
                   //write_data(0xA3);
                   //write_data(0xBA);                               /*---:显示光标自动后移一位----*/ 
                   break;                                           /*子程序返回*/
                   }
                  }
                }  
/*----------设定重量按位加-------------------------*/
               void   setda1on()                                  /*写数据B子函数*/
                  {                                                /*子函数开始*/
                   dispose1();                                       /*设定重量处理分离各位*/                         
                   switch (TBIT)
                   {
                    case 1:                                        /*光标个位显示*/
                     {
                      s++;
                      if(s>=10)
                      {s=0;}
                      single();
                      //decade();
                      break;
                     }
                    case 2:                              /*光标十位显示*/
                     {
                      n++;
                      if(n>=10)
                         {n=0;}
                      decade();
                      //hundreds();
                      break;
                     }
                    case 3:                              /*光标百位显示*/
                     {
                      m++;
                        if(m>=10)
                      {m=0;}
                      hundreds();
                      //Thousands();
                      break;
                      }
                    case 4:                              /*光标千位显示*/
                     { 
                      l++;
                      if(l>=10)
                      {l=0;}
                      Thousands();
                      //TenThousands();
                      break;
                     }
                    case 5:                                 /*光标千位显示*/
                     { 
                      a++;
                      if(a>=4)
                      {a=0;}
                        TenThousands();                         /*万位显示*/
                     
                      break;
                     }
                    }
                    val1=a*10000+l*1000+m*100+n*10+s;
                    writea();                              /*百 十 个三位写入EEPROM*/
                   }    
/*******************************************/
              void main()
              {
               lcdreset();
               Delay_ms(1000);                           //延时1s,等待传感器稳定
               displaywriting();                     //显示文字
               Get_Maopi();                             //称毛皮重量
               TBIT=0;
               Get_Weight();                         //称重
               dispose2();                           //数据处理取实际重量个十百千万位值
               displayb();                           //显示实际重量数据
               red24 ();                             //读EEPROM数据 取设定值数据
               dispose1();                           //数据处理取设定重量个十百千万位值
               displaya();                           //显示设定重量数据
               val3=0;
               k=0;w=0;                                 //延时计时标记归零
               addtotal();                  /*处理产量统计 分离个十百千位*/
               displayd();
                while(1)
                {         
                   if(!SETWEIGHT)                      /*设置重量按键*/
                   {                                 /*循环*/
                    for(;k<=25;)                     /*小于等于25循环*/
                    {
                     if(!SETWEIGHT)                  /*检测重量按键为低电平？*/
                     {  
                      k++;
                     }
                   else if(~!SETWEIGHT)                  /*检测重量按键为低电平？*/
                    {  
                     k=0;break; 
                    }
                    k=0;
                    dispose1();                           //数据处理取设定重量个十百千万位值
                    displaya();                           //显示设定重量数据
                    ww=10;
                    do
                     {
                    if(!WEIGHTSET)                     
                      {//3                                
                       for(;w<=25;)                    
                       {      //2
                       if(!WEIGHTSET)                 
                         {     //1                              
                          OUT3=0;
                          w++;
                          delay(10); 
                          }     //1
                        else if(~WEIGHTSET)        
                         w=0;break;                                   
                        }       //2                             
                       w=0;OUT3=1;                       
                       _nop_();_nop_();               
                       setda1on();                     
                       delay(600); 
                      }//3                            // 重量设置结束                           
                       else if(!WEIGHTBIT)                /**重量位选按键**/
                       {         //3                              
                        for(;w<=25;)                    
                         {       //2
                          if(!WEIGHTBIT)                
                          {     //1                                             
                          OUT3=0;
                          w++;
                          delay(10); 
                          }     //1
                           else if(~WEIGHTBIT)            
                           w=0;break;                                   
                          }       //2   
                        w=0;OUT3=1;                    
                        TBIT++;                        
                        if(TBIT>=6)    
                        {TBIT=0;}             
                        displaybit();                 
                        delay(2500);
                       }       //3  
                        else if(!BACK)              /**重量位选按键**/
                        {                                  
                         ww=0;
                         }    
                       }  
                      while(ww>5);
                     }

                    }
                    if(!Filling)                    /*检测灌装开关为低电平?**/
                      {                              /*自动开始*/
                       for(;k<=10;)                  /*寄存器复位*/
                       {
                         if(!Filling)                /*检测灌装开关为低电平？*/
                         {                           /*自动运行*/
                          k++;
                          delay(10); 
                          }
                         else if(~!Filling)          /*检测灌装开关为高电平？*/
                         k=0;break;                  /*寄存器复位返回循环*/                                
                        }
                        val2=0;
                        dispose3();                  //数据处理取实际重量个十百千万位值
                        displayc();                  //显示实际重量数据
                        k=0;                         /*寄存器复位*/
                        disfilling();
                        OUT1=0; OUT2=0;              /*灌装输出*/
                        while(WeiDATA<val1)    
                        {
                        Get_Weight();                 //称重
                        dispose2();                  //数据处理取实际重量个十百千万位值
                        displayb();                  //显示实际重量数据
                        }
                        val2=val1;
                        OUT1=1;OUT2=1;                 /*灌装关*/
                        clrfilling();  
                        dispose3();                  //数据处理取实际重量个十百千万位值
                        displayc();                  //显示实际重量数据
                        val3++;
                        addtotal();                  /*处理产量统计 分离个十百千位*/
                        displayd();                  //显示产量
                       }
                      if(!TOTALCLR)                      /*设置重量按键*/
                       {                                 /*循环*/
                        for(;k<=25;)                     /*小于等于25循环*/
                        {
                         if(!TOTALCLR)                  /*检测重量按键为低电平？*/
                         {                              /*循环检测 */
                          val3=0;
                          addtotal();                  /*处理产量统计 分离个十百千位*/
                          displayd();                  //显示产量
                          }
                         else if(~TOTALCLR)             /*检测重量按键为高电平？*/
                          k=0;break;                    /*寄存器复位*/                 
                         }                              /*循环*/
                        } 
                      k=0;                                    /*结束*/    
                      Get_Weight();                         //称重
                      dispose2();                        //数据处理取实际重量个十百千万位值
                      displayb();                        //显示实际重量数据
                      OUT3=0; 
                      Delay_ms(200);                       //延时
                      OUT3=1; 
                      Delay_ms(200);                       //延时
                     } 
                   }
 

czhaii
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HX711 称重传感器 C程序
10-09
HX711 称重传感器 C程序 电路 基于51单片机的
树莓派集成Hx711称重传感器demo
weixin_43242242的博客
12-01 7600
我是代码小白，一个正在做毕设的秃头少年。鄙人拙作,有不当之处,还请指教。 今天，我怀着无比悲痛的心情写下这边博文。为什么呢，因为就在刚刚，我的一个树莓派3B+烧了，因为接线短路。 大家接线的时候一定要注意看引脚图，不要胡乱接。 好，废话不多说进入正题。最近入手了一个HX711称重传感器，在arduino上还挺容易实现的，因为都是现成的库直接调用就行了，那么在树莓派中怎么使用呢。经过我不断百度，找...
HX711传感器调试好的代码
m0_68142760的博客
03-15 6605
HX711传感器调试好的代码 180kg量程 基于STM32f103rct6/c8t6开发的程序 可以用作项目开发 也可以拿来学习用 （精度小数点两位数） 编号:134629532677340c编程鬼
hx711c语言程序,51单片机HX711传感器电子秤设计（原理图、程序源码、BOM等）
weixin_33193480的博客
05-21 3370
#include //调用单片机头文件#define uchar unsigned char//无符号字符型 宏定义 变量范围0~255#define uintunsigned int //无符号整型 宏定义 变量范围0~65535#define ulong unsigned long#includeuchar ...
hx711c语言滤波函数,模数转换芯片hx711 c驱动程序
weixin_39912566的博客
05-22 1078
电子天平专用高精度的模数转换芯片 HX711 的c语言驱动程序,讲解详细,一看就会。bugAD_F(void){u8 str[26];int i=0,j=0,k=0;delay_init(72);UsartConf(9600);ADInit();BUFInit();//往队列数组BUF里面存入N个采样值，初始化SUM为N个采样值的和。while(1){IntToStr(filter(),str);...
【0029】自动灌装机.zip西门子PLC编程实例程序源码下载
04-19
【0029】自动灌装机.zip西门子PLC编程实例程序源码下载【0029】自动灌装机.zip西门子PLC编程实例程序源码下载【0029】自动灌装机.zip西门子PLC编程实例程序源码下载【0029】自动灌装机.zip西门子PLC编程实例程序源码...
PLC程序 自动灌装机.rar
05-24
PLC程序 自动灌装机.rar
基于PLC的自动饮料灌装机.doc
03-26
基于PLC的自动饮料灌装机
全自动液体灌装机控制系统的设计与研究.pdf
03-21
全自动液体灌装机控制系统的设计与研究.pdf
自动化控制在黄酒灌装生产中应用.docx
12-15
自动化控制在黄酒灌装生产中应用.docx
基于c语言的单片机电子秤程序 毕业设计
05-18
单片机的电子秤程序 基于c语言的写法 毕业设计用的
多功能电子秤设计的程序
11-29
1、系统具有称重、去皮、计价、重量累加、金额累计、单价存储、自动回零、显示、较零、超重报警等功能； 2、可以与上位机进行串行通信； 3、具有量程自动转换功能； 4、以单片机为控制、运算核心。
HX711电子称程序
06-11
HX711电子称程序的STM8驱动程序代码
电子称C语言代码
12-01
电子称C语言代码 电子称C语言代码 #include "stm32f10x.h" #include "LCD1602.h" /* * 函数名：main * 描述 ：主函数 * 输入 ：无 * 输出 ：无 */ int main(void) { SystemInit(); GPIO_Config(); LCD_init(); while(1) { LCD_displaynum(0,1,10); LCD_displaynum(8,1,10); LCD_displaynum(0,2,10); } } /******************* (C) COPYRIGHT 2012 WildFire Team *****END OF FILE************/
基于51单片机智能电子秤方案原理图程序设计
jianghuxiaoge的博客
07-17 7710
硬件设计 单片机最小系统 对51系列单片机来说，最小系统一般应该包括:单片机、晶振电路、复位电路。下面给出一个51单片机的最小系统电路图。 复位电路： 一、复位电路的用途：单片机复位电路就好比电脑的重启部分，当电脑在使用中出现死机，按下重启按钮电脑内部的程序从头开始执行。单片机也一样，当单片机系统在运行中，受到环境干扰出现程序跑飞的时候，按下复位按钮内部的程序自动从头开始执行。单片机复位电路如下图： 二、复位电路的工作原理在书本上有介绍，51单片机要复位只需要在第9引脚接个高电平持续2US
蓝桥杯------自动售水机
m0_56279210的博客
01-19 1112
单片机蓝桥杯
基于STM32的智能电子秤原理图PCB程序设计
weixin_44116175的博客
05-17 6922
硬件设计 （末尾附文件） 本次设计以STM32单片机为核心，利用压力传感器监测货物的压力并转换成电流输出给AD芯片，HX711转换模块将模拟量转换成数字量并输出给单片机，STM32单片机通过公式计算出具体的货物重量，采用按键矩阵对结果进行加减乘除，得出总价或者其他的结果。LCD1602液晶屏上显示检测到的货物重量、单价和总价。 设计思路 以STM32为中央处理器，通过压力传感器监测货物对其造成的压力，并以电流变化输出给HX711AD模块，hx711AD芯片将模拟量转换成数字量并发送给单片机，经单片机计算后，
电子秤c语言编程,STC89C51单片机+HX711称重模块电子秤程序
weixin_35080040的博客
05-18 4630
#include "main.h"#include "HX711.h"#include "eeprom52.h"#define uchar unsigned char#define uint unsigned intunsigned long HX711_Buffer = 0;unsigned long Weight_Maopi = 0;unsigned long Weight_Maopi_0 ...
国信长天单片机竞赛训练之超声波实验（四）
昊月光华的博客
12-01 1097
本次是第四次作业了，作业要求如下： 1.结合定时器知识，使用定时器1作为中断源，使用定时器0做计数器进行超声波测距，并在数码管上显示； 2.以第一种方式进行测距。当测试距离大于10cm，小于等于20cm时，蜂鸣器打开，继电器打开。大于20cm，小于40cm时，继电器打开，蜂鸣器关闭，当距离大于等于40cm时，继电器关闭； 超声波的电气参数如下： 本次作业用的是stc15f2k60s2.h，程序运行的频率设置为11.0592MHZ,实际上与12Mhz差别并不大（以我目前的水平感觉上可以兼...
s4-700自动灌装程序
最新发布
07-04
S4-700自动灌装程序是一种高效、自动化的灌装装置。该程序通过计算机控制系统实现自动化操作，可广泛应用于食品、饮料、化妆品等行业的生产线。 首先，S4-700自动灌装程序可以根据设定的参数进行精确的计量和灌装。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值