STC液压伺服控制系统

最新推荐文章于 2024-04-03 16:23:41 发布
最新推荐文章于 2024-04-03 16:23:41 发布
阅读量313 收藏 4
点赞数
分类专栏： C语言 文章标签： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czhaii/article/details/114306347
版权

/***********立式波纹管手动PAST     **********/    
/***********L604 CODE 3202 2021 3 3**********/    
/***半自动打一个波,全自动打一节,再按键循环***/
              #include     <REG52.H>              //开机第一个参数设置翻页需改进
              #include     <intrins.h>            //保压时间
              #include     <string.h>
              #include     "stdio.h"
              #include     <stdlib.h>
              #define      uint unsigned int
              #define      uchar unsigned char
              sbit         Led=P5^4;             //EEPROM写指示
              sbit         Auto_Led=P5^5;         //自动运行指示
              sbit         CP1=P3^7;             //
              sbit         DIR1=P3^6;            //
              sbit         CP2=P3^5;             //
              sbit         DIR2=P3^4;            //  
              sbit         YL=P1^1;              /****压力输出信号****/
              sbit         GZ=P1^0;                 /****鼓涨输出信号****/
              sbit         GS=P1^6;                 /****鼓松输出信号****/
              sbit           S1=P3^2;                 /***步进电机限位*2016 5 14 5.5改1.7****/
              sbit           INTPUT1=P3^3;         //
              uint         FLAG_S;                 //运行标志
              uchar        i,k;                  //循环总变量i
              #define      CMD_IDLE    0         //空闲模式
              #define      CMD_READ    1         //IAP字节读命令
              #define      CMD_PROGRAM 2         //IAP字节编程命令
              #define      CMD_ERASE   3         //IAP扇区擦除命令
              #define      ENABLE_IAP  0x82      //if SYSCLK<20MHz
              #define      IAP_ADDRESS 0x0000    //时间 EEPROM首地址
              bit            manu;                 /****手动标志位 0 1****/
              bit           semiauto;             /*半自动运行标志*/
              bit           MOTORRUN=0;             //电机运行标志
              typedef      unsigned char BYTE;
              typedef      unsigned int WORD;
              uint         ScaleFactor;
              uint         val0,val1,val2,val3,val4;      /*0产量计数器1设定波值2鼓涨时间3鼓松时间4电机速度*/
              uint         vala,valb,val5,val6,val7;      /*5电机计数6实际波值7运行时间缓冲     */
              uint         val8;                 //顶出距离
              int           func;           /*功能标志0:break 1:波值 2:鼓涨时间3:鼓松时间4:电机速度5:电机计数6:归零*/
              bit           Receive_Flag;
              uint         Run_Flag;                 //手动    半自动 自动    运行标志
              bit            Signauto;                 /*检测接近开关自动运行标志*/
              uchar        kcounter,kstatus;     //按键计数标志 按键状态标志
              uint         a[10];             //定义数组a 存储串口数据串
/*------------------------------------------*/
              void delay(uint t)
              {
              uint i,j;
              for(i=0;i<t;i++)
              for(j=0;j<100;j++);
              }
/*------------------延时子程序------------------------*/
               void delay10ms(uint x)
               {
               int i, j;
               for (i=0; i<x; i++)
               for (j=0; j<10; j++);
               }
/*-----------(1)延时子程序12MHz 加千百十个显示--------*/
               void Delay_100ms(uint x)          //page 5 保压，上升计时  Delay100ms
               {
               uint i,j;
                for(i=0;i<x;i++)
                {
                for(j=0;j<9200;j++);
                }
               }    
/*----关闭IAP----------------------------*/
              void IapIdle()
              {
              IAP_CONTR = 0;                  //关闭IAP功能
              IAP_CMD = 0;                    //清除命令寄存器
              IAP_TRIG = 0;                   //清除触发寄存器
              IAP_ADDRH = 0x80;               //将地址设置到非IAP区域
              IAP_ADDRL = 0;
              }
