Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1058224
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
uart裸机驱动程序

分类： LINUX

2015-12-02 11:27:10

2440init.h文件

点击(此处)折叠或打开

  1. #ifndef _2440INIT_H_
  2. #define _2440INIT_H_

  4. /* WATCHDOG寄存器 */
  5. #define WTCON (*(volatile unsigned long *)0x53000000)
  6. /* SDRAM寄存器 */
  7. #define     MEM_CTL_BASE        0x48000000

  9. /*系统时钟相关寄存器*/
  10. #define    MPLLCON        (*(volatile unsigned long *)0x4c000004)
  11. #define    CLKDIVN        (*(volatile unsigned long *)0x4c000014)
  12. #define S3C2440_MPLL_200MHZ ((0x5c<<12)|(0x01<<4)|(0x02))

  14. void disable_watch_dog();
  15. void clock_init(void);
  16. void memsetup();
  17. void copy_steppingstone_to_sdram(void);

  19. #endif
init.c文件

点击(此处)折叠或打开

  1. #include "2440init.h"
  2. #include "uart.h"

  4. /*
  5.  * 关闭WATCHDOG，否则CPU会不断重启
  6.  */
  7. void disable_watch_dog(void)
  8. {
  9.     WTCON = 0; // 关闭WATCHDOG很简单，往这个寄存器写0即可
  10. }

  12. /*
  13.  * 对于MPLLCON寄存器，[19:12]为MDIV，[9:4]为PDIV，[1:0]为SDIV
  14.  * 有如下计算公式：
  15.  * S3C2440: MPLL(FCLK) = (2 * m * Fin)/(p * 2^s)
  16.  * 其中: m = MDIV + 8 = 92+8, p = PDIV + 2 = 1+2, s = SDIV = 2
  17.  * 对于本开发板，Fin = 12MHz
  18.  * 设置CLKDIVN，令分频比为：FCLK:HCLK:PCLK=1:2:4，
  19.  * FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
  20.  */
  21. void clock_init(void)
  22. {
  23.     // LOCKTIME = 0x00ffffff; // 使用默认值即可
  24.     CLKDIVN = 0x03; // FCLK:HCLK:PCLK=1:2:4, HDIVN=1,PDIVN=1
  25.     /* 如果HDIVN非0，CPU的总线模式应该从“fast bus mode”变为“asynchronous bus mode” */
  26. __asm__(
  27.     "mrc p15, 0, r1, c1, c0, 0\n" /* 读出控制寄存器 */
  28.     "orr r1, r1, #0xc0000000\n" /* 设置为“asynchronous bus mode” */
  29.     "mcr p15, 0, r1, c1, c0, 0\n" /* 写入控制寄存器 */
  30.     );

  32.     MPLLCON = S3C2440_MPLL_200MHZ;
  33.     /* 现在，FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
  34.     并不保证你的任何设置都是合适的。所以，如果想要工作在200MHz，还是按照vivi的推荐值((0x5c<<12)|(0x01<<4)|(0x02))即可。
  35.     */
  36. }

  38. /*
  39. *功能：设置存储控制器以使用SDRAM
  40. *注意：REFRESH寄存器有特殊
  41. * 未开启PLL时：HCLK=12MHz: REFRESH寄存器值取： 0x008C07A3,
  42. * 开启PLL时：HCLK=100MHz: REFRESH寄存器值取： 0x008C04F4
  43. *在这个程序里面，为什么不能用下面这个函数，原因还没搞清楚。

  45.         链接地址指定为：0x30000000时，这个数组的反汇编代码：
  46.         300003c0 <.rodata>:
  47.         300003c0:    22011110     andcs    r1, r1, #4    ; 0x4
  48.         300003c4:    00000700     andeq    r0, r0, r0, lsl #14
  49.         300003c8:    00000700     andeq    r0, r0, r0, lsl #14
  50.         300003cc:    00000700     andeq    r0, r0, r0, lsl #14
  51.         300003d0:    00000700     andeq    r0, r0, r0, lsl #14
  52.         300003d4:    00000700     andeq    r0, r0, r0, lsl #14
  53.         300003d8:    00000700     andeq    r0, r0, r0, lsl #14
  54.         300003dc:    00018005     andeq    r8, r1, r5
  55.         300003e0:    00018005     andeq    r8, r1, r5
  56.         300003e4:    008c04f4     streqd    r0, [ip], r4
  57.         300003e8:    000000b1     streqh    r0, [r0], -r1
  58.         300003ec:    00000030     andeq    r0, r0, r0, lsr r0
  59.         300003f0:    00000030     andeq    r0, r0, r0, lsr r0
  60.         Disassembly of section .rodata.str1.4:
  61.         
  62.         链接地址指定为：0x0时，这个数组的反汇编代码：
  63.         000003c0 <.rodata>:
  64.         3c0:    22011110     andcs    r1, r1, #4    ; 0x4
  65.         3c4:    00000700     andeq    r0, r0, r0, lsl #14
  66.         3c8:    00000700     andeq    r0, r0, r0, lsl #14
  67.         3cc:    00000700     andeq    r0, r0, r0, lsl #14
  68.         3d0:    00000700     andeq    r0, r0, r0, lsl #14
  69.         3d4:    00000700     andeq    r0, r0, r0, lsl #14
  70.         3d8:    00000700     andeq    r0, r0, r0, lsl #14
  71.         3dc:    00018005     andeq    r8, r1, r5
  72.         3e0:    00018005     andeq    r8, r1, r5
  73.         3e4:    008c04f4     streqd    r0, [ip], r4
  74.         3e8:    000000b1     streqh    r0, [r0], -r1
  75.         3ec:    00000030     andeq    r0, r0, r0, lsr r0
  76.         3f0:    00000030     andeq    r0, r0, r0, lsr r0
  77.         Disassembly of section .rodata.str1.4:

  79. 可以看出来，这个数组中的数据放在ro段。

  81. 1，链接脚本只能决定你的各个段的地址，但是如果里面某个函数的代码没有访问任何与绝对地址相关的东西。是可以在任意地址运行的。

  83. 2，这段代码中数组里面的数据一般会放在RO段，是在链接的时候决定了他的位置，并且访问时以链接的绝对地址访问。
  84.         
  85.         链接起始地址指定为：0x30000000时，打印结果如下：
  86.         mem_cfg_val[0]的地址=0x00000FB4,值=0xFFFFFFFF：
  87.         因为：mem_cfg_val[0]数组存放在4k内的物理地址0x00000FB4中，但是，程序会从连接地址0x300003c0中取值，所以是不对的值。
  88.         ......
  89.         mem_cfg_val[10]的地址=0x00000FE0,值=0xFFFFFFFF
  90.         mem_cfg_val[10]的地址=0x00000FE4,值=0xFFFFFFFF
  91.         
  92.         上面的值，明显是垃圾数据，那为什么地址不是0x300开头的地址？
  93.         
  94.         链接起始地址指定为：0x0时，打印结果如下：
  95.         mem_cfg_val[0]的地址=0x00000FB4,值=0x22011110：
  96.         因为：mem_cfg_val[0]数组存放在4k内的物理地址0x00000FB4中，程序会从连接地址0x000003c0中取值，所以值是对的。
  97.         mem_cfg_val[1]的地址=0x00000FB8,值=0x00000700
  98.         ......
  99.         mem_cfg_val[8]的地址=0x00000FD4,值=0x00018005
  100.         mem_cfg_val[9]的地址=0x00000FD8,值=0x008C04F4
  101.         ......
  102.         mem_cfg_val[12]的地址=0x00000FE4,值=0x00000030
  103.         值是正常的
  104.         
  105. void memsetup(void)
  106. {
  107.         //init_uart();
  108.         uart_sendByte('\n');
  109.         uart_sendByte('w');
  110.         uart_sendByte('x');
  111.         uart_sendByte('c');
  112.         uart_sendByte('\n');
  113.         
  114.         // 连接地址是0x0时，这个函数是可以随便用的。
  115.     // 这个数组的地址是：连接地址0x30000000开始中的某个地址，不是映象文件的偏移物理地址0x0开始的。
  116.     // 即由于连接地址 和 映象文件的偏移物理地址 不是相同的地址值，
  117.     // 刚开始运行时是 映象文件的偏移物理地址，所以取连接地址中的值的时候，取不到想要的值
  118.     unsigned long const mem_cfg_val[]={ 0x22011110, //BWSCON
  119.                                             0x00000700, //BANKCON0
  120.                                             0x00000700, //BANKCON1
  121.                                             0x00000700, //BANKCON2
  122.                                             0x00000700, //BANKCON3
  123.                                             0x00000700, //BANKCON4
  124.                                             0x00000700, //BANKCON5
  125.                                             0x00018005, //BANKCON6
  126.                                             0x00018005, //BANKCON7
  127.                                             0x008C04F4, //REFRESH
  128.                                             0x000000B1, //BANKSIZE
  129.                                             0x00000030, //MRSRB6
  130.                                             0x00000030, //MRSRB7
  131.                                     };
  132.     int i = 0;
  133.     
  134.     volatile unsigned long *p = (volatile unsigned long *)MEM_CTL_BASE;
  135.     for(; i < 13; i++)
  136.        {
  137.                uart_sendByte('\n');
  138.                 uart_sendByte('n');
  139.                 uart_sendByte('o');
  140.                 uart_sendByte('.');
  141.                 uart_sendByte_hex((unsigned long)i);
  142.                 uart_sendByte(':');
  143.                uart_sendByte_hex((unsigned long)(&(mem_cfg_val[i]))); //为什么打印出来的不是连接地址啊？？？
  144.                uart_sendByte('=');
  145.                uart_sendByte_hex((unsigned long)(mem_cfg_val[i]));
  146.                uart_sendByte('\n');
  147.                
  148.         p[i] = mem_cfg_val[i];
  149.     }
  150. }
  151. */

  153. void memsetup(void)
  154. {
  155.     volatile unsigned long *p = (volatile unsigned long *)MEM_CTL_BASE;

  157.     // 这个函数之所以这样赋值，而不是像前面的实验(比如mmu实验)那样将配置值
  158.     // 写在数组中，是因为要生成”位置无关的代码”，使得这个函数可以在被复制到
  159.     // SDRAM之前就可以在steppingstone中运行
  160.     // 存储控制器13个寄存器的值
  161.     p[0] = 0x22011110; //BWSCON
  162.     p[1] = 0x00000700; //BANKCON0
  163.     p[2] = 0x00000700; //BANKCON1
  164.     p[3] = 0x00000700; //BANKCON2
  165.     p[4] = 0x00000700; //BANKCON3
  166.     p[5] = 0x00000700; //BANKCON4
  167.     p[6] = 0x00000700; //BANKCON5
  168.     p[7] = 0x00018005; //BANKCON6
  169.     p[8] = 0x00018005; //BANKCON7
  170.     
  171.                                             // REFRESH,
  172.                                             // HCLK=12MHz: 0x008C07A3,
  173.                                             // HCLK=100MHz: 0x008C04F4
  174.     p[9] = 0x008C04F4;
  175.     p[10] = 0x000000B1; //BANKSIZE
  176.     p[11] = 0x00000030; //MRSRB6
  177.     p[12] = 0x00000030; //MRSRB7
  178. }

  180. /*
  181. *功能：复制启动石中的4K代码，到SDRAM中去
  182. */
  183. void copy_steppingstone_to_sdram(void)
  184. {
  185.     unsigned int * src = (unsigned int *)0x0; /*片内4K内存*/
  186.     unsigned int * des = (unsigned int *)0x30000000; /*SDRAM起始地址，全部是物理地址*/
  187.     
  188.     while (src < (unsigned int *)4096) /*复制4K空间*/
  189.     {
  190.         *des = *src;
  191.         des++;
  192.         src++;
  193.     }
  194. }
