ARM44B0机器人控制程序

最新推荐文章于 2020-06-18 16:53:04 发布
最新推荐文章于 2020-06-18 16:53:04 发布
阅读量1.3k 收藏
点赞数
分类专栏： ARM&RTOS 文章标签： delay timer string 测试 float hyper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujia2100/article/details/6989743
版权

本程序，是自动机器人的一个程序，融合了外部中断、定时器、PWM和利用SPI显示LCD等模块。本程序有完善的工程文件，有需要，请发送邮箱liujia1989911@126.com，有时间会把工程文件补上，以便提供参考
/*主程序*/

#include "option.h"
#include "def.h"
#include "44b.h"
#include "44blib.h"
  U32 TimerCnt=0,maichong=5000;
  unsigned int led=0; unsigned char TempData1,TempData2;    
  U32 tmp=0;
  U32 timer=0;
  U32 time=0;
  U32 speed=0;
  int out2=0,out3=0,time1=0,time0=0,time2=0,time3=0,time5=20000;//定时器计数
  char flag1=0,flag2=0,flag=0;
 
   int int1=0,int2=0,int3=0,int4=0;
 static int flg=0,flg1=0,flg2=0;
    int temp=0;
  int which_int;
  int jd=0;
void Main(void)
{
  
    rSYSCFG=CACHECFG;                                  // Using 8KB Cache
    Port_Init();
    interrupt_Init();
    init_LCD();
    clear_LCD();
    Printf(1,0,"  ABU ROBOCON");
    delay(150);
    Printf(2,0,"THE SECOND ROBOT");
    Uart_Init(0,4800);
    Delay(10);
    timems(10);                                       //设置定时器10ms定时
    rINTMSK=~(BIT_GLOBAL+BIT_EINT4567+BIT_URXD0+BIT_URXD1+BIT_TIMER5+BIT_EINT2);
    Printf(2,0,"测试开始");
   while(1) 
   {
    /* Printf(3,0,"机器人启动");
     Uart_Printf1("机器人启动");
     delay(200);
     Printf(4,0,"是否进入测试");
     Uart_Printf1("是否进入测试");
     flg1=0;
     while(!flg1){delay(1);}
     flg1=0;
     flg=0;
     clear_LCD();
     delay(200);
     Printf(1,0,"是否测试0");
     Uart_Printf1("是否测试0");
     while(!flg1){delay(1);}
     jd=0;
 
     while(flg)                           //测试电机0 记录脉冲数
     {
      clear_LCD();
      flg1=0;
      Printf(1,0,"是否开始测试0");
      Uart_Printf1("是否开始测试0");
      while(!flg1){delay(1);}
      Printf(1,0,"速度1k方向正");
      Uart_Printf1("速度1k方向正");
      pw0(1,1);
      flg1=0;
      while(!flg1){delay(1);}
      pw0off();
      Printf(1,0,"    停止    ");
      Uart_Printf1(" 停止");
      flg1=0;
      while(!flg1){delay(1);}
      Printf(1,0,"是否重试");
       Uart_Printf1("是否重试");
      flg1=0;
      while(!flg1){delay(1);}
      clear_LCD();             
      if(flg==0)
      break;            
                  
        
       
     }
     
      
     
     flg=0;
     flg1=0;
    
     clear_LCD();
     delay(200);
     Printf(1,0,"是否测试1");
     Uart_Printf1("是否测试1");
     while(!flg1){delay(1);}
     clear_LCD();
     jd=1;
    
     while(flg)
     {
     
      Printf(1,0,"test 1");
      delay(200);
      flg1=0;
      Printf(2,0,"是否开始1");
      Uart_Printf1("是否开始1");
      while(!flg1){delay(1);}  
      Printf(2,0,"开始伸杆");
      Uart_Printf1("开始伸杆");
      time5=0;
      rPDATD&=~(1<<3);     //伸杆
      rPDATD|=(1<<1);
      flg1=0;
      while(!flg1){delay(1);}
      rPDATD|=(1<<3);     //停杆
      rPDATD|=(1<<1);
      Printf(2,0,"time=%d  ",time5);
       Uart_Printf1("time=%d  ",time5);
      delay(200);
    
      Printf(3,0,"停杆");
       Uart_Printf1("停杆");
       flg1=0;
      while(!flg1){delay(1);}
      delay(200);
      flg1=0;
      Printf(3,0,"是否收起抓手");
       Uart_Printf1("是否收起抓手");
      while(!flg1){delay(1);}
      Printf(3,0,"    收起抓手");
       Uart_Printf1("收起抓手");
      rPDATD&=~(1<<2);     //收起抓手
      rPDATD|=(1<<0);
      time5=0;
      flg1=0;
      while(!flg1){delay(1);}
      rPDATD|=(1<<2);     //暂停抓手
      rPDATD|=(1<<0);
      Printf(3,0,"收起抓手time=%d",time5);
       Uart_Printf1("收起抓手time=%d",time5);
      delay(200);
      Printf(4,0,"暂停抓手");
      Uart_Printf1("暂停抓手");
      flg1=0;
      while(!flg1){delay(1);}
      clear_LCD();
      delay(200);
      Printf(1,0,"是否收杆");
      Uart_Printf1("是否收杆");
      flg1=0;
      while(!flg1){delay(1);}
      Printf(1,0,"    收杆");
      Uart_Printf1("收杆");
      rPDATD|=(1<<3);      //收杆
      rPDATD&=~(1<<1);
      time5=0;
    
      flg1=0;
      while(!flg1){delay(1);}
      rPDATD|=(1<<3);     //停杆
      rPDATD|=(1<<1);
      Printf(2,0,"收杆time=%d",time5);
       Uart_Printf1("收杆time=%d",time5);
      flg1=0;
         
      delay(200);
      Printf(3,0,"是否重试");
      Uart_Printf1("是否重试");
   
     
      while(!flg1){delay(1);}
      clear_LCD(); 
     if(flg==0)
     break;
    } 
    clear_LCD();
     delay(200);
     flg1=0;
     Printf(1,0,"是否测试2");
       Uart_Printf1("是否测试2");
     while(!flg1){delay(1);}
     clear_LCD();
     jd=2;
     while(flg)
     {
      flg1=0;
       Printf(1,0,"测试2 开始");
       Uart_Printf1("测试2 开始");
      rPDATF|=(1<<6);
      rPDATF&=~(1<<5);
      while(!flg1){delay(1);}
      flg1=0;
         
      delay(200);
      Printf(3,0,"是否重试");
      Uart_Printf1("是否重试");
    
      while(!flg1){delay(1);}
      clear_LCD(); 
      if(flg==0)
      break;
    
     } 
    
    
     clear_LCD();
     delay(200);
     flg1=0;
     Printf(1,0,"是否测试3");
       Uart_Printf1("是否测试3");
     while(!flg1){delay(1);}
     clear_LCD();
     jd=3;
    
     while(flg)
     {
     
      Printf(1,0,"test 3");
      delay(200);
      flg1=0;
      Printf(2,0,"是否开始3");
       Uart_Printf1("是否开始3");
      while(!flg1){delay(1);}  
      Printf(2,0,"开始伸杆");
       Uart_Printf1("开始伸杆");
      time5=0;
      rPDATC&=~(1<<6);     //伸杆
      rPDATC|=(1<<4);
      flg1=0;
      while(!flg1){delay(1);}
      rPDATC|=(1<<6);     //停杆
      rPDATC|=(1<<4);
      Printf(2,0,"time=%d  ",time5);
      Uart_Printf1("time=%d  ",time5);
      delay(200);
    
      Printf(3,0,"停杆");
        Uart_Printf1("停杆");
       flg1=0;
      while(!flg1){delay(1);}
      delay(200);
      flg1=0;
      Printf(3,0,"是否收起抓手");
         Uart_Printf1("是否收起抓手");
      while(!flg1){delay(1);}
      Printf(3,0,"    收起抓手");
        Uart_Printf1("收起抓手");
      rPDATC&=~(1<<2);     //收起抓手
      rPDATC|=(1<<0);
      time5=0;
      flg1=0;
      while(!flg1){delay(1);}
      rPDATC|=(1<<2);     //暂停抓手
      rPDATC|=(1<<0);
      Printf(3,0,"收起抓手time=%d",time5);
      Uart_Printf1("收起抓手time=%d",time5);
      delay(200);
      Printf(4,0,"暂停抓手");
      Uart_Printf1("暂停抓手");
      flg1=0;
      while(!flg1){delay(1);}
      clear_LCD();
      delay(200);
      Printf(1,0,"是否收杆");
        Uart_Printf1("是否收杆");
      flg1=0;
      while(!flg1){delay(1);}
      Printf(1,0,"    收杆");
        Uart_Printf1(" 收杆");
      rPDATC|=(1<<6);      //收杆
      rPDATC&=~(1<<4);
      time5=0;
    
      flg1=0;
      while(!flg1){delay(1);}
      rPDATC|=(1<<6);     //停杆
      rPDATC|=(1<<4);
      Printf(2,0,"收杆time=%d",time5);
        Uart_Printf1("收杆time=%d",time5);
      flg1=0;
         
      delay(200);
      Printf(3,0,"是否重试");
        Uart_Printf1("是否重试");
    
      while(!flg1){delay(1);}
      clear_LCD(); 
     if(flg==0)
     break;
    }   
     Printf(1,0,"测试结束祝你好运");
       Uart_Printf1("测试结束祝你好运");
     delay(200);
  Printf(2,0,"    工大必胜");
    Uart_Printf1("    工大必胜");   
 
    flg1=0;
      while(!flg1){delay(1);} */
}

}
void __irq ex4567(void)//主要做调试用
{
     
      which_int=rEXTINTPND;//rEXTINTPND外部中断挂起寄存器 P316
   Uart_Printf0("\n中断为%d", which_int);
   Delay(10);
    if(which_int==rEXTINTPND)
  {
        switch(which_int)
     {
        case 1:
         
           WrUart1('a');
           Delay(200);
           break;
       
        case 2:
            WrUart1('b');
              Delay(200);
             break;
        case 4:
             WrUart1('c');
             Delay(200);
            break;
       case 8:
            WrUart1('d');
            Delay(200);
            break;
          default:
          break;
   }   
   }
  Delay(5000);

  rEXTINTPND=0XF;         //作用是清楚中断标志
  rI_ISPC=BIT_EINT4567;     //清楚中断申请位，很重要
 
}
void motor0(int num,int k)
{
   time0=0;
   pw0(k,1);
   while((time0<=num)&&flag){delay(1);}
   pw0off();
}
void motor1(int time1,int time2)//95 D3; 97 D1; 96 D2;98 D0;第一层
{  
   clear_LCD();
   Printf(1,0,"第一层开始");
   time5=0;
   Printf(2,0,"伸杆");
   rPDATD&=~(1<<3);     //伸杆
   rPDATD|=(1<<1);
   while((time5<time1)&&flag){delay(1);}
   rPDATD|=(1<<3);     //停杆
   rPDATD|=(1<<1);
   Printf(2,0,"停杆");
   time5=0;
   while(time5<10){delay(1);}      //延时一段1s
   Printf(2,0,"收起抓手");
   rPDATD&=~(1<<2);     //收起抓手
   rPDATD|=(1<<0);
   while((time5<time2)&&flag){delay(1);}
   rPDATD|=(1<<2);     //暂停抓手
   rPDATD|=(1<<0);
   Printf(2,0,"收起抓手收杆");
   rPDATD|=(1<<3);      //收杆
   rPDATD&=~(1<<1);
   time5=0;
  while((time5<time1)&&flag){delay(1);}
   rPDATD|=(1<<3);     //停杆
   rPDATD|=(1<<1);
   Printf(2,0,"停杆");
}
void motor2(int time1,int time2)//PC6 112; PC4 114; PC2 116; PC0 118;//第二层
{  
   clear_LCD();
   Printf(1,0,"第二层开始");
   time5=0;
   Printf(2,0,"伸杆");
   rPDATC&=~(1<<6);     //伸杆
   rPDATC|=(1<<4);
   while((time5<time1)&&flag){delay(1);}
   rPDATC|=(1<<6);     //停杆
   rPDATC|=(1<<4);
   Printf(2,0,"停杆");
   time5=0;
   while(time5<10){delay(1);}     //延时一段1s
   Printf(2,0,"收起抓手");
   rPDATC&=~(1<<2);     //收起抓手
   rPDATC|=(1<<0);
   while((time5<time2)&&flag){delay(1);}
   rPDATC|=(1<<2);     //暂停抓手
   rPDATC|=(1<<0);
   Printf(2,0,"收起抓手收杆");
   rPDATC|=(1<<6);      //收杆
   rPDATC&=~(1<<4);
   time5=0;
  while((time5<time1)&&flag){delay(1);}
   rPDATC|=(1<<6);     //停杆
   rPDATC|=(1<<4);
   Printf(2,0,"停杆");
}
void motor3(int time1)//F6 58;59 ;第三组一个电机
{
   clear_LCD();
   Printf(1,0,"第二层开始");
   time5=0;
   rPDATD&=~(1<<1);
   rPDATD|=(1<<0);
   Printf(2,0,"分离");
   while((time5<time1)&&flag){delay(1);}
   rPDATD|=(1<<1);
   rPDATD|=(1<<0);
   Printf(2,0,"分离完毕");

}
/*void motor3(int time1,int time2)
{
   time5=0;
   rPDATF&=~(1<<7);     //伸杆
   rPDATF|=(1<<6);
   while((time5<time1)&&flag);
   rPDATF&=~(1<<7);     //停杆
   rPDATF&=~(1<<6);
   time5=0;
   while(time5<10);     //延时一段1s
   rPDATF&=~(1<<5);     //收起抓手
   rPDATF|=(1<<4);
   while((time5<time2)&&flag);
   rPDATF&=~(1<<5);     //暂停抓手
   rPDATF&=~(1<<4);
   rPDATF|=(1<<7);      //收杆
   rPDATF&=~(1<<6);
   time5=0;
   while((time5<time1)&&flag);
   rPDATF&=~(1<<7);     //停杆
   rPDATF&=~(1<<6);
}*/
void motor4(int time1,int time2)
{
   time5=0;
   rPDATF&=~(1<<3);     //伸杆
   rPDATF|= (1<<2);
   while((time5<time1)&&flag);
   rPDATF&=~(1<<3);     //停杆
   rPDATF&=~(1<<2);
   time5=0;
   while(time5<10);     //延时一段1s
   rPDATF&=~(1<<1);     //收起抓手
   rPDATF|=(1<<0);
   while((time5<time2)&&flag);
   rPDATF&=~(1<<1);     //暂停抓手
   rPDATF&=~(1<<0);
   rPDATF|=(1<<3);      //收杆
   rPDATF&=~(1<<2);
   time5=0;
   while((time5<time1)&&flag);
   rPDATF&=~(1<<3);     //停杆
   rPDATF&=~(1<<2);
}

