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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
nand.c
资源名称：msp430.rar　[点击查看]
上传用户：xs588588
上传日期：2021-03-30
资源大小：242k
文件大小：14k
源码类别：

DSP编程

开发平台：

C/C++

nand.c：源码内容
  1. #include <MSP430X14X.h>
  2. #include <stdio.h>
  3. #include "Nand.h"
  5. void Init_CLK(void);
  6. //全局变量
  7. extern int nSM_R_B;
  8. void SM_Port_Init(void)
  9. {
  10.     P4DIR = 0;
  11.     P4DIR |= BIT0;    //设置CLE为输出管脚
  12.     P4DIR |= BIT1;    //设置CE~为输出管脚
  13.     P4DIR |= BIT2;    //设置ALE为输出管脚
  14.     P4DIR |= BIT3;    //设置RE~为输出管脚
  15.     P4DIR |= BIT4;    //设置WE~为输出管脚
  16.     P1DIR &= ~(BIT1); //设置R/B为输入管脚
  17.     return;
  18. }
  19. void CLE_Enable(void)
  20. {
  21.     P4OUT |= BIT0;
  22.     return;
  23. }
  24. void CLE_Disable(void)
  25. {
  26.     P4OUT &= ~(BIT0);
  27.     return;
  28. }
  29. void CE_Enable(void)
  30. {
  31.     P4OUT &= ~(BIT1);
  32.     return;
  33. }
  34. void CE_Disable(void)
  35. {
  36.     P4OUT |= BIT1;
  37.     return;
  38. }
  39. void ALE_Enable(void)
  40. {
  41.     P4OUT |= BIT2;
  42.     return;
  43. }
  44. void ALE_Disable(void)
  45. {
  46.     P4OUT &= ~(BIT2);
  47.     return;
  48. }
  49. void WE_Enable(void)
  50. {
  51.     P4OUT &= ~(BIT4);
  52.     return;
  53. }
  54. void WE_Disable(void)
  55. {
  56.     P4OUT |= BIT4;
  57.     return;
  58. }
  59. void RE_Enable(void)
  60. {
  61.     P4OUT &= ~(BIT3);
  62.     return;
  63. }
  64. void RE_Disable(void)
  65. {
  66.     P4OUT |= BIT3;
  67.     return;
  68. }
  69. int GetSMStatus(void)
  70. {
  71.     int nTemp = 0;
  72.     return nTemp;
  73. }
  74. ////////////////////////////////////////
  75. // 正确返回 1，错误返回 0
  76. int PageWrite(int nCol,unsigned long nRow,char *pBuf)
  77. {
  78.     int nTemp = 0;
  79.     int i;
  80.     int j;
  81.     unsigned nADD1;
  82.     unsigned nADD2;
  83.     unsigned nADD3;
  84.     
  85.     nADD1 = nRow & 0x00ff;
  86.     nADD2 = (nRow >> 8) &0x00ff;
  87.     nADD3 = (nRow >> 16) & 0x00ff; //处理最高地址的时候必须注意的是其余没有用的位必须是 0
  88.     
  89.     CE_Enable();
  90.     
  91.     P5DIR = 0xff; //设置P5口为输出方向
  92.     
  93.     CLE_Enable();
  94.     WE_Enable();
  95.     P5OUT = 0x80; //页写命令
  96.     WE_Disable();
  97.     CLE_Disable();
  98.     
  99.     ALE_Enable();
  100.     WE_Enable();
  101.     P5OUT = (unsigned char)(nCol); // 行的起始地址
  102.     WE_Disable();
  103.     //for(i = 3;i > 0;i--);
  104.     WE_Enable();
  105.     P5OUT = nADD1;
  106.     WE_Disable();
  107.     //for(i = 3;i > 0;i--);
  108.     WE_Enable();
  109.     P5OUT = nADD2;
  110.     WE_Disable();
  111.     //for(i = 3;i > 0;i--);
  112.     WE_Enable();
  113.     P5OUT = nADD3;
  114.     WE_Disable();
  115.     ALE_Disable();
  116.     
  117.     //WE_Enable();
  118.     for(j = 0;j < 528;j++)
  119.     {
  120.      WE_Enable();
  121.      P5OUT = pBuf[j];
  122.      //for(i = 3;i > 0;i--);
  123.      WE_Disable();
  124.     }
  125.     //WE_Disable();
  126.     
  127.     CLE_Enable();
  128.     WE_Enable();
  129.     P5OUT = 0x10;
  130.     WE_Disable();
  131.     CLE_Disable();
  132.     
  133.     //等待R/B中断
  134.     //while(!nSM_R_B) ;
  135.     //nSM_R_B = 0;
  136.     for(i = 100;i > 0;i--);
  137.     
  138.     CLE_Enable();
  139.     WE_Enable();
  140.     P5OUT = 0x70;
  141.     WE_Disable();
  142.     CLE_Disable();
  143.     
  144.     P5DIR = 0x00; //设置P5口为输入方向
  145.     for(i = 1000;i > 0;i--)
  146.     {
  147.      RE_Enable();
  148.      nTemp = P5IN;
  149.      RE_Disable();
  150.      if(nTemp == 0xc0) break;
  151.     }
  152.     
  153.     if(nTemp == 0xc0) return 1;
  154.     else return 0;
  155. }
  156. ////////////////////////////////////////
  157. // 正确返回 1，错误返回 0
  158. int WriteByte(int nCommand,int nCol,unsigned long nRow,char nValue)
  159. {
  160.     int nTemp = 0;
  161.     int i;
  162.     unsigned nADD1;
  163.     unsigned nADD2;
  164.     unsigned nADD3;
  165.     
  166.     nADD1 = nRow & 0x00ff;
  167.     nADD2 = (nRow >> 8) &0x00ff;
  168.     nADD3 = (nRow >> 16) & 0x00ff; //处理最高地址的时候必须注意的是其余没有用的位必须是 0
  169.     
  170.     CE_Enable();
  171.     
  172.     P5DIR = 0xff; //设置P5口为输出方向
  173.     CLE_Enable();
  174.     WE_Enable();
  175.     P5OUT = (unsigned char)(nCommand); //指针
  176.     WE_Disable();
  177.     CLE_Disable();
  178.     
  179.     CLE_Enable();
  180.     WE_Enable();
  181.     P5OUT = 0x80; //页写命令
  182.     WE_Disable();
  183.     CLE_Disable();
  184.     
  185.     ALE_Enable();
  186.     WE_Enable();
  187.     P5OUT = (unsigned char)(nCol); // 行的起始地址
  188.     WE_Disable();
  189.     //for(i = 3;i > 0;i--);
  190.     WE_Enable();
  191.     P5OUT = nADD1;
  192.     WE_Disable();
  193.     //for(i = 3;i > 0;i--);
  194.     WE_Enable();
  195.     P5OUT = nADD2;
  196.     WE_Disable();
  197.     //for(i = 3;i > 0;i--);
  198.     WE_Enable();
  199.     P5OUT = nADD3;
  200.     WE_Disable();
  201.     ALE_Disable();
  202.   
  203.     WE_Enable();
  204.     P5OUT = nValue;
  205.     WE_Disable();
  206.     
  207.     
  208.     CLE_Enable();
  209.     WE_Enable();
  210.     P5OUT = 0x10;
  211.     WE_Disable();
  212.     CLE_Disable();
  213.     
  214.     //等待R/B中断
  215.     //while(!nSM_R_B) ;
  216.     //nSM_R_B = 0;
  217.     for(i = 100;i > 0;i--);
  218.     
  219.     CLE_Enable();
  220.     WE_Enable();
  221.     P5OUT = 0x70;
  222.     WE_Disable();
  223.     CLE_Disable();
  224.     
  225.     P5DIR = 0x00; //设置P5口为输入方向
  226.     for(i = 1000;i > 0;i--)
  227.     {
  228.      RE_Enable();
  229.      nTemp = P5IN;
  230.      RE_Disable();
  231.      if(nTemp == 0xc0) break;
  232.     }
  233.     //printf("SM Write: nTemp = %x ,",nTemp);
  234.     if(nTemp == 0xc0) return 1;
  235.     else return 0;
  236. }
  237. ////////////////////////////////////////
  238. // 正确返回 1，错误返回 0
  239. char ReadByte(int nCommand,int nCol,unsigned long nRow)
  240. {
  241.     int i;
  242.     char chrLow = 0;
  243.     unsigned char nADD1;
  244.     unsigned char nADD2;
  245.     unsigned char nADD3;
  246.     
  247.     nADD1 = nRow & 0x00ff;
  248.     nADD2 = (nRow >> 8) & 0x00ff;
  249.     nADD2 = (nRow >> 16) & 0x00ff;
  250.     
  251.     CE_Enable();
  252.     
  253.     P5DIR = 0xff; //设置P5口为输出方向
  254.     
  255.     CLE_Enable();
  256.     WE_Enable();
  257.     P5OUT = (unsigned char)(nCommand); //输出读命令代码;
  258.     WE_Disable();
  259.     CLE_Disable();
  260.     
  261.     ALE_Enable();
  262.     WE_Enable();
  263.     P5OUT = (unsigned char)(nCol);
  264.     WE_Disable();
  265.     //for(i = 3;i > 0;i--);
  266.     WE_Enable();
  267.     P5OUT = (unsigned char)(nADD1);
  268.     WE_Disable();
  269.     //for(i = 3;i > 0;i--);
  270.     WE_Enable();
  271.     P5OUT = (unsigned char)(nADD2);
  272.     WE_Disable();
  273.     //for(i = 3;i > 0;i--);
  274.     WE_Enable();
  275.     P5OUT = (unsigned char)(nADD3);
  276.     WE_Disable();
  277.     ALE_Disable();
  278.     
  279.     //等待R/B中断
  280.     //while(!nSM_R_B) ;
  281.     //nSM_R_B = 0;
  282.     for(i = 100;i > 0;i--);
  283.     
  284.     P5DIR = 0; //设置P5口为输入方向
  286.     RE_Enable();
  287.     chrLow = P5IN;
  288.     RE_Disable();
  289.     
  290.     CE_Disable();
  291.     return chrLow;
  292. }
  294. ////////////////////////////////////////
  295. // 正确返回 1，错误返回 0
  296. int PageRead(int nCol,unsigned long nRow,char *pBuf)
  297. {
  298.     int nTemp = 0;
  299.     int i;
  300.     int j;
  301.     unsigned char nADD1;
  302.     unsigned char nADD2;
  303.     unsigned char nADD3;
  304.     
  305.     nADD1 = nRow & 0x00ff;
  306.     nADD2 = (nRow >> 8) & 0x00ff;
  307.     nADD2 = (nRow >> 16) & 0x00ff;
  308.     
  309.     CE_Enable();
  310.     
  311.     P5DIR = 0xff; //设置P5口为输出方向
  312.     
  313.     CLE_Enable();
  314.     WE_Enable();
  315.     P5OUT = 0x00; //输出读命令代码 0x00;
  316.     WE_Disable();
  317.     CLE_Disable();
  318.     
  319.     ALE_Enable();
  320.     WE_Enable();
  321.     P5OUT = (unsigned char)(nCol);
  322.     WE_Disable();
  323.     //for(i = 3;i > 0;i--);
  324.     WE_Enable();
  325.     P5OUT = (unsigned char)(nADD1);
  326.     WE_Disable();
  327.     //for(i = 3;i > 0;i--);
  328.     WE_Enable();
  329.     P5OUT = (unsigned char)(nADD2);
  330.     WE_Disable();
  331.     //for(i = 3;i > 0;i--);
  332.     WE_Enable();
  333.     P5OUT = (unsigned char)(nADD3);
  334.     WE_Disable();
  335.     ALE_Disable();
  336.     
  337.     //等待R/B中断
  338.     //while(!nSM_R_B) ;
  339.     //nSM_R_B = 0;
  340.     for(i = 100;i > 0;i--);
  341.     
  342.     P5DIR = 0; //设置P5口为输入方向
  343.     //RE_Enable();
  344.     for(j = 0;j < 528;j++)
  345.     {
  346.      RE_Enable();
  347.      pBuf[j] = P5IN;
  348.      //for(i = 3;i > 0;i--); //是否需要延时
  349.      RE_Disable();
  350.     }
  351.     //RE_Disable();
  352.     
  353.     CE_Disable();
  354.     return nTemp;
  355. }
  356. ////////////////////////////////////////
  357. // 正确返回 1，错误返回 0
  358. int ReadID(unsigned char pBuf[2])
  359. {
  360.     int nTemp = 0;
  361.     int nMaker = 0;
  362.     int nDevice = 0;
  363. //    int nUniqueID = 0;
  364. //    int nPlaneCode = 0;
  365.     CE_Enable(); // 使能片选信号
  366.     ALE_Disable();
  367.     CLE_Disable();
  368.     RE_Disable();
  369.     WE_Disable();
  370.     P5DIR = 0XFF; // 设置P5口为输出方向
  371.     
  372.     CLE_Enable();
  373.     //for(i = 3;i > 0;i--);
  374.     WE_Enable();
  375.     //for(i = 5;i > 0;i--);
  376.     P5OUT = 0x90; // 输出命令代码 0x90
  377.     WE_Disable();
  378.     CLE_Disable();
  379.     
  380.     ALE_Enable();
  381.     //for(i = 3;i > 0;i--);
  382.     WE_Enable();
  383.     //for(i = 5;i > 0;i--);
  384.     P5OUT = 0x00; // 地址周期
  385.     WE_Disable();
  386.     ALE_Disable();
  387.     
  388.     P5DIR = 0x00; // 设置P5口为输入方向
  389.     
  390.     RE_Enable();
  391.     nMaker = P5IN;
  392.     RE_Disable();
  393.     
  394.     RE_Enable();
  395.     nDevice = P5IN;
  396.     RE_Disable();
  397.     //RE_Enable();
  398.     //nUniqueID = P5IN;
  399.     //RE_Disable();
  400.     //RE_Enable();
  401.     //nPlaneCode = P5IN;
  402.     //RE_Disable();
  403.     
  404.     CE_Disable();
  405.     
  406.     if(nMaker == 0xec)
  407.     {
  408.      if(nDevice == 0x76 || nDevice == 0x79)
  409.      {
  410.          nTemp = 1;
  411.          pBuf[0] = (unsigned char)(nMaker);
  412.          pBuf[1] = (unsigned char)(nDevice);
  413.      }
  414.     }
  415.     return nTemp;
  416. }
  417. /////////////////////////////////////////
  418. //成功返回 1，错误返回 0
  419. int BlockErase(unsigned long nAddr)
  420. {
  421.     int nTemp = 0;
  422.     int i;
  423.     unsigned char nADD1;
  424.     unsigned char nADD2;
  425.     unsigned char nADD3;
  426.     
  427.     nADD1 = nAddr & 0x00ff;
  428.     nADD2 = (nAddr >> 8) & 0x00ff;
  429.     nADD3 = (nAddr >> 16) & 0x00ff;
  430.     
  431.     CE_Enable();
  432.     
  433.     P5DIR = 0xff; //设置P5口为输出方向
  434.     
  435.     CLE_Enable();
  436.     WE_Enable();
  437.     P5OUT = 0x60; //输出块擦出命令
  438.     WE_Disable();
  439.     CLE_Disable();
  440.     
  441.     ALE_Enable();
  442.     WE_Enable();
  443.     P5OUT = (unsigned char)(nADD1);
  444.     WE_Disable();
  445.     //for(i = 3;i > 0;i--);
  446.     WE_Enable();
  447.     P5OUT = (unsigned char)(nADD2);
  448.     WE_Disable();
  449.     //for(i = 3;i > 0;i--);
  450.     WE_Enable();
  451.     P5OUT = (unsigned char)(nADD3);
  452.     WE_Disable();
  453.     ALE_Disable();
  454.     
  455.     CLE_Enable();
  456.     WE_Enable();
  457.     P5OUT = 0xd0;
  458.     WE_Disable();
  459.     CLE_Disable();
  460.     
  461.     //等待R/B中断
  462.     //while(!nSM_R_B);
  463.     //nSM_R_B = 0;
  464.     for(i = 200;i > 0;i--);
  465.     
  466.     //CLE_Enable();
  467.     //WE_Enable();
  468.     //P5OUT = 0x70;
  469.     //WE_Disable();
  470.     //CLE_Disable();
  471.     
  472.     P5DIR = 0; //设置P5口为输入方向
  473.     
  474.     RE_Enable();
  475.     nTemp = P5IN;
  476.     RE_Disable();
  477.     
  478.     CE_Disable();
  479.     //printf("SM: nTemp = %x ,",nTemp);
  480.     if(nTemp & 0x01) return 0;
  481.     else return 1;
  482. }
  483. /////////////////////////////////////////////
  484. // 正确返回 1，错误返回 0
  485. int VerifyValid(unsigned long nAddr)
  486. {
  487.     int j;
  488.     int buf;
  489.     //char pBuf[528];
  490.     
  491.     for(j = 0;j < 32;j++)
  492.     {
  493.         buf = ReadByte(0x50,5,(nAddr + j));
  494.         
  495.         //printf("SM: buf = %x ,j = %d",buf,j);
  496.         if(buf != 0x00ff) break;
  497.         
  498.     }
  499.     if(buf != 0x00ff) return 0;
  500.     else return 1;
  501. }
  502. void ResetSM(void)
  503. {  
  504.     int i;
  505.     CE_Enable();
  506.     
  507.     P5DIR = 0xff; // 设置P5口为输出方向
  508.     
  509.     CLE_Enable();
  510.     WE_Enable();
  511.     P5OUT = 0xff; // 输出RESET控制命令
  512.     WE_Disable();
  513.     CLE_Disable();
  514.     
  515.     //while(!nSM_R_B);
  516.     //nSM_R_B = 0;
  517.     for(i = 100;i > 0;i--);
  518.     
  519.     CE_Disable();
  520.     
  521.     return;
  522. }
  523. ////////////////////////////////////////
  524. // 正确返回 1，错误返回 0
  525. int BlockRead(unsigned long nAddr,char pBuf[32][528])
  526. {
  527.     int i,j;
  528.     int n;
  529.     unsigned char nADD1;
  530.     unsigned char nADD2;
  531.     unsigned char nADD3;
  532.     
  533.     nADD1 = nAddr & 0x00ff;
  534.     nADD2 = (nAddr >> 8) & 0x00ff;
  535.     nADD3 = (nAddr >> 16) & 0x00ff;
  536.     
  537.     CE_Enable();
  538.     
  539.     P5DIR = 0xff; // 将P5口设置为输出方向
  540.     for(i = nADD1;i < nADD1 + 32;i++)
  541.     {
  542.      ResetSM();
  543.     
  544.      CLE_Enable();
  545.      WE_Enable();
  546.      P5OUT = 0x00;
  547.      WE_Disable();
  548.      CLE_Disable();
  549.     
  550.      ALE_Enable();
  551.      WE_Enable();
  552.      P5OUT = 0x00;
  553.      WE_Disable();
  554.     
  555.      WE_Enable();
  556.      P5OUT = (unsigned char)(i);
  557.      WE_Disable();
  558.     
  559.      WE_Enable();
  560.      P5OUT = (unsigned char)(nADD2);
  561.      WE_Disable();
  562.     
  563.      WE_Enable();
  564.      P5OUT = (unsigned char)(nADD3);
  565.      WE_Disable();
  566.      ALE_Disable();
  567.     
  568.      //while(!nSM_R_B);
  569.      //nSM_R_B = 0;
  570.      for(n = 100;n > 0;n--);
  571.     
  572.      P5DIR = 0x00; // 将P5口设置为输入方向
  573.      for(j = 0;j < 528;j++)
  574.      {
  575.          RE_Enable();
  576.          pBuf[i][j] = P5IN;
  577.          RE_Disable();
  578.      }
  579.     }
  580.     
  581.     CE_Disable();
  582.     
  583.     
  584.     return 1;
  585. }
  586. ////////////////////////////////////////
  587. // 正确返回 1，错误返回 0
  588. int CopyToFlash(unsigned long nAddr)
  589. {
  590.     return 1;
  591. }
  592. ////////////////////////////////////////
  593. // 正确返回 1，错误返回 0
  594. int RealTimeBadMark(unsigned long nAddr)
  595. {
  596.     int i;
  597.     int rg_stat;
  599.     for(i = 0;i < 32;i++)
  600.     {
  601.      rg_stat = WriteByte(0x50,5,nAddr + i,0x00f0);
  602.      //printf("rg_stat = %x i = %d",rg_stat,i);
  603.      if((rg_stat & 0x01) != 0) return 0;
  604.     }
  605.     
  606.     ResetSM();
  608.     return 1;
  609. }
  610. int main(void)
  611. {
  612.     unsigned long nAddr;
  613.     int j;
  614.     int n;
  615.     int nTemp;
  616.     char pBuf0[528];
  617.     char pBuf1[528];
  618.     int nCount_Err;
  619.     int nLen;
  620.     // 关闭看门狗
  621.     WDTCTL = WDTPW + WDTHOLD;   
  622.     // 关闭中断
  623.     _DINT();                   
  624.     
  625.     // 初始化
  626.     Init_CLK();
  627.     SM_Port_Init();
  628.     // 打开中断
  629.     _EINT();                
  630.     
  631.     // 擦除块地址为1024的块
  632.     nAddr = 1024;
  633.     BlockErase(nAddr);
  634.     // 延迟一点时间
  635.     for(j = 1000;j > 0;j--) ;
  636.     // 判断擦除的块是否为0xFF,起始页地址为1024
  637.     for(j = 0;j < 528;j++) pBuf0[j] = j;
  638.     // 按页写入数据，地址为：1024
  639.     PageWrite(0,1024,pBuf0);
  640.     // 延迟一点时间
  641.     for(j = 1000;j > 0;j--) ;
  642.     //按页读操作
  643.     PageRead(0,1024,pBuf1);
  644.     //比较读出数据和写入数据是否相等
  645.     nCount_Err = 0;
  646.     for(j = 0;j < 528;j++)
  647.     {
  648.      if(pBuf0[j] != pBuf1[j])
  649.      {
  650.          nCount_Err += 1;
  651.          break;
  652.      }    
  653.     }
  654.     
  655.     return 0;
  656. }
  657. void Init_CLK(void)
  658. {
  659.     unsigned int i;
  660.     BCSCTL1 = 0X00; //将寄存器的内容清零
  661. //XT2震荡器开启
  662. //LFTX1工作在低频模式
  663. //ACLK的分频因子为1
  665.     do 
  666.     {
  667. IFG1 &= ~OFIFG;                       // 清除OSCFault标志
  668. for (i = 0x20; i > 0; i--);                
  669.     }
  670.     while ((IFG1 & OFIFG) == OFIFG);      // 如果OSCFault =1   
  672.     BCSCTL2 = 0X00; //将寄存器的内容清零
  673.     BCSCTL2 += SELM1; //MCLK的时钟源为TX2CLK，分频因子为1
  674.     BCSCTL2 += SELS; //SMCLK的时钟源为TX2CLK，分频因子为1
  675. }