head.S文件

点击(此处)折叠或打开

  1. @******************************************************************************
  2. @ File：head.S
  3. @ 功能：设置SDRAM，将程序复制到SDRAM，然后跳到SDRAM继续执行
  4. @******************************************************************************
  5. .extern main
  6. .text
  7. .global _start
  8. _start:
  9.     ldr sp, =4096 @ 设置栈指针，以下都是C函数，调用前需要设好栈
  10.     bl disable_watch_dog @ 关闭WATCHDOG，否则CPU会不断重启
  11.     @ bl是位置无关码，相当于：PCnew = PC + 偏移
  12.     @ PCnew = (4+8) + 0x28 = 0x34
  13.     
  14.     @ ldr pc, =disable_watch_dog
  15.     @ ldr是位置相关码，相当于：PC=链接脚本中指定的链接地址0x30000034,走到这里时，程序会崩溃，所以不能使用LDR。
  16.     
  17.     bl clock_init @ 设置MPLL，改变FCLK、HCLK、PCLK
  18.     bl init_uart
  19.     bl memsetup @ 设置存储控制器以使用SDRAM
  20.     bl copy_steppingstone_to_sdram @ 复制代码到SDRAM中，在这之前，需要使用位置无关码。从这之后，使用的指令是不是位置无关码，没有关系了
  21.     
  22.     ldr pc, =on_sdram @ 跳到SDRAM中继续执行
  23. on_sdram:
  24.     ldr sp, =4096 @ 设置栈指针,0x30000000到 0x34000000 ，是SDRAM地址范围，共64M
  25.     ldr lr, =my_loop     @ 设置返回地址
  26.     @ bl main
  27.     ldr pc, =main @ 调用main函数
  28. my_loop:
  29.     b my_loop