void __irq Timer5(void) //定时器
{ 
 
  rI_ISPC=BIT_TIMER5; 
  timer++;

  if(timer>=50)
  {
 
  
    time5++;
    timer=0;
 
  }
}
void delayms(int i)
{
  int j;
  timer=0;
  time5=0;
 
  while(1)
  {
   j++;
   if(time5>=i)
   break;
  }
}
void __irq Timer4(void)
{ 
 
   
   rI_ISPC=BIT_TIMER4 
  ; 
 
}

void __irq Timer3(void)
{ 
 
   
   rI_ISPC=BIT_TIMER3;   
  
 
 
}
void __irq Timer2(void)
{ 
   rI_ISPC=BIT_TIMER2;
 
   
  
  
 
}
void __irq Timer1(void)
{ 
 
    
     rI_ISPC=BIT_TIMER5;
    
 
}
void __irq Timer0(void)
{ 
 
     time0++;
  
     rI_ISPC=BIT_TIMER0;
  
 
}
void __irq ex3(void)
{
 rI_ISPC=BIT_EINT3;     //清楚中断申请位，很重要
 out2++;
}
void __irq ex2(void)
{
 out2++;
 //Printf(4,0,"out2=%d",out2);

 

 rI_ISPC=BIT_EINT2;     //清楚中断申请位，很重要
}

