开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
userlib.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：11k
源码类别：

uCOS

开发平台：

C/C++

userlib.c：源码内容
  1. #include <string.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include "def.h"
  5. #include "option.h"
  6. #include "2440addr.h"
  7. #include "2440lib.h"
  9. #include "userlib.h"
  12. /************************** Manual register setting *****************************/
  14. char sbuf[80], scmd1[20], scmd2[20], scmd3[20], scmd4[20];
  15. //char *sbuf, *scmd1, *scmd2, *scmd3, *scmd4;
  16. U32 cmd2, cmd3, cmd4;
  17. char pre_scmd[10][80];
  19. const void *command_set[][2] = {
  20. (void *)Memory_Dump, "dump",
  21. (void *)Multimem_Write, "mw",
  22. (void *)Halfword_Read, "hr",
  23. (void *)Halfword_Write, "hw",
  24. (void *)Halfword_Write_Multi, "hwm",
  25. (void *)Word_Write, "w",
  26. (void *)Word_Write_Or, "ow",
  27. (void *)Word_Read, "r",
  28. (void *)Fill_Memory, "fi",
  29. // Add the test function. add manset_Usage too.
  30. 0,0,0
  31. };
  33. void Manset_Usage(void)
  34. {
  35. int i;
  37. Uart_Printf("dump:memory dump(ex:dump addr length)n");
  38. Uart_Printf("mw:multiple write.n");
  39. Uart_Printf("hr:halfword read.n");
  40. Uart_Printf("hw:halfword write.n");
  41. Uart_Printf("hwm:halfword write multi.n");
  42. Uart_Printf("w:word write.n");
  43. Uart_Printf("ow:word write with OR logic.n");
  44. Uart_Printf("r:word read.n");
  45. Uart_Printf("fi:memory fill(ex:fi addr length value).n");
  46. Uart_Printf("P: execute previous command.n");
  48. }
  51. void Manual_Register_Set(void)
  52. {
  53. U32 i=0, j=0;
  55. Uart_Printf("Manual regiter set. (q)uit.n");
  56. Uart_Printf("Usage(?): >> <command> <opr1> (<opr2>)n");
  57. Manset_Usage();
  59. while (1) {
  60. Uart_Printf(">> ");
  61. Uart_GetString(sbuf);
  63. if(*sbuf==NULL) continue;
  64. else if(*sbuf=='P') Execute_Precmd();
  66. else if(*sbuf==ESC_KEY) break;
  67. else if(*sbuf==ESC_KEY) {
  68. Manset_Usage();
  69. } else {
  70. Get_Cmd(sbuf);
  72. for(i=0; (int)(command_set[i][0])!=NULL; i++) {
  73. if(!strcmp((command_set[i][1]), scmd1)) {
  74. ((void (*)(void)) (command_set[i][0]))();
  75. for(j=MAX_PRECMD_SIZE-1; j>0; j--) {
  76. //if((int)pre_scmd[j][0]==NULL) continue;
  77. strcpy(pre_scmd[j], pre_scmd[j-1]);
  78. }
  80. strcpy(pre_scmd[j], sbuf);
  81. break;
  82. }
  83. }
  84. } // end of if(*sbuf==NULL)...
  86. }
  88. }
  93. void Get_Cmd(char incmd[])
  94. {
  95. int cmd_level=0, i, j, overlap=0;
  97. scmd1[0]='';
  98. scmd2[0]='';
  99. scmd3[0]='';
  100. scmd4[0]='';
  102. for(j=0, i=0; incmd[i]!=NULL; i++) {
  103. if(incmd[i] != ' ' && incmd[i] != 0x09 && incmd[i] != ',') {
  104. overlap=0;
  105. switch(cmd_level) {
  106. case 0:
  107. scmd1[j] = incmd[i];
  108. scmd1[j+1]='';
  109. //if(DEBUG_LEVEL>0) Uart_Printf("(%c)", scmd1[j]);
  110. break;
  111. case 1:
  112. scmd2[j] = incmd[i];
  113. scmd2[j+1]='';
  114. //if(DEBUG_LEVEL>0) Uart_Printf("%c", scmd2[j]);
  115. break;
  116. case 2:
  117. scmd3[j] = incmd[i];
  118. scmd3[j+1]='';
  119. //if(DEBUG_LEVEL>0) Uart_Printf("[%c]", scmd3[j]);
  120. break;
  121. case 3:
  122. scmd4[j] = incmd[i];
  123. scmd4[j+1]='';
  124. //if(DEBUG_LEVEL>0) Uart_Printf("[%c]", cmd4[j]);
  125. break;
  127. }
  128. j++;
  129. } else {
  130. j=0;
  131. if(overlap==0) {
  132. cmd_level++;
  133. }
  134. overlap=1;
  135. }
  136. }
  138. // Make argument.
  139. cmd2 = Get_Num(scmd2); // atox(scmd2);
  140. cmd3 = Get_Num(scmd3); // : Character to hexa(decimal)
  141. cmd4 = Get_Num(scmd4); // : Character to hexa(decimal)
  143. if(cmd2==0xffffffff) cmd2=0;
  144. if(cmd3==0xffffffff) cmd3=0;
  145. if(cmd4==0xffffffff) cmd4=0;
  146. }
  148. U32 Get_Num(char *string)
  149. {
  150.     int base=10;
  151.     int minus=0;
  152.     int lastIndex;
  153.     int result=0;
  154.     int i;
  156.     if(string[0]=='-')
  157.     {
  158. minus=1;
  159. string++;
  160.     }
  162.     if(string[0]=='0' && (string[1]=='x' || string[1]=='X'))
  163.     {
  164. base=16;
  165. string+=2;
  166.     }
  168.     lastIndex=strlen(string)-1;
  169.     if(lastIndex<0)return -1;
  171.     if( string[lastIndex]=='h' || string[lastIndex]=='H' )
  172.     {
  173. base=16;
  174. string[lastIndex]=0;
  175. lastIndex--;
  176.     }
  178.     if(base==10)
  179.     {
  180. result=atoi(string);
  181. result=minus ? (-1*result):result;
  182.     }
  183.     else
  184.     {
  185. for(i=0;i<=lastIndex;i++)
  186. {
  187.     if(isalpha(string[i]))
  188.     {
  189. if(isupper(string[i]))
  190.     result=(result<<4)+string[i]-'A'+10;
  191. else
  192.     result=(result<<4)+string[i]-'a'+10;
  193.     }
  194.     else
  195.     {
  196. result=(result<<4)+string[i]-'0';
  197.     }
  198. }
  199. result=minus ? (-1*result):result;
  200.     }
  201.     return result;
  202. }
  206. void Execute_Precmd(void)
  207. {
  208. int cnt=0, i=0, cmd_sel=0, exec_cmd=1;
  209. char ch;
  211. for(i=0; i<MAX_PRECMD_SIZE && pre_scmd[i][0]!=NULL; i++) {
  212. Uart_Printf("%d: [%s]n", i, pre_scmd[i]);
  213. }
  214. if(i==0) return;
  215. Uart_Printf("select num(-1 to exit)? ");
  216. cmd_sel = Uart_GetIntNum();
  218. if(cmd_sel != -1) {
  219. Uart_Printf("n>> %s", pre_scmd[cmd_sel]);
  220. Uart_Printf("n");
  221. Get_Cmd(pre_scmd[cmd_sel]); // Make sbuf -> scmd...
  223. for(i=0; (int)(command_set[i][0])!=NULL; i++) {
  224. if(!strcmp((command_set[i][1]), scmd1)) {
  225. ((void (*)(void)) (command_set[i][0]))();
  226. break;
  227. }
  228. }
  229. }
  231. }
  233. void Uart_AppendString(char *string)
  234. {
  235.     char *string2 = string;
  236.     char c;
  238. string = (string + strlen(string));
  240.     while((c = Uart_Getch())!='r') {
  241.         if(c=='b') {
  242.             if( (int)string2 < (int)string ) {
  243.                 Uart_Printf("b b");
  244.                 string--;
  245.             }
  246.         } else {
  247.             *string++ = c;
  248.             Uart_SendByte(c);
  249.         }
  250.     }
  251.     *string='';
  252.     Uart_SendByte('n');
  253. }
  255. //================================================================
  256. void Memory_Dump(void)
  257. {
  258. int i;
  260. Uart_Printf("memory dumpn");
  261. for(i=0; i<cmd3; i+=4) {
  262. Uart_Printf("  %08xh: %08xhn", (cmd2+i), *(U32 *)(cmd2+i));
  263. if(Uart_GetKey()!=NULL) {
  264.   Uart_Printf("Break at %xn", cmd2+i);
  265.   break;
  266.   }
  267. }
  268. }
  270. void Multimem_Write(void)
  271. {
  272. U32 i, itmp;
  273. char tmps[20];
  275. if(cmd2%4) cmd2=(cmd2/4)*4;
  276. Uart_Printf("Multiple memory write (q)uit.n");
  278. for(i=0; ; ) {
  279. Uart_Printf("  %08xh ? ", cmd2+i);
  280. Uart_GetString(tmps);
  281. if(*tmps=='q') break;
  283. itmp = Get_Num(tmps);
  284.   if(itmp!=-1) *(U32 *)(cmd2+i) = itmp;
  286. i+=4;
  287. }
  288. }
  290. void Fill_Memory(void)
  291. {
  292. U32 i, itmp;
  293. char tmps[20];
  295. if(cmd2%4) cmd2=(cmd2/4)*4;
  296. Uart_Printf("Fill memory[%08xh - %08xh with %xh].n", cmd2, cmd2 + cmd3, cmd4);
  298. for(i=0; i<cmd3; i+=4) {
  299.   *(U32 *)(cmd2+i) = cmd4;
  300.   if(Uart_GetKey()!=NULL) {
  301.   Uart_Printf("Break at %xn", cmd2+i);
  302.   break;
  303.   }
  304. }
  306. }
  308. void Halfword_Read(void)
  309. {
  310. Uart_Printf("  [%08xh:%04xh]n", cmd2, *(U16 *)cmd2);
  311. }
  313. void Halfword_Write(void)
  314. {
  315. *(U16 *)cmd2 = (U16)cmd3;
  316. Uart_Printf("  [%08xh<-%04xh]n", cmd2, (U16)cmd3);
  317. }
  321. void Halfword_Write_Multi(void)
  322. {
  323. char *string;
  324. short int  indata;
  326. Uart_Printf("  Addr:%08xhn", cmd2);
  328. while(1) {
  329. Uart_Printf("  data: ");
  330. indata = Uart_GetIntNum();
  331. if(indata==-1) break;
  332. *(U16 *)cmd2 = indata;
  333. Uart_Printf("  [%08xh<-%04xh]n", cmd2, indata);
  334. }
  336. }
  338. void Word_Write(void)
  339. {
  340. if(cmd2%4) cmd2=(cmd2/4)*4;
  341. *(U32 *)cmd2 = (U32)cmd3;
  342. Uart_Printf("  [%08xh<-%08xh]n", cmd2, cmd3);
  344. }
  346. void Word_Write_Or(void)
  347. {
  348. if(cmd2%4) cmd2=(cmd2/4)*4;
  349. *(U32 *)cmd2 |= (U32)cmd3;
  350. Uart_Printf("  [%08xh |= %08xh]n", cmd2, cmd3);
  351. }
  353. void Word_Read(void)
  354. {
  355. if(cmd2%4) cmd2=(cmd2/4)*4;
  356. Uart_Printf("  [%08xh:%08xh]n", cmd2, *(U32 *)cmd2);
  357. }
  359. void user_delay(unsigned int cnt)
  360. {
  361. int i, j;
  363. for(j=0; j<cnt; j++)
  364. for(i=0; i<500; i++);
  365. }
  367. /***************************************************************************/
  369. /**************************** Clock calculation ********************************/
  370. // Clock calculation. Current clock information calc.
  371. // Register value : MPLLCON(Mdiv, Pdiv, Sdiv), CLKDIVN(Hdivn, Pdivn).
  372. // Hclk = Fclk/Hclk_Ratio, Pclk = Fclk/Hclk_Ratio/Pclk_Ratio.
  373. // Refresh count(Ref_Cnt) = 2048+1-(Hclk*7.8)
  374. void Calc_Clock(int print_msg);
  375. U32 Mdiv, Pdiv, Sdiv, Fclk, Hclk, Pclk, Hdivn, Pdivn, Hclk_Ratio, Pclk_Ratio, Ref_Cnt;
  377. // Register value : Mdiv, Pdiv, Sdiv, Hdivn, Pdivn.
  378. // Hclk = Fclk/Hclk_Ratio, Pclk = Fclk/Hclk_Ratio/Pclk_Ratio.
  380. #define LCDCLK (5000000) //5MHz
  381. void Calc_Clock(int print_msg)
  382. {
  383. unsigned int mpll_val, sval, lcd_clk_val, tmpi;
  385. // Get MPS value from register.
  386. mpll_val = rMPLLCON;
  387. Mdiv = (mpll_val&(0xff<<12))>>12;
  388. Pdiv = (mpll_val&(0x3f<<4))>>4;
  389. Sdiv = (mpll_val&0x3);
  391. // Get HDIVN, PDIVN value from register.
  392. Hdivn = ((rCLKDIVN&0x6)>>1);
  393. Pdivn = (rCLKDIVN&1);
  396. // Get the HCLK and PCLK ratio
  397. switch(Hdivn) {
  398. case 0: Hclk_Ratio=1; break;
  399. case 1: Hclk_Ratio=2; break;
  400. case 2: Hclk_Ratio=4; break;
  401. case 3: Hclk_Ratio=3; break;
  402. }
  403. switch(Pdivn) {
  404. case 0: Pclk_Ratio=1; break;
  405. case 1: Pclk_Ratio=2; break;
  406. }
  408. tmpi = rCAMDIVN&(3<<8);
  409. if(tmpi!=0) {
  410. if(Hclk_Ratio==3 || Hclk_Ratio==4)
  411. Hclk_Ratio *= 2;
  412. }
  414. // Get sval for calc Fout.
  415. //sval=(int)pow(2,Sdiv);
  416. switch(Sdiv) {
  417. case 0: sval = 1; break;
  418. case 1: sval = 2; break;
  419. case 2: sval = 4; break;
  420. case 3: sval = 8; break;
  421. default: sval = 0; break;
  422. }
  424. // Calc Fclk, Hclk, Pclk
  425. #if CPU2440A==TRUE
  426. Fclk=(U32)( (((float)Mdiv+8)*FIN*2.0)/( ((float)Pdiv+2)*(float)sval) ); // pll2188x.
  427. #else
  428. Fclk=(U32)( (((float)Mdiv+8)*FIN)/( ((float)Pdiv+2)*(float)sval) ); // pll2115x
  429. #endif
  431. Hclk =(U32)( ((float)Fclk/(float)Hclk_Ratio) );
  432. Pclk = (U32)( (((float)Fclk/(float)Hclk_Ratio)/(float)Pclk_Ratio));
  434. // Calc refresh count.
  435. Ref_Cnt = 2048+1-(U32)( (float)( ((float)Hclk*7.8)/MEGA) );
  437. Uart_TxEmpty(1);
  438. Uart_Init(Pclk, 115200);
  441. if(print_msg!=0) {
  442. Uart_Printf("MPLLVal [M:%xh(%d),P:%xh,S:%xh]n", Mdiv, Mdiv, Pdiv, Sdiv);
  443. Uart_Printf("F/H/PCLK=[1:%d:%d=", Hclk_Ratio, Hclk_Ratio*Pclk_Ratio);
  444. //Uart_Printf("%4.3f:%4.3f:%4.3f MHz]n", (float)Fclk/MEGA, (float)Hclk/MEGA, (float)Pclk/MEGA);
  445. Uart_Printf("%4.1f:%4.1f:%4.1f MHz]n", (float)Fclk/MEGA, (float)Hclk/MEGA, (float)Pclk/MEGA);
  446. Uart_Printf("Refcnt:%dn", Ref_Cnt);
  447. }
  449. lcd_clk_val = (Hclk/(2.0*LCDCLK)+0.5)-1;
  450. rLCDCON1 = (rLCDCON1 & ~(0x3ff<<8)) | lcd_clk_val<<8;
  451. //Uart_Printf("CLKVAL:%dn", lcd_clk_val);
  453. }
  454. /***************************************************************************/
  457. //*************************[ Ticker ]********************************
  458. unsigned int Init_Ticker(int divider)  //0:16us,1:32us 2:64us 3:128us
  459. {
  460. unsigned int Div_us;
  462.     rWTCON = ((Pclk/1000000-1)<<8)|(divider<<3);  //Watch-dog timer control register
  463.     rWTDAT = 0xffff;  //Watch-dog timer data register
  464.     rWTCNT = 0xffff;  //Watch-dog count register
  466. pISR_WDT_AC97=(int)Ticker_int;
  468. ClearPending(BIT_WDT_AC97);
  469. rSUBSRCPND=(BIT_SUB_WDT);
  471. rINTMSK&=~(BIT_WDT_AC97);
  472. rINTSUBMSK&=~(BIT_SUB_WDT);
  474. switch(divider) {
  475. case 0: Div_us=16; break;
  476. case 1: Div_us=32; break;
  477. case 2: Div_us=64; break;
  478. case 3: Div_us=128; break;
  479. default: Div_us=0; break;
  480. }
  482. return Div_us;
  483. }
  487. //=================================================================
  488. int Ticker_Stop(void)
  489. {
  490.     rWTCON = ((Pclk/1000000-1)<<8);
  491.     return (0xffff - rWTCNT);
  492. }
  494. static void __irq Ticker_int(void)
  495. {
  496. rINTSUBMSK|=(BIT_SUB_WDT); // Just for the safety
  498. rSUBSRCPND=(BIT_SUB_WDT); // Clear Sub int pending
  499. ClearPending(BIT_WDT_AC97); // Clear master pending
  501. Uart_Printf("Error: Ticker timer reaches 0.n");
  503. }