leds.c

点击(此处)折叠或打开

  1. #include "2440init.h"
  2. #include "uart.h"

  4. /**************************************************************************/
  5. //LED相关的GPIO
  6. #define GPBDAT (*(volatile unsigned long *)0x56000014)
  7. #define GPBCON (*(volatile unsigned long *)0x56000010)
  8. #define GPBUP (*(volatile unsigned long *)0x56000018)
  9. /*注意：这个程序没有mmu，所以寄存器的地址是物理地址*/

  11. #define GPB5_OUT (1<<(5*2))
  12. #define GPB6_OUT (1<<(6*2))
  13. #define GPB7_OUT (1<<(7*2))
  14. #define GPB8_OUT (1<<(8*2))

  16. #define GPB5_ON (~(1<<5))
  17. #define GPB6_ON (~(1<<6))
  18. #define GPB7_ON (~(1<<7))
  19. #define GPB8_ON (~(1<<8))

  21. #define GPB5_OFF (1<<5)
  22. #define GPB6_OFF (1<<6)
  23. #define GPB7_OFF (1<<7)
  24. #define GPB8_OFF (1<<8)
  25. /**************************************************************************/

  27. /*
  28.  * 功能：初始化LED的GPIO引脚
  29.  * 注意：这个函数用不用inline都一样，不会影响运行，因为head.S中使用的是ldr pc, =main，不是ldr pc, =0x30004000一样绝对的值。
  30.  */
  31. static inline void init_led()
  32. {
  33.      GPBCON = (GPB5_OUT | GPB6_OUT | GPB7_OUT | GPB8_OUT);
  34.     GPBUP = 0x1e0;
  35.     GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  36. }

  38. /*
  39. *功能：延时函数
  40. */
  41. static void wait(volatile unsigned int num)
  42. {
  43.     unsigned int i = 0;
  44.     unsigned int j = 0;
  45.     for(i=0; i<100; i++)
  46.         for(j=0; j<num; j++);
  47. }


  50. int main(void)
  51. {
  52.         // init_uart(); 在head.S中已经初始化了，这里可以省略
  53.         
  54.         uart_sendString("\n\n UART and LED begin:\n");
  55.         //uart_printf("%s%s:[%s][%s][%s]\n", __DTAE__, __TIME__, __FILE__, __FUNCTION__, __LINE__);
  56.         
  57.     init_led();
  58.     
  59.     int i = 8;
  60.     int j = 802;
  61.     char ch1 = 'a';
  62.     char ch2 = 'A';
  63.     unsigned long num = i*100;
  64.     unsigned long num2 = 0xFFFFFFFF;
  65.     char * name = "wangxiancai";
  66.     
  67.     int testnum = 12;
  68.     int x = testnum / 8;
  69.     int y = testnum % 8;
  70.     uart_printf("************x=[%d]***********\n", x);
  71.     uart_printf("************y=[%d]***********\n", y);
  72.     
  73.     uart_printf("************i=[%d]***********\n", i);
  74.     uart_printf("************j=[%d]***********\n", j);
  75.     uart_printf("************ch1=[%c]=[0x%x]***********\n", ch1, ch1);
  76.     uart_printf("************ch2=[%c]=[0x%x]***********\n", ch2, ch2);
  77.     uart_printf("************num=[0x%x]***********\n", num);
  78.     uart_printf("************num2=[0x%x]***********\n", num2);
  79.     uart_printf("************name=[%s]***********\n", name);
  80.     
  81.     while(1)
  82.     {
  83.             uart_sendString("\n***********************************\n");
  84.             uart_sendString("LED ON 3 second!\n");
  85.         GPBDAT = (GPB5_ON & GPB6_ON & GPB7_ON & GPB8_ON);
  86.         wait(30000);
  87.         uart_sendString("LED OFF 2 second!\n");
  88.         uart_sendString("***********************************\n");
  89.         GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  90.         wait(20000);
  91.         
  92.     }

  94.     return 0;
  95. }