void __irq ex1(void)
{
 rI_ISPC=BIT_EINT1;     //清楚中断申请位，很重要


}
void __irq ex0(void)
{
  rI_ISPC=BIT_EINT0;     //清楚中断申请位，很重要


 
}
void __irq Uart0_RxFifoInt(void)
{
    rI_ISPC=BIT_URXD0;
    while(!(rUFSTAT0&0x1));    
   TempData1=rURXH0;
  // Uart_Printf1("我：");
  if(TempData1=='\r')
    {
     Uart_Printf0("\n");
     Uart_Printf1("\n");
    }
  if(TempData1=='\b')
    {
     Uart_Printf0("\b");
     Uart_Printf1("\b");
    } 
   if(TempData1!='\r')
   {
     Uart_Printf1("%c",TempData1);
     Uart_Printf0("%c",TempData1);
   }
 
}
void __irq Uart1_RxFifoInt(void)
{ 
   static char string[20];
 
   static int i=0;
   int j,k;
  // static char x,y;
 
 
   rI_ISPC=BIT_URXD1;
   while(!(rUFSTAT1&0x1));    
     TempData2=rURXH1;
    // WrUart0(TempData2);
  
    if(TempData2!='\0')
       {
      string[i++]=TempData2;
  
    }
     else{
          string[i]=0;
          k=i;
          i=0; 
            // Uart_Printf0("%s\n",string);        
          //Uart_Printf0("%s\n",string);
        
         /* if(!mystrcmp(string,"二"))
           {
             x=2,y=0;
             for(j=0;j<k;j++)
             {
              string[j]=0;
             }
            
           }
          else if(!mystrcmp(string,"一"))
           {
             clear_LCD();
             x=1,y=0;
             for(j=0;j<k;j++)
             {
              string[j]=0;
             }
           
           } */
          clear_LCD();
          Delay(200);
          Printf(1,0,"%s\n",string);
          Uart_Printf0("%s\n",string);
        
        }  
          
}

 

 

 

 