/*-从ISP/IAP/EEPROM区域读取一字节-*/
              BYTE IapReadByte(WORD addr)
              {
              BYTE dat;                       //数据缓冲区
              IAP_CONTR = ENABLE_IAP;         //使能IAP
              IAP_CMD = CMD_READ;             //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              dat = IAP_DATA;                 //读ISP/IAP/EEPROM数据
              IapIdle();                      //关闭IAP功能
              return dat;                     //返回
              }
/*-写一字节数据到ISP/IAP/EEPROM区域-*/
              void IapProgramByte(WORD addr, BYTE dat)
              {
              IAP_CONTR = ENABLE_IAP;         //使能IAP
              IAP_CMD = CMD_PROGRAM;          //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_DATA = dat;                 //写ISP/IAP/EEPROM数据
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              IapIdle();
              }
/*---扇区擦除---------------*/
              void IapEraseSector(WORD addr)
              {
              IAP_CONTR = ENABLE_IAP;         //使能IAP val=IapReadByte(IAP_ADDRESS+1);
              IAP_CMD = CMD_ERASE;            //设置IAP命令
              IAP_ADDRL = addr;               //设置IAP低地址
              IAP_ADDRH = addr >> 8;          //设置IAP高地址
              IAP_TRIG = 0x5a;                //写触发命令(0x5a)
              IAP_TRIG = 0xa5;                //写触发命令(0xa5)
              _nop_();                        //等待ISP/IAP/EEPROM操作完成
              IapIdle();
              }
/***********************************/
              void red_eeprom(void)
              {
              uint m,n;        
              m=IapReadByte(IAP_ADDRESS+0);  //设定波值前八位
              n=IapReadByte(IAP_ADDRESS+1);  //设定波值后八位
              val1=m*256+n;                     //设定波值
              m=IapReadByte(IAP_ADDRESS+2);  //电机速度前八位
              n=IapReadByte(IAP_ADDRESS+3);  //电机速度后八位
              val4=m*256+n;                     //电机速度
              m=IapReadByte(IAP_ADDRESS+4);  //比例系数前八位
              n=IapReadByte(IAP_ADDRESS+5);  //比例系数后八位
              ScaleFactor=m*256+n;             //比例系数
              m=IapReadByte(IAP_ADDRESS+6);  //鼓涨时间前八位
              n=IapReadByte(IAP_ADDRESS+7);  //鼓涨时间后八位
              val2=m*256+n;                     //鼓涨时间
              m=IapReadByte(IAP_ADDRESS+8);  //鼓松时间前八位
              n=IapReadByte(IAP_ADDRESS+9);  //鼓松时间后八位
              val3=m*256+n;                     //鼓松时间
              m=IapReadByte(IAP_ADDRESS+10); //顶出距离前八位
              n=IapReadByte(IAP_ADDRESS+11); //顶出距离后八位
              val8=m*256+n;                     //顶出距离
              Led=1;
              }
/*************写时间参数到EEPROM*******************************/
               void Write_EepromTime()
              {
               IapEraseSector(IAP_ADDRESS); //扇区擦除
               IapProgramByte(IAP_ADDRESS+0,val1/256);       /*设定波值高八位*/    
               IapProgramByte(IAP_ADDRESS+1,val1%256);       /*设定波值低八位*/

               IapProgramByte(IAP_ADDRESS+2,val4/256);       /*电机速度高八位*/  
               IapProgramByte(IAP_ADDRESS+3,val4%256);       /*电机速度低八位*/

               IapProgramByte(IAP_ADDRESS+4,ScaleFactor/256);/*比例系数高八位*/
               IapProgramByte(IAP_ADDRESS+5,ScaleFactor%256);/*比例系数低八位*/

               IapProgramByte(IAP_ADDRESS+6,val2/256);       /*鼓涨时间高八位*/    
               IapProgramByte(IAP_ADDRESS+7,val2%256);       /*鼓涨时间低八位*/

               IapProgramByte(IAP_ADDRESS+8,val3/256);       /*鼓松时间高八位*/  
               IapProgramByte(IAP_ADDRESS+9,val3%256);       /*鼓松时间低八位*/

               IapProgramByte(IAP_ADDRESS+10,val3/256);      /*顶出距离高八位*/  
               IapProgramByte(IAP_ADDRESS+11,val3%256);      /*顶出距离低八位*/

               Led=1;
               }