makefile文件

点击(此处)折叠或打开

  1. objs := head.o init.o uart.o leds.o

  3. uart.bin: $(objs)
  4.     arm-linux-ld -Tuart.lds -o uart_elf $^ $(shell arm-linux-gcc -msoft-float -print-libgcc-file-name)
  5. ##    arm-linux-ld -Tuart.lds -o uart_elf head.o init.o uart.o leds.o /home/wangxc/linux/toolchain/gcc-3.4.5-glibc-2.3.6/bin/../lib/gcc/arm-linux/3.4.5/libgcc.a 同上一句
  6.     arm-linux-objcopy -O binary -S uart_elf $@
  7.     arm-linux-objdump -D -m arm uart_elf > uart.dis
  8.     
  9. %.o:%.c
  10.     arm-linux-gcc -O2 -c -o $@ $<

  12. %.o:%.S
  13.     arm-linux-gcc -Wall -O2 -c -o $@ $<

  15. clean:
  16.     rm -f uart.bin uart_elf uart.dis *.o
uart.c文件

点击(此处)折叠或打开

  1. #include "uart.h"

  3. /***********************************************************************************/
  4. //串口相关函数
  5. /*功能：初始化串口UART0
  6. *轮询方式来使用串口
  7. */
  8. void init_uart(void)
  9. {
  10.      /*GPHCON寄存器
  11.     [7:6]=10,GPH2作为TXD0,串口发送数据引脚
  12.     [5:4]=10,GPH3作为RXD0,串口接受数据引脚
  13.     GPH2，GPH3控制串口通道0
  14.     GPH4，GPH5控制串口通道1
  15.     GPH6，GPH7控制串口通道2
  16.     */
  17.         rGPHCON = ((2<<6)|(2<<4)|(0<<2)|(0<<0));
  18.         rGPHUP = ((1<<3)|(1<<2)); /*禁止上拉*/
  19.         
  20.         /*ULCON0串口线路控制寄存器:设置传输格式
  21.         [6]=0，普通模式，非红外工作模式
  22.         [5:3]=000，无奇偶校验位，100=奇校验，101=偶校验，110=固定校验位为1，111=固定校验位为0
  23.         [2]=0，每帧1个停止位，1：每帧2个停止位
  24.         [1:0]=11，8位，每帧发送或接受的数据位的个数。00=5位，01=6位，10=7位
  25.         */
  26.         rULCON0 = 0x3;
  27.         
  28.         /*UCON0:串口控制寄存器：用于选择UART时钟源，设置UART中断方式
  29.         [15:12]: 当[11:10]选择PCLK时，这4位无效。选择FCLK/n时，表示n值。
  30.         [11:10]=00: 选择PCLK给UART比特率，10：PCLK, 01：UEXTCLK, 11:FCLK/n。
  31.         [9]=1: 中断请求类型
  32.         [8]=0: 中断请求类型
  33.         [7]=0: 禁止超时中断，1：使能超时中断
  34.         [6]=1: 产生接受错误状态中断，1：不产生接受错误状态中断
  35.         [5]=0: 正常操作，非回环模式。发送引脚发送的数据，直接到达接受引脚，一般是测试用。
  36.         [4]=0: 正常操作，不发送断电信号
  37.         [3:2]=01: 发送模式，中断或者轮询,如果中断寄存器不设置，就是轮询。
  38.         [1:0]=01: 接受模式，中断或者轮询
  39.         */
  40.         rUCON0 = 0x5;
  41.         
  42.         /*UFCON:串口FIFO控制寄存器：用于设置是否使用FIFO,设置各FIFO的触发阀值。
  43.         [7:6]=发送FIFO的触发深度，即在发送时，发送FIFO中还剩有多少个数据时，才触发中断，告诉CPU可以继续发送了。
  44.         [5:4]=接受FIFO的触发深度，即在接受时，接受FIFO中接受了多少个数据后，才触发中断，告诉CPU已经有接受到的数据了。
  45.         [3]=空
  46.         [2]=TX的FIFO是否复位
  47.         [1]=RX的FIFO是否复位
  48.         [0]=0,不使用FIFO，非FIFO模式，相当于接受和发送时，不使用缓冲寄存器,上面的设置无效。如果这里是1，则上面的位肯定有对应的设置。
  49.         */
  50.         rUFCON0 = 0x0;
  51.         
  52.         /*UMCON:串口MODEM控制寄存器：用于流量控制
  53.         [7:5]=000,规定必须为0
  54.         [4]=0:禁止自动流控制(AFC)，即不使用流控。一般不使用这种硬件自动流控制手段。
  55.         [3:1]=000:规定必须为0
  56.         [0]=0:高电平(撤销nRTS),1:低电平(激活nRTS),因为,AFC位禁止,nRTS必须由软件控制。如果AFC使能，则忽略这个位。
  57.         */
  58.         rUMCON0 = 0x0;
  59.         
  60.         /*UBRDIV:波特率分频寄存器：用于设置波特率
  61.         [15:0],波特率分频值。使用UEXTCLK作为输入时钟时，可以设置UBRDIV为0.
  62.         UBRDIV = (int)(UART时钟/(波特率*16))-1
  63.         */
  64.         rUBRDIV0 = UART_BRD;
  65. }

  67. /*功能：向串口发送一个字符
  68. *参数：待发送的字符

  70. UTRSTAT0:用来表明数据是否已经发送完毕，是否已经接受到数据
  71. 串口收发TX/RX状态寄存器，是CPU自动更新的，程序员检测它的状态就行。
  72. [2]:发送移位寄存器空标志。
  73. 检测为0：表示发送移位寄存器非空，或发送缓冲寄存器非空。
  74. 检测为1：表示发送移位寄存器为空，且发送缓冲寄存器为空，程序员可以继续发送数据了。
  75. [1]:发送缓冲区空标志位。
  76. 检测为0：表示发送缓冲寄存器非空，即上次要发送的数据还没有发完。不能太快，否则会覆盖掉。
  77. 检测为1：表示发送缓冲寄存器为空，程序员可以继续发送数据了。(非FIFO模式，非请求中断，非DMA)
  78. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。
  79. [0]:接收缓冲器数据就绪标志位。
  80. 检测为0：表示接收缓冲器为空。
  81. 检测为1：表示接收缓冲器接收到有效数据，程序员可以取数据了。(非FIFO模式，非请求中断，非DMA)
  82. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

  84. UTXH0：串口发送缓冲寄存器
  85. [7:0]:串口要发送的数据
  86. */
  87. void uart_sendByte(int data)
  88. {
  89.     if(data == '\n')
  90.     {
  91.         while(!(rUTRSTAT0 &0x2));
  92.         WrUTXH0('\r'); /*回车不换行*/
  93.     }
  94.     /*等待，直到发送缓冲区中的数据已经全部发送出去
  95.     这里也可以检测UTRSTAT0[2]位*/
  96.     while(!(rUTRSTAT0 &0x2));
  97.     /*向UTXH0寄存器中写入数据，UART即自动将它发送出去
  98.     #define rUTXH0 (*(volatile unsigned char *)0x50000020)    //UART 0 Transmission Hold
  99.     #define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
  100.     所以：WrUTXH0(data); 相当于 rUTXH0 = data；
  101.     */
  102.     WrUTXH0(data);
  103. }

  105. /*功能：向串口打印一个字符串
  106. *参数：待打印的字符串
  107. */
  108. void uart_sendString(char *p)
  109. {
  110.     while(*p)
  111.         uart_sendByte(*p++);
  112. }

  114. /*功能：向串口打印一个字符的16进制格式
  115. *参数：待打印的字符
  116. * 数字0=0x30，数字9=0x39
  117. */
  118. void uart_sendByte_hex(unsigned long val)
  119. {
  120.     // val = 0x1234ABCD
  121.     unsigned long c;
  122.     int i = 0;
  123.     
  124.     uart_sendByte('0');
  125.     uart_sendByte('x');

  127.     for (i = 0; i < 8; i++)
  128.     {
  129.         c = (val >> ((7-i)*4)) & 0xf;
  130.         if((c >= 0) && (c <= 9))
  131.         {
  132.             c = '0' + c;
  133.         }
  134.         else if ((c >= 0xA) && (c <= 0xF))
  135.         {
  136.             c = 'A' + (c - 0xA);
  137.         }
  138.         uart_sendByte((int)c);
  139.     }
  140. }

  142. /*功能：从串口接受一个字符
  143. *返回值：接受到的字符

  145. UTRSTAT0: 串口收发TX/RX状态寄存器
  146. [0]:接收缓冲器数据就绪标志位。
  147. 0：接收缓冲器为空
  148. 1：接收缓冲器接收到有效数据(非FIFO模式，非请求中断，非DMA)
  149. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

  151. URXH0：串口接受缓冲寄存器
  152. [7:0]:串口接受到的数据
  153. */
  154. char uart_getch(void)
  155. {
  156.     /*等待，直到接受缓冲区中有数据*/
  157.     while(!(rUTRSTAT0 & 0x1));
  158.     /*直接读取URXH0寄存器，即可以获得接受到的数据
  159.     #define rURXH0 (*(volatile unsigned char *)0x50000024)    //UART 0 Receive buffer
  160.     #define RdURXH0() (*(volatile unsigned char *)0x50000024)
  161.     所以：return RdURXH0(); 相当于：return rURXH0；
  162.     */
  163.     return RdURXH0();
  164. }

  166. /*功能：从串口接受一个字符串
  167. *参数：输入的字符串
  168. */
  169. void uart_getString(char *string)
  170. {
  171.     char *string2 = string;
  172.     char c;
  173.     while((c=uart_getch()) != '\r')
  174.     {
  175.         if(c == '\b')
  176.         {
  177.             if((int)string2 < (int)string)
  178.             {
  179.                 //uart_printf("\b\b");
  180.                 string--;
  181.             }
  182.         }
  183.         else
  184.         {
  185.             *string++ = c;
  186.             uart_sendByte(c);
  187.         }
  188.     }
  189.     *string = '\0';
  190.     uart_sendByte('\n');
  191. }

  193. /***********************************************************************************/
  194. /*
  195. *功能：整型(int) 转化成 字符型(char)
  196. *注意：不用 % / 符号的话，只能正确打印:0...9的数字对应的字符'0'...'9'
  197. */
  198. void itoa(unsigned int n, char * buf)
  199. {
  200.     int i;

  202.     if(n < 10){
  203.         buf[0] = n + '0';
  204.         buf[1] = '\0';
  205.         return;
  206.     }
  207.     itoa(n / 10, buf);
  208.     
  209.     for(i=0; buf[i]!='\0'; i++);
  210.     
  211.     buf[i] = (n % 10) + '0';
  212.     
  213.     buf[i+1] = '\0';
  214. }

  216. /*
  217. *功能：16进制字(0x) 转化成 字符型(char)
  218. *注意：不用 % / 符号的话，只能正确打印，0...9..15的数字,对应的'0'...'9''A'...'F'
  219. *注意：由于编译问题，这个函数，暂时由uart_sendByte_hex()函数替代
  220. */
  221. void xtoa(unsigned int n, char * buf)
  222. {
  223.     int i;

  225.     if(n < 16)
  226.     {
  227.         if(n < 10)
  228.         {
  229.             buf[0] = n + '0';
  230.         }
  231.         else
  232.         {
  233.             buf[0] = n - 10 + 'a';
  234.         }
  235.         buf[1] = '\0';
  236.         return;
  237.     }
  238.     xtoa(n / 16, buf);
  239.     
  240.     for(i = 0; buf[i] != '\0'; i++);
  241.     
  242.     if((n % 16) < 10)
  243.     {
  244.         buf[i] = (n % 16) + '0';
  245.     }
  246.     else
  247.     {
  248.         buf[i] = (n % 16) - 10 + 'a';
  249.     }
  250.     buf[i + 1] = '\0';
  251. }

  253. /*******************************************************************************************
  254. 为了支持求余求模，需要:
  255. 1,修改makefile如下：增加libgcc的库
  256.     arm-linux-ld -Tuart.lds -o uart_elf $^ $(shell arm-linux-gcc -msoft-float -print-libgcc-file-name)
  257. 上面一句展开后，其实就是下面的一句：
  258. ##    arm-linux-ld -Tuart.lds -o uart_elf head.o init.o uart.o leds.o /home/wangxc/linux/toolchain/gcc-3.4.5-glibc-2.3.6/bin/../lib/gcc/arm-linux/3.4.5/libgcc.a
  259. 2,自己手写libgcc的库。
  260. 这个在uart3实现
  261. *******************************************************************************************/

  263. /*功能：向串口格式化打印一个字符串
  264. *参数：格式化的字符串
  265. *注意：由于求模求余的问题没有解决，所以这里%d输出时，只能输出0~9，10和10以上的不能输出
  266. */
  267. int uart_printf(const char *fmt, ...)
  268. {
  269.     int count = 0;
  270.     char c;
  271.     char *s;
  272.     int n;
  273.     char buf[65];
  274.     va_list ap;
  275.     
  276.     va_start(ap, fmt);
  277.     
  278.     while(*fmt != '\0')
  279.     {
  280.         if(*fmt == '%')
  281.         {
  282.             fmt++;
  283.             switch(*fmt)
  284.          {
  285.                 case 'd': /*整型*/
  286.                     n = va_arg(ap, int);
  287.                     if(n < 0)
  288.                     {
  289.                         //uputchar('-');
  290.                         uart_sendByte('-');
  291.                         n = -n;
  292.                     }    
  293.                     itoa(n, buf);
  294.                     //_uputs(buf);
  295.                     uart_sendString(buf);
  296.                     break;        
  297.                 case 'c': /*字符型*/
  298.                     c = va_arg(ap, int);
  299.                     uart_sendByte(c);
  300.                     break;
  301.                 case 'x': /*16进制*/
  302.                     n = va_arg(ap, int);
  303.                     //uart_sendByte_hex(n); /*由于求模求余编译有问题，所以用uart_sendByte_hex来替代下面的2行代码*/
  304.                     xtoa(n, buf);
  305.                     uart_sendString(buf);
  306.                     break;
  307.                 case 's': /*字符串*/
  308.                     s = va_arg(ap, char *);
  309.                     uart_sendString(s);
  310.                     break;
  311.                 case '%': /*输出%*/
  312.                     uart_sendByte('%');
  313.                     break;
  314.                 default:
  315.                     break;
  316.             }    
  317.         }
  318.         else
  319.         {
  320.             uart_sendByte(*fmt);
  321.             if(*fmt == '\n')
  322.             {
  323.                 //uart_sendByte('\r');
  324.             }
  325.         }
  326.         fmt++;
  327.     }

  329.     va_end(ap);

  331.     return count;
  332. }

  334. /*
  335. uart_printf("%s%s:[%s][%s][%s]\n", __DTAE__, __TIME__, __FILE__, __FUNCTION__, __LINE__);

  337. int WriteLog(const char *fmt, ...)
  338. {
  339.         return uart_printf(fmt);
  340. }

  342. */