/************************************************
 * NAME    : 44BLIB.C                *
 ************************************************/


#include "44b.h"
#include "44blib.h"
#include "def.h"
#include "option.h"
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>


#define STACKSIZE    0xa00 //SVC satck size(do not use user stack)
#define HEAPEND     (_ISR_STARTADDRESS-STACKSIZE-0x500) // = 0xc7ff000
 //SVC Stack Area:0xc(e)7ff000-0xc(e)7ffaff

extern char Image$$RW$$Limit[];

void *mallocPt=Image$$RW$$Limit;

int f1;
/************************* SYSTEM *************************/
void Delay(int time)
{
    int i;
 int delayLoopCount=400;

    for(;time>0;time--)
 for(i=0;i<delayLoopCount;i++);
}
void delay(int time)
{
  for(;time>0;time--);
}
void interrupt_Init(void)
{
   //外部中断设置
   rPCONG |= 0xffff;                          //引脚定义为外部中断引脚，选择引脚功能。
      rPUPG=0;
      rEXTINT =0x22222222;//外部中断控制寄存器
      rEXTINTPND=0X0;
      rINTPND=0X0;    

    //中断服务程序地址设置 
      pISR_EINT4567=(int)ex4567;
      pISR_EINT3=(int)ex3;
      pISR_EINT2=(int)ex2;
      pISR_EINT1=(int)ex1;
      pISR_EINT0=(int)ex0;
      pISR_TIMER5=(unsigned)Timer5;//5做定时器用，其他四个做pwm 
      pISR_TIMER4=(unsigned)Timer4;
      pISR_TIMER3=(unsigned)Timer3;
      pISR_TIMER2=(unsigned)Timer2;
      pISR_TIMER1=(unsigned)Timer1; 
      pISR_TIMER0=(unsigned)Timer0; 
    //  pISR_UTXD0=(unsigned)Uart0_TxFifoInt;
      pISR_URXD0=(unsigned)Uart0_RxFifoInt;
      pISR_URXD1=(unsigned)Uart1_RxFifoInt;
     // pISR_UERR01=(unsigned)Uart0_RxFifoErrorInt;
   //设置E口为外部中断下降沿触发
      rPCONE=0X0aaaa;//A800
      rPUPE|=0XFF;  
    
      rTCFG0=0X000e0e0e;//0x00000f00; //dead zone=0,pre2=0,pre1=0xf,pre0=0
      rTCFG1= 0x0111111;//0x00001000; //all interrupt,mux5=1/2,mux2=1/2,mux3=1/4,mux2=1/2,mux1=1/2,mux0=1/2
     
    
   
      rINTCON=0x5;    //Non-vectored,IRQ enable,FIQ disable
      rINTMOD=0x0;    //All=IRQ mode
    
      rTCON=0X0;
      rINTMSK=BIT_GLOBAL;
      //rINTMSK=~(BIT_GLOBAL+BIT_TIMER5+BIT_TIMER1+BIT_EINT4567+BIT_EINT0);
    
 }
void pw0(float f1,char flag1)//pw0 117
{
 
     unsigned int j;
     j=1000/f1-1;
     rTCNTB0 = j;
     rTCMPB0 = j/2;
     rTCON&=0XFFFFFF0;
     rTCON|=0X0000002;
     rTCON^=0x000000b;
 
     if(flag1==1)
    {
       rPDATC|=(1<<1);
      Uart_Printf0("\n电机0正转 频率=%4.3fk\n",f1);
      //display(3,"1 正频率",f1);
     }
      
      if(flag1==0)
    {
       rPDATC&=~(1<<1);
       Uart_Printf0("\n电机0反转 频率=%4.3fk\n",f1);
      // display(3,"1 反频率",f1);
    }
}
void pw1(float f1,char flag1)
{
 
     unsigned int j;
     j=1000/f1-1;
     rTCNTB1 = j;
     rTCMPB1 = j/2;
     rTCON&=0XFFFF0FF;
     rTCON|=0X0000200;
     rTCON^=0x0000b00;
 
     if(flag1==1)
    {
       rPDATC|=(1<<1);//0x0008;
      Uart_Printf0("\n电机1正转 频率=%4.3fk",f1);
     
       }
      
      if(flag1==0)
    {
       rPDATC&=~(1<<1);;
       Uart_Printf0("\n电机1反转 频率=%4.3fk", f1);
     
    }
}
void pw2(float f1,char flag1)
{
 
     unsigned int j;
     j=1000/f1-1;
     rTCNTB2 = j;
     rTCMPB2 = j/2;
     rTCON&=0XFFF0FFF;
     rTCON|=0X0002000;
     rTCON^=0x000b000;
 
     if(flag1==1)
    {
       rPDATC|=(1<<2);//0x0008;
      Uart_Printf0("\n电机2正转 频率=%4.3fk",f1);
      Uart_Printf0("\nrTCON=%x\n",rTCON);
       }
      
      if(flag1==0)
    {
       rPDATC&=~(1<<2);
       Uart_Printf0("\n电机2反转 频率=%4.3fk", f1);
     
    }
}