/*************关所有输出*******************************/             
               void reset_io()
               {
               P3M0=0X00;
               P3M1=0X00;
               P5M0=0X00;
               P5M1=0X00;
               CP1=1;                 //
               DIR1=1;                //
               CP2=1;                 //
               DIR2=1;                //  
               YL=1;                  /****压力输出信号****/
               GZ=1;                  /****鼓涨输出信号****/
               GS=1;                  /****鼓松输出信号****/
               S1=1;                  /***伺服电机限位*2016 5 14 5.5改1.7****/
               INTPUT1=1;                         //
               }
/****************按键计数器状态寄存器归零*************/
               void RstKey()
               {
               kcounter=0;                       //按键计数器归零
               kstatus=0;                        //状态寄存器归零
               }
/*****************按键低电平检测函数*****************/
               void   LowVoltKey(void)           //按键计数器状态标志加一
               {
               kcounter++;                       
               kstatus++;     
               delay(5);                         //延时                  
               }
/*****************按键高电平检测函数*****************/
               void    HighVoltKey(void)         //按键计数器加一 状态标志归零
               {
               kcounter++;                       //按键计数器加一
               kstatus=0;                        //按键状态标志归零
               delay(5);                         //延时
               }
/*------------page 0页面显示---------------------*/
               void disdata_a()//
               {
                red_eeprom();
                printf("n0.val=%d\xff\xff\xff",val1);    //设定波值
                printf("n0.val=%d\xff\xff\xff",val1);    //设定波值
               }
/*------------page 1页面显示---------------------*/
               void disdata_b()//                            
               {
                red_eeprom();
                printf("n0.val=%d\xff\xff\xff",ScaleFactor);    //比例系数
                printf("n0.val=%d\xff\xff\xff",ScaleFactor);    //比例系数
                printf("n1.val=%d\xff\xff\xff",val2);            //鼓涨时间
                printf("n2.val=%d\xff\xff\xff",val3);            //鼓松时间     val8
                printf("n3.val=%d\xff\xff\xff",val8);            //顶出距离
                printf("n4.val=%d\xff\xff\xff",val4);    //电机速度
               }
/*----------电机前进------------*/
               void   MotorForward( )            /**/
               {  
                for(val7>0;val7--;)
                {
                 for(k=0;k<20;k++)                //
                 {
                 CP1=0;                      /*子函数开始*/
                   delay10ms(val4);
                 CP1=1;
                  delay10ms(val4);
                 }
                }
               }      
/*************手动电机上升****/
              void Motor_Up()                    //
              {
               DIR1=1;
               MOTORRUN=1;
               while(MOTORRUN)
               {
               CP1=0;
               delay(val4);
               CP1=1;
               delay(val4);
               }
              }
/*************手动电机下降****/
              void Motor_Dwon()                    //
              {
               DIR1=0;
               MOTORRUN=1;
               while(MOTORRUN)
               {
               CP1=0;
               delay(val4);
               CP1=1;
               delay(val4);
               RstKey();
                for(;kcounter<5;)                //按键循环5次
                {
                 if(!INTPUT1)                    //按键低电平
                 {
                 LowVoltKey();                   //按键低电平 计数器加一状态标志加一
                 }
                 else if(~!INTPUT1)              //按键高电平
                 {
                 HighVoltKey();                  //按键计数器加一    状态标志归零
                 }
                }
                if(kstatus>=3)                   /*按键状态标志大于等于3为有效值*/
                {  
                MOTORRUN=0;                         //电机下限位电机运行标志关
                }
               }
               DIR1=1;                             //
              }
/*----------手动电机下降------------*/
               void   MotorBack( )          /**/
               {                                 /*子函数开始*/
                   CP1=0;
                delay10ms(val4);
                CP1=1;
                delay10ms(val4);
               }
/*----------鼓涨输出------------*/
               void   OUTA( )     //鼓涨     
               {                            
                   GZ=0;
                YL=0;
               }