uart.h文件

点击(此处)折叠或打开

  1. #ifndef _UART_H_
  2. #define _UART_H_

  4. /**************************************************************************/
  5. //串口相关寄存器
  6. #define rULCON0 (*(volatile unsigned *)0x50000000)
  7. #define rUCON0 (*(volatile unsigned *)0x50000004)
  8. #define rUFCON0 (*(volatile unsigned *)0x50000008)
  9. #define rUMCON0 (*(volatile unsigned *)0x5000000c)
  10. #define rUTRSTAT0 (*(volatile unsigned *)0x50000010)
  11. #define rUBRDIV0 (*(volatile unsigned *)0x50000028)

  13. #define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
  14. #define RdURXH0() (*(volatile unsigned char *)0x50000024)

  16. #define rGPHCON (*(volatile unsigned *)0x56000070)
  17. #define rGPHUP (*(volatile unsigned *)0x56000078)

  19. #define PCLK 50000000 // init.c中的clock_init函数设置PCLK为50MHz
  20. #define UART_CLK PCLK // UART0的时钟源设为PCLK
  21. #define UART_BAUD_RATE 115200 // 波特率
  22. #define UART_BRD ((UART_CLK / (UART_BAUD_RATE * 16)) - 1)

  24. typedef char * va_list;
  25. #define va_start(ap,p) (ap = (char *) (&(p)+1))
  26. #define va_arg(ap, type) ((type *) (ap += sizeof(type)))[-1]
  27. #define va_end(ap)

  29. void init_uart(void);
  30. void uart_sendByte(int data);
  31. void uart_sendString(char *p);
  32. void uart_sendByte_hex(unsigned long val);
  33. char uart_getch(void);
  34. void uart_getString(char *string);

  36. void itoa(unsigned int n, char * buf);
  37. void xtoa(unsigned int n, char * buf);
  38. int uart_printf(const char *fmt, ...);
  39. /**************************************************************************/

  41. #endif
uart.lds文件

点击(此处)折叠或打开

  1. SECTIONS {
  2.     . = 0x0;
  3.     .text : { *(.text) }
  4.     .rodata ALIGN(4) : {*(.rodata)}
  5.     .data ALIGN(4) : { *(.data) }
  6.     .bss ALIGN(4) : { *(.bss) *(COMMON) }
  7. }








阅读(748) | 评论(0) | 转发(0) |
0

上一篇：ADC裸机驱动代码

下一篇：MMU裸机驱动代码

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6