void pw3(float f1,char flag1)
{
 
     unsigned int j;
     j=1000/f1-1;
     rTCNTB3 = j;
     rTCMPB3 = j/2;
     rTCON&=0XFF0FFFF;
     rTCON|=0X0020000;
     rTCON^=0x00b0000;
 
     if(flag1==1)
    {
       rPDATC|=led1;//0x0008;
      Uart_Printf0("\n电机3正转 频率=%4.3fk",f1);
     
       }
      
      if(flag1==0)
    {
       rPDATC&=!led_off;;
       Uart_Printf0("\n电机3反转 频率=%4.3fk", f1);
     
    }
}

void pw4(float f2,char flag2)
{
   unsigned int j;
   j=1000/f2-1;
 
   rTCNTB4=j;
   rTCMPB4=j/2;
   rTCON&=0XF0FFFFF;
   rTCON|=0x0200000;
   rTCON^=0X0b00000;
 
   if(flag2==1)
    {
    rPDATC|=led2; Uart_Printf0("\n电机4正转 频率=%4.3f k",f2);}
   if(flag2==0)
    {
   rPDATC&=!led_off; Uart_Printf0("\n电机4反转 频率=%4.3f k",f2);}
}
void timems(float  time)//单位是k
{
    rTCNTB5 =time*1000-1;
    rTCON&=0X0FFFFFF;
    rTCON|=0X2000000;
    rTCON^=0x7000000; 
   
}


void timeoff(void)
{
     rTCON&=0X0ffffff;
}


void pw0off(void)
{
     rTCON&=0Xffffff0;
     Uart_Printf0("\n电机0停转\n");
}

void pw1off(void)
{
     rTCON&=0Xffff0ff;
     Uart_Printf0("\n电机1停转\n");
}
void pw2off(void)
{
     rTCON&=0Xfff0fff;
     Uart_Printf0("\n电机2停转\n");
}
void pw3off(void)
{
     rTCON&=0Xff0ffff;
     Uart_Printf0("\n电机3停转\n");
}
void pw4off(void)
{
     rTCON&=0Xf0fffff;
     Uart_Printf0("\n电机3停转\n");
}

/************************* PORTS ****************************/

void Port_Init(void)
{
  
    rPCONA=0x1ff; 
  
    rPDATB=0x3ff;
    rPCONB=0x3ff;
  
    rPDATC=0xff;//0xffff; //All I/O Is High
    rPCONC=0x0f055555;//4,5，6,7为输出lcd，pc0到pc3可用 
    rPUPC=0x3000; //PULL UP RESISTOR should be enabled to I/O
 
    rPDATD=0xff;//全部输出
    rPCOND= 0x55;
 rPUPD = 0x0;//允许上拉电阻
 
    rPDATE=0x1ff;   //All I/O Is High  PE8输出
    rPCONE=0x20428; //All NC is INPUT 
    rPUPE=0x06; //PE8 do not have programmable pull-up resistor. 
   /*
    rPDATF=0x1ff; //All I/O Is High
    rPCONF=0x20900a;//All NC is INPUT
    rPUPF=0x163;*/
    rPDATF=0X1ff;
    rPCONF=0X92555;
    rPUPF=0X0;
   
 
    rPDATG=0xff;
    rPCONG=0xffff;  
    rPUPG=0x0;  //should be enabled 
   
    rSPUCR=0x7;  //D15-D0 pull-up disable
  
 //rEXTINT=0x0; //All EXTINT0-7 Low level interrupt
 
}

/************************* UART ****************************/

//static int whichUart=0;

void Uart_Init(int mclk,int baud)
{
    int i;
    if(mclk==0)
 mclk=MCLK;
    rUFCON0=0x0; // rUFCON0=(2<<6)|(1<<4)|(6)|0;     //FIFO disable
    rUFCON1=0x0;
    rUMCON0=0x0;
    rUMCON1=0x0;
//UART0
    rULCON0=0x3;     //Normal,No parity,1 stop,8 bit
    rUCON0=0x245;    //rx=edge,tx=level,disable timeout int.,enable rx error int.,normal,interrupt or polling
    rUBRDIV0=( (int)(mclk/16./baud + 0.5) -1 );
//UART1
    rULCON1=0x3;
    rUCON1=0x245;
    rUBRDIV1=( (int)(mclk/16./baud + 0.5) -1 );
 
    for(i=0;i<100;i++);
}


/*void Uart_Select(int ch)
{
    whichUart=ch;
}*/


char Uart_Getch0(void)
{
  
 while(!(rUTRSTAT0 & 0x1)); //Receive data ready
 return RdURXH0();
}
char Uart_Getch1(void)
{  
 while(!(rUTRSTAT1 & 0x1)); //Receive data ready
 return rURXH1;
}