/*----------鼓松输出------------*/
               void   OUTB( )     //鼓松    
               {                            
                   GS=0;
                YL=0;
               }
/*----------鼓涨关闭------------*/
               void   GOUTA( )    //鼓涨关     
               {                            
                   GZ=1;
                YL=1;
               }
/*----------鼓松关闭------------*/
               void  GOUTB( )      // 鼓松关   
               {                            
                   GS=1;
                YL=1;
               }
/*----------实际波值加-----------------*/
               void   workwaveon( )              /*实际波值加子函数*/
               {                                 /*子函数开始*/
                val6=val6+1;                     /**加一**/
                if(val6>999)                     /*大于999*/
                {
                val6=0;                             /*归零*/
                }                                   //     val0
               }
/*----------产量加一-----------------*/                                                    
               void  totaladd( )
               {
                val0=val0+1;
                if(val0>9999)                     /*大于999*/
                {
                val0=0;                             /*归零*/
                }  
               }
/*----------------自动运行程序----------------*/
                void autorun()
                {
                 printf("n2.val=%d\xff\xff\xff",val0); //显示产量
                 printf("n0.val=%d\xff\xff\xff",val1); //显示设定波值
                 while(manu)                /*循环条件为manu=1 按手动时manu=0*/
                 {                        
                  OUTA();                    //鼓涨输出
                  printf("t5.txt=\"鼓涨\"\XFF\XFF\XFF");                //显示鼓涨
                  val7=val2;                //鼓涨时间交缓冲器
                 // xsdjs();                //倒计时显示
                  GOUTA();                    //关
                  OUTB();                    //鼓松输出
                  printf("t5.txt=\"鼓松\"\XFF\XFF\XFF");                //显示鼓松
                  val7=val3;                //鼓松时间交缓冲器
                 // xsdjs();                    //倒计时显示
                  GOUTB();                    //关鼓松
                  printf("t5.txt=\"顶出\"\XFF\XFF\XFF");                //显示顶出
                  val7=val5;                //顶出计数交缓冲器
                  MotorForward();            //顶出
                  if(semiauto)              //判断自动半自动标志
                  {
                  workwaveon( );            //实际值加一
                  printf("n1.val=%d\xff\xff\xff",val6); //显示实际值
                  if(val6>=val1)            //如果实际值大于等于设定值
                  {
                   manu=0;                    //运行标志关
                   printf("t5.txt=\"顶退\"\XFF\XFF\XFF");                //显示顶退
                   DIR1=0;                //步进电机方向使能开
                   delay(1000);                //
                   Signauto=1;                /*行程输入信号检测标志无输入为1,永久循环*/
                   k=0;                        /*抗干扰计数器*/
                  do
                  {
                   if(~!S1)                    /*顶退行程开关高电平*/
                   for(;k<=3;)              /*小于等于3循环*/
                   {
                    if(!S1)                 /*检测顶退为低电平？*/
                    {                       /*循环检测 */
                     _nop_();
                     _nop_();
                     k++;
                    }
                    else if(~!S1)           /*检测顶退为高电平？*/
                    {
                    MotorBack( );            //顶退 检测限位开关
                    k=0;                    /*寄存器复位*/  
                    }               
                   }
                   Signauto=0;              /*行程输入信号连续检测到3次Signauto=0退出循环*/   
                   totaladd();                 //产量加一
                   printf("n2.val=%d\xff\xff\xff",val0); //显示产量
                   }
                   while(Signauto);            //while 结束
                   printf("t4.txt=\"手动\"\XFF\XFF\XFF");                //显示手动
                   val6=0;                    //实际波值归零
                   printf("n1.val=%d\xff\xff\xff",val6); //显示实际值
                  }
                  DIR1=1;                    //步进电机方向使能复位
                  }
                  else    if(!semiauto)
                  {
                  manu=0;                    //运行标志manu 置0
                  }
                  }
                  Auto_Led=1;                     //
                 }
/*----------------半自动运行程序----------------*/
                 void Run()
                 {
                  OUTA();                    //鼓涨输出
                  printf("t5.txt=\"鼓 涨\"\XFF\XFF\XFF");                //显示鼓涨
                  Delay_100ms(val2);        //
                  GOUTA();                    //关
                  OUTB();                    //鼓松输出
                  printf("t5.txt=\"鼓 松\"\XFF\XFF\XFF");                //显示鼓松
                  Delay_100ms(val3);        //
                  GOUTB();                    //关鼓松
                  printf("t5.txt=\"顶 出\"\XFF\XFF\XFF");                //显示顶出
                  val7=val8;
                  MotorForward();            //顶出
                  delay(200);
                  printf("t5.txt=\"待 机\"\XFF\XFF\XFF");                //显示顶出
                 }
/*------------初始化串口---------------------*/
              void InitUart()
              {
              SCON=0X50;                  
      //8位数据，可变波特率
              AUXR|=0x01;                        //串口1选择定时器2为波特率发生器
              AUXR|=0X04;                        //定时器2时钟为Fosc，即1T
              T2L=0XE0;                          //设置定时器处置  110592》9600
              T2H=0XFE;                          //设置定时器处置  110592》9600
              AUXR|=0X10;                        //启动定时器2
              TI=1;                                 //
              ES=1;                                 //
              EA=1;                                 //
              }
/*×--------UART 中断服务程序-------------------**/
/**×**把接收到的数据存进数组a[i]**i开机初始化****/
/***×*接收到触摸屏结束码Receive_Flag标志位置1****/
/****×主程序检测到标志码=1判断指令功能***********/
              void Uart() interrupt 4 using 1
              {
               if(RI)
               {
                if(SBUF==0XFA||SBUF==0XFF)         //触摸屏结束码
                {
                Receive_Flag=1;                     //接收数据标志置一
                RI=0;                             //
                i=0;                             //数组计数器归零
                }
                else
                {
                a[i]=SBUF;                       //数组下标位置的数据等于SBUF
                RI=0;                             //
                i++;
                }
               }
               if(Receive_Flag==1)                 //关手动伺服电机工作
                {
                 if(a[0]==0XA0)                     //
                 {
                  if(a[1]==0X00)                 //
                   {
                  Receive_Flag=0;                 //串口中断接收标志置零
                  i=0;                             //数组计数器归零
                  MOTORRUN=0;                     //关伺服电机
                  }
                 }
                }
              }