void Uart_SendByte0(int data)
{
  
 if(data=='\n')
 {
     while(!(rUTRSTAT0 & 0x2));
     Delay(10); //because the slow response of hyper_terminal
     WrUTXH0('\r');
 }
 while(!(rUTRSTAT0 & 0x2)); //Wait until THR is empty.
 Delay(10);
 WrUTXH0(data);
}
void Uart_SendByte1(int data)
{ 
 if(data=='\n')
 {
         while(!(rUTRSTAT1 & 0x2));
     Delay(10); //because the slow response of hyper_terminal
     rUTXH1='\r';
 }
 while(!(rUTRSTAT1 & 0x2));  //Wait until THR is empty.
 Delay(10);
 rUTXH1=data;
  
}  
unsigned char ReadUart0(void)
{
 unsigned char ReadData;
 while((rUTRSTAT0 & 0x5) == 0x0) //等待接收缓冲数据准备好
 //if(rUTRSTAT0&0X1==0X1)
 {
  ReadData = rURXH0; 
 }    //读取字符
  return ReadData;
 
 
}
unsigned char ReadUart1(void)
{
 unsigned char ReadData;
 while((rUTRSTAT1 & 0x1) == 0x0) //等待接收缓冲数据准备好
 //if(rUTRSTAT1&0X01==0X1)
 {
  ReadData = rURXH1; }    //读取字符
  return ReadData;
 
 
}
/*unsigned char ReadUart(void)
{
   unsigned char ReadData
   while(!((rUTRSTAT0&0X01)|(rUTRSTAT1&0X01)))
  


}*/
void WrUart0(unsigned char WriteData)
{
 if(WriteData=='\n')       //如果是换行符，则回车
 {
     while(!(rUTRSTAT0 & 0x2));     //等待发送缓冲为空
     Delay(10);        //延时，超级终端显示速度慢
     rUTXH0 = '\n';
 }
 while(!(rUTRSTAT0 & 0x2));         //等待
 Delay(10);
 rUTXH0 = WriteData;
}
void WrUart1(unsigned char WriteData)
{
 if(WriteData=='\r')       //如果是换行符，则回车
 {
     while(!(rUTRSTAT1 & 0x2));     //等待发送缓冲为空
     Delay(10);        //延时，超级终端显示速度慢
     rUTXH1 = '\n';
 }
 while(!(rUTRSTAT1 & 0x2));         //等待
 Delay(10);
 rUTXH1 = WriteData;
}
void Uart_SendString0(char *pt)
{
    while(*pt)
 Uart_SendByte0(*pt++);
}
void Uart_SendString1(char *pt)
{
    while(*pt)
 Uart_SendByte1(*pt++);
}


//if you don't use vsprintf(), the code size is reduced very much.
void Uart_Printf0(char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    Uart_SendString0(string);
    WrUart0('\0');
    va_end(ap);
}
void Uart_Printf1(char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    Uart_SendString1(string);
    WrUart1('\0');
    va_end(ap);
}
char *String(char string)
{
    static char string1[1];
    static char *string2=string1;
    static int i=0;
    if(string!='\0')
     *(string2+i++)=string;
   
         *(string2+i)='\0';
          i=0;
       return string2;     
}


/************************* ledblink *****************************/

void Led_Display(int LedStatus)
{
 //PC1,PC2,PC3 High available
    rPDATC=(rPDATC & 0x1f1) | ((LedStatus & 0x7)<<1);
}

/************************* beep *********************************/

void Beep(int BeepStatus)
{
 //PE5 Low available
 if (BeepStatus==0)
  rPDATE=rPDATE&0x1df;
 else
  rPDATE=rPDATE|0x020;
}

/************************* Timer ********************************/

void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3);
    rWTDAT=0xffff;
    rWTCNT=0xffff;  

    // 1/16/(65+1),nRESET & interrupt  disable
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3)|(1<<5); 
}


int Timer_Stop(void)
{
//    int i;
    rWTCON=((MCLK/1000000-1)<<8);
    return (0xffff-rWTCNT);
}


/************************* PLL ********************************/
void ChangePllValue(int mdiv,int pdiv,int sdiv)
{
    rPLLCON=(mdiv<<12)|(pdiv<<4)|sdiv;
}


/************************* General Library **********************/

void * malloc(unsigned nbyte)
/*Very simple; Use malloc() & free() like Stack*/
//void *mallocPt=Image$$RW$$Limit;
{
    void *returnPt=mallocPt;

    mallocPt= (int *)mallocPt+nbyte/4+((nbyte%4)>0); //to align 4byte

    if( (int)mallocPt > HEAPEND )
    {
 mallocPt=returnPt;
 return NULL;
    }
    return returnPt;
}


void free(void *pt)
{
    mallocPt=pt;
}


void Cache_Flush(void)
{
    int i,saveSyscfg;
   
    saveSyscfg=rSYSCFG;

    rSYSCFG=SYSCFG_0KB;        
    for(i=0x10004000;i<0x10004800;i+=16)   
    {       
 *((int *)i)=0x0;    
    }
    rSYSCFG=saveSyscfg;       
}
/************************* LCD 串口方式显示*************************/
//串行发送一字节数据  

unsigned char  AC_TABLE[]={
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,      //第一行汉字位置
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,      //第二行汉字位置
0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,      //第三行汉字位置
0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,      //第四行汉字位置
};