/*************************************************/
              void   main( )                      /*主程序开始*/
              {
               reset_io();
               Led=0;
               Delay_100ms(300);                 //延时(30)等触摸屏先启动
               AUXR=0X80;                        //STC系列的1T 设置
               TMOD=0X01;
               P_SW1=0x00;                       //RXD/P3.0, TXD/P3.1
               Receive_Flag=0;    
               InitUart();                       //初始化串口
               printf("0XFF,0XFF,0XFF");
               red_eeprom();
               disdata_a();
               Run_Flag=0;
               FLAG_S=6;                         //1下降 2上升 3停止 4结束5保压6待机7周期一8周期二9周期三
               printf("va0.val=%d\xff\xff\xff",FLAG_S);    //
               i=0;                              //数据接收计数器等于0
               while(1)            //INTPUT1
               {
               if(Receive_Flag==1)
               {
                Receive_Flag=0;                     //重新接收
/*************周期一*********/
                 if(a[0]==0XE0)            
                 {
                  if(a[1]==0XA1)                 //给单片机发顶 进信号
                  {
                   MOTORRUN=1;                     //电机运行标志
                   Motor_Up();                      //顶 进
                  }
                  else  if(a[1]==0XA2)             //给单片机发顶 退信号
                  {
                   MOTORRUN=1;                     //电机运行标志
                   Motor_Dwon();
                  }
                   else  if(a[1]==0XA3)             //给单片机发鼓 涨信号
                  {
                   OUTA();                       //鼓涨
                  }
                   else  if(a[1]==0XA4)             //给单片机发鼓 松信号
                  {
                   OUTB();                       //鼓松  
                  }
                  else  if(a[1]==0XA5)             //关鼓涨鼓松输出
                  {
                   GS=1;
                   GZ=1;
                   YL=1;
                  }
                 }
                 else  if(a[0]==0XE1)             //出厂数据恢复
                 {
                  if(a[1]==0XA1)                 //
                  {
                   disdata_a();                     //page0
                  }
                  else  if(a[1]==0XA2)             //
                  {
                   disdata_b();                     //page1
                  }
                  if(a[1]==0XE1)                 //数据全部删除
                  {
                  Led=0;
                  val1=10;                       //设定波值
                  val2=12;                       //鼓涨时间
                  val3=12;                         //鼓松时间
                  val4=2;                        //电机速度
                  val8=20;                       //顶出距离
                  ScaleFactor=6;                 //比例系数
                  Write_EepromTime();
                  disdata_b();                     //
                  }
                 }
                 else  if(a[0]==0XC0)             //出厂数据恢复
                 {
                  if(a[1]==0X01)                 //数据全部删除
                  {
                  val1=a[3]*256+a[2];             //设定波值
                  }
                  else  if(a[1]==0X02)             //数据全部删除
                  {
                  val4=a[3]*256+a[2];             //电机速度
                  }
                  else  if(a[1]==0X03)             //数据全部删除
                  {
                  ScaleFactor=a[3]*256+a[2];     //比例系数
                  }
                  else  if(a[1]==0X04)             //数据全部删除
                  {
                  val2=a[3]*256+a[2];             //鼓涨时间
                  }
                  else  if(a[1]==0X05)             //数据全部删除
                  {
                  val3=a[3]*256+a[2];             //鼓松时间
                  }
                  else  if(a[1]==0X06)             //数据全部删除
                  {
                  val8=a[3]*256+a[2];             //顶出距离
                  }
                  Write_EepromTime();
                 }
                 else  if(a[0]==0XB0)             //手动半自动全自动
                 {
                  if(a[1]==0XA1)                 //手动
                  {
                  Auto_Led=1;                     //
                  Run_Flag=0;                     //手动    
                  }
                  else  if(a[1]==0XA2)             //半自动
                  {
                  Auto_Led=1;                     //
                  Run_Flag=1;                     //半自动
                  Run();
                  }
                  else  if(a[1]==0XA3)             //自动
                  {
                  Run_Flag=2;                     //自动    
                  Auto_Led=0;                     //
                  }
                 }
/****************/
                  
///
               RstKey();
               if(Run_Flag==2)                     //自动运行标志为2
               {
                for(;kcounter<5;)                //按键循环5次
                {
                 if(!INTPUT1)                    //按键低电平
                 {
                 LowVoltKey();                   //按键低电平 计数器加一状态标志加一
                 }
                 else if(~!INTPUT1)              //按键高电平
                 {
                 HighVoltKey();                  //按键计数器加一    状态标志归零
                 }
                }
                if(kstatus>=3)                   /*按键状态标志大于等于3为有效值*/
                {  
                autorun();
                }
               }
              }
             }     
            }                    //L604 CODE 3202 2021 3 3