void     SendByte(unsigned     char     dat)  
    {  
       unsigned     char     i;  
       for(i=0;i<8;i++)  
           {  
               rPDATC&=~(1<<7);//E_CLK=0;  
               if(dat&0x80)
               rPDATC|=(1<<5); //RW_SID=1;
               else  rPDATC&=~(1<<5);//RW_SID=0;  
               rPDATC|=(1<<7); //E_CLK=1; 
               dat=dat<<1;  
                            }  
    }
 
 
 
 
//写控制命令  
void     SendCMD(unsigned     char     dat)  
    {
              SendByte(0xF8);//11111,00,0     RW=0,RS=0     同步标志  
              SendByte(dat&0xF0);//高四位
              SendByte((dat&0x0F)<<4);//低四位 
              Delay(10);
    }
 
 
//写显示数据或单字节字符  
void     SendDat(unsigned     char     dat)  
    {
              SendByte(0xFA);//11111,01,0     RW=0,RS=1  
              SendByte(dat&0xF0);//高四位  
              SendByte((dat&0x0F)<<4);//低四位 
    }
   
 void init_LCD(void)
{ 
 delay(50);
 rPDATC&=~(1<<3);    //RST=0;
 Delay(10);
 rPDATC|=(1<<3);    //RST=1;     //复位

 SendCMD(0x30);   //模式8位，基本命令
 SendCMD(0x0c);  //整体显示开，光标显示开，光标反白
 SendCMD(0x01);  //清除显示
 SendCMD(0x02);
 SendCMD(0x80);
}
void clear_LCD(void)
{
 SendCMD(0x01);
 SendCMD(0x34);
 SendCMD(0x30);
}
void set_XY(unsigned char xpos,unsigned char ypos)
{
switch(ypos)
{
   case 1:
    SendCMD(0X80|xpos);break;
   case 2:
    SendCMD(0X90|xpos);break;
   case 3:
    SendCMD(0X88|xpos);break;
   case 4:
    SendCMD(0X98|xpos);break;
   default:break;
}
}

/*void display1(unsigned char x,unsigned y,char *str)
{
    unsigned char lcd_temp;
       
    set_XY(y,x);
    lcd_temp=*str;
    while(lcd_temp != 0x00)
    {
        SendDat(lcd_temp);
        lcd_temp=*(++str);
     
    }
  

}*/
void     disasc(unsigned char x,unsigned char y,unsigned char dat)  
    { 
         set_XY(y,x);
         SendDat(dat);
             
    }
void disstr(unsigned char x,unsigned char y,char *str)
{
    unsigned char lcd_temp;   
    set_XY(y,x);
    lcd_temp=*str;
    while(lcd_temp != 0x00)
    {
        SendDat(lcd_temp);
        lcd_temp=*(++str);
      
    }
}
 
void disvar(unsigned char x,unsigned char y,float data)
{
    
     int i,j11=0;
     unsigned char strTemp[7];
   
     int uiData;
     uiData=data*10;
     set_XY(y,x);
    strTemp[0] = (unsigned char)((uiData % 10) + 0x30);
    strTemp[1]=0x2e;
    strTemp[2] = (unsigned char)(((uiData / 10) % 10) + 0x30);
    strTemp[3] = (unsigned char)(((uiData / 100) % 10) + 0x30);
    strTemp[4] = (unsigned char)(((uiData / 1000) % 10) + 0x30);
    strTemp[5] = (unsigned char)(((uiData / 10000)% 10) + 0x30);
    strTemp[6] = (unsigned char)(((uiData / 100000)% 10) + 0x30);
   while(uiData/10)//显示位数
     {
      uiData/=10;
      ++j11;
     }
     for(i=j11+1;i>=0;i--)
               SendDat(strTemp[i]);
   j11=0;
   delay(50);
 }
 void  display(unsigned char x,char *str,float data)
 {
     unsigned char lcd_temp;
     int i,j11=0;
     unsigned char strTemp[7];
     int y=0;
     int uiData;
     uiData=data*10;
     set_XY(y,x);
      
    lcd_temp=*str;
    while(lcd_temp != 0x00)
    {
        SendDat(lcd_temp);
        lcd_temp=*(++str);
    }
  
   
    strTemp[0] = (unsigned char)((uiData % 10) + 0x30);
    strTemp[1]=0x2e;
    strTemp[2] = (unsigned char)(((uiData / 10) % 10) + 0x30);
    strTemp[3] = (unsigned char)(((uiData / 100) % 10) + 0x30);
    strTemp[4] = (unsigned char)(((uiData / 1000) % 10) + 0x30);
    strTemp[5] = (unsigned char)(((uiData / 10000)% 10) + 0x30);
    strTemp[6] = (unsigned char)(((uiData / 100000)% 10) + 0x30);
   while(uiData/10)//显示位数
   {
   uiData/=10;
   ++j11;
   }
     for(i=j11+1;i>=0;i--)
               SendDat(strTemp[i]);
   j11=0;
   delay(50);
 }
void Printf(unsigned char x,unsigned char y,char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    disstr(x,y,string);
    va_end(ap);
}
void printflcd(char *fmt,...)
{  unsigned char lcd_temp;
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
     
   
    lcd_temp=*fmt;
    while(lcd_temp != 0x00)
    {
        SendDat(lcd_temp);
        lcd_temp=*(++fmt);
      
    }
    va_end(ap);
   
}
int mystrcmp(char* a, char* b)
{
  char c;
  for(;(*a!='\0')&&(*b!='\0');a++,b++)
  {
    if(*a==*b)
    continue;
    else
    break;
   }
   if(*a=='\0')
   return c=0;
   else
   return c=1;
}
/************************* 电机 ****************************/

liujia2100
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
联发科MTK6737安卓4G全网通智能模块核心板规格书
qilinktech的博客
04-20 4415
QL160模块硬件设计指导手册深圳市褀联科技有限公司一 、综述1.1 适用范围本文档适用的产品是：QL160模块。本核心板是以MT6735（兼容MT6737/8735/6753）为平台，周围配件主要有MT6328 电源模块，存储模块，MT6625L 四合一无线模块，MT6158 和MT6169 射频模块等，通过对核心板QL160的介绍， 用以指导用户对QL160 模块进行硬件设计，并在该模块基础上...
mtk android 关机充电,MTK充电开机关机过程
weixin_36253081的博客
05-27 1580
一、 工作原理：1、 手机主板加电，插入下载数据线；2、 开机信号使手机工作，并产生；3、 启动IBOOT CODE引导程序；4、 运行内置在CPU System ROM内的Factory Programming程序；5、 CPU检测到通用异步串行端口UART1有效信号，用来配置下载所需参数；6、 CPU通过UTXD1、URXD1引脚将下载数据存入System RAM或者外部FLASH中。7、 完...
arm44b0原理图，包括原理图以及pcb图
04-25
arm44b0原理图，包括原理图以及pcb图，对44b0电路设计有参考作用
MSP430F149数据手册.pdf
07-21
这是MSP430F149数据手册，方便你们下载，也不要到处去找了。
罗马计数法
热门推荐
08-01 1万+
7 8 9 10 11 12 VII VIII IX X XI XII 712=DCCXII 罗马数字的符号一共只有7个：I（代表1）、V（代表5）、X（代表10）、L（代表50）、C代表1
基于ARM7的远程机器人控制系统设计
01-19
其工作过程为远端PC机向机器人控制器发送控制命令，处理器接收到来自远端的命令，发送到控制器，控制器控制机器人运动；机器人监视系统，通过视频摄像头抓取现场图像，传送到远端，在远端PC上显示现场图像。 　（1）...
高级机器人控制器ARM
07-16
ARM一般为32位单片机，适于处理大量复杂数据，很多ARM装上了UCOS2、WindowsCE、Linux操作系统，下面来学习一下
爬壁机器人控制程序
10-21
【标题】"爬壁机器人控制程序"涉及到的关键技术主要集中在嵌入式系统、微控制器以及电机控制领域。这里的核心是STM32微控制器，它在爬壁机器人的运动控制中扮演着重要角色。 STM32是一款基于ARM Cortex-M内核的微...
ARM44B0PCB原理图
09-15
在原理图中，ARM44B0的引脚布局、电源管理、时钟系统、中断控制器、以及与外围设备的连接方式等都是设计的重点。 在“ARM44B0_SCH.rar”压缩包中，包含的“ARM44B0_SCH.ddb”文件是设计数据库，通常用于专业电路...
arm.rar_44b0_arm
最新发布
09-19
44b0是ARM体系结构中的一种特定核心，它属于早期的ARM7系列，具有32位RISC（精简指令集计算）设计。 **ARM7TDMI-S核心** 44b0是基于ARM7TDMI-S核心的，其中T代表“Thumb”指令集，DMI代表“数据处理、多字节操作和...
嵌入式系统原理程序题汇总
weixin_46148956的博客
06-18 2302
0、汇编实例 P67： 例1:该例要求完成18+8,并保存结果到R7寄存器中,指令代码如下： AREA example1,CODE, READONLY;指明一个代码段名称为examplel ENTRY;指明程序的人口 start MOV R7, #18;R7中赋值18,这是第1条运行指令 MOV R6, #8;R6中赋值8 ADD R7, R7, R6;R7=R7 + R6 ;下面指令用于返回调试器 stop MOV R0, # 0x18 LDR R1, = 0x2002
手机电源工作原理
kerson的专栏
12-03 7506
一、 手机下载工作原理： 1、 手机主板加电，插入下载数据线； 2、 开机信号使手机电源管理芯片工作，并产生复位信号； 3、 启动IBOOT CODE引导程序； 4、 运行内置在CPU System ROM内的Factory Programming程序； 5、 CPU检测到通用异步串行端口UART1有效信号，用来配置下载所需参数； 6、 CPU通过UTXD1、URXD1引脚将下载数据存入Syste
ARM44b0 中断总结
04-26 493
     经过自学，然后又系统的学习，写一点ARM44b的中断总结。中断：首先进行中断控制等寄存器的设置，然后主要是中断响应流程。     当中断发生是，处理器会自动跳转到从0x0地址开始的异常中断矢量表中的某个位置（由异常类型确定）跳转后读取指令然后运行。比如：IRQ中断发生，一定跳到0x18地址，b IRQ ；      当中断发生是，主要是中断服务函数的地址怎么装到PC指针中的，通常在中断初始化时会有：pISR_EINT3=(int)EXT3_Exception;这样一条指令，就是把EXT3_Exce
我的RTOS 之三 --Threadx在s5pv210上移植
liujia2100的专栏
11-04 5056
threadx s5pv210
我的RTOS 之一 --S5PV210 异常向量表基址和软中断测试
liujia2100的专栏
10-30 3711
s5pv210 软中断 异常向量基址修改
我的RTOS 之六 -- Touch移植(s5pv210+threadx+ucgui+touch)
liujia2100的专栏
07-01 3201
RTOS Threadx UCGUI Touch
嵌入式Linux驱动的ARM9排爆机器人远程控制系统
"基于ARM9的排爆机器人远程控制系统设计与实现" 本文主要探讨了如何利用ARM9处理器和嵌入式Linux系统设计与实现一个具备视觉功能的智能排爆机器人远程控制系统。ARM9处理器是32位嵌入式处理器中的主流选择，因其高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值