czhaii
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
电液伺服系统_液压伺服系统（工作原理）
weixin_39978276的博客
11-17 2125
原创首发路过的看官：本店专业承接非标定制系统，非标定制油路块,具有20年线下定制设计经验，欢迎咨询！点击最下方【了解更多 】 即可找到本店【大大液压】-----------------------------------------------------------------------------------------------液压伺服控制系统的工作原理 在伺服系统中，输出量(位移、速度...
液压伺服控制（完美版）
06-30
液压控制 液压控制系统 液压伺服控制 液压伺服系统
液压伺服控制系统设计
czhaii的专栏
04-30 1257
13775061792
液压伺服控制系统(新版课件)
06-23
液压伺服控制系统，新版课件，清华大学出版社，2014年版 ，常同立 编著 工程实用性强，是一本很好的专著。
液压控制系统
08-20
关于液压控制的
STC89C52芯片的模拟路灯控制系统
01-11
【STC89C52芯片的模拟路灯控制系统】 本文主要介绍了一种基于STC89C52单片机的模拟路灯控制系统的设计与实现。STC89C52是一款广泛应用的8位微控制器，以其高可靠性和良好的抗干扰性能而受到青睐。在路灯控制系统中...
STC12最小系统原理图
05-31
STC12系列单片机是基于51内核的一款微控制器，由宏晶科技（STC）生产，因其在51系列的基础上增加了一些增强功能，如内部集成ISP（In-System Programming）在线编程功能，使得它在电子工程领域中广泛应用。"STC12最小...
基于STC89C52控制系统的校园送餐机器人设计
07-07
自主行走单元系统采用PWM调控机器人的速度,安装在机器人底盘上的新型集成红外传感器DRS3100对轨道形状及宽度进行循迹,并将检测到的信号传输给STC89C52,控制机器人左右电机的运转,进而调整运行方向或停止。...
STC单片机控制 DS1820
12-19
STC单片机控制DS1820是一个典型的嵌入式系统应用，涉及到的主要知识点包括STC系列单片机的基本操作、DS1820数字温度传感器的工作原理以及两者之间的通信协议。 首先，STC单片机是Microchip Technology公司生产的...
一种高精度伺服控制系统设计
11-25
一种关于伺服控制的设计方法，涉及到高精度，而且是能够适用于通用的机架转动系统的
贴片STC最小系统资料包
06-13
【贴片STC最小系统资料包】是一个针对STC系列微控制器的开发资源集合，它包含了一套完整的硬件设计和软件编程所需的文档、原理图、代码示例等关键信息。STC系列微控制器是单片机的一种，因其性价比高、功能强大而...
【学习一】液压伺服与比例控制系统介绍
最新发布
weixin_43324296的博客
04-03 1132
伺服系统、控制系统
C printf输出格式控制
dragon_cdut的博客
02-17 3589
原文地址：http://c.biancheng.net/view/159.html 输入输出函数（printf 和 scanf）是C语言中非常重要的两个函数，也是学习C语言必学的两个函数。在C语言程序中，几乎没有一个程序不需要这两个函数，尤其是输出函数（printf），所以这两个函数必须要掌握。 如果在程序中要使用 printf 或者 scanf，那么就必须要包含头文件 stdio.h。因为这两...
串口屏操作
行不地上的博客
08-23 315
【代码】串口屏操作。
c语言 xff占几个字节,xff
weixin_39560002的博客
05-17 3402
知识点：《xff》 收集：充腾谑 编辑：百合仙子本知识点包括：1、在计算机中，“a\xff”在内存中占用多少字节数？为什... 2、C语言中printf("%d\n",strlen("\t\"\065\xff\n"));... 3、问个问题， printf("%d",strlen("\t\"\065\xff\n")... 4、已知ch是字符型变量，下面正确的赋值语句是。 A.ch... 5、c程里...
淘晶驰串口屏与DSP28335通信实现三相电压电流实时显示
Mickey_Yyl的博客
08-24 3192
最近有个项目需要使用屏幕实时显示系统的电压电流，使用串口屏能减少很多额外的工作量，在此做一个开发记录。 选择了淘晶驰家的串口屏，这里选用的是3.5寸的触屏显示。 附上官方文档： start [USART HMI 资料中心] (tjc1688.com) 官方的上位机软件： 2.上位软件下载:1.最新版本下载 [USART HMI 资料中心] (tjc1688.com) 查看官方手册，找到需要参考的地方： //////////////////////////////////////////////
在设计电机电路项目中总结的一些电机参数知识和设计要点 - 直流电机、空心杯电机、步进电机、伺服电机等
STCNXPARM的博客
04-14 5331
一、直流电机 1、直流电机内阻、转速、扭矩的关系： *内阻主要指线圈的匝数决定，匝数越大，内阻越大； *内阻越小，工作时消耗的电流越大，同一转速，扭矩大； *内阻越大，工作时消耗的电流越小，同一转速，扭矩小； 2、关于扭矩、公斤力、N的关系以及计算： *9.8N=1Kg=1000g ； 1N=102g; *1mN=10.2g ； ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值