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

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

DSP编程

开发平台：

C/C++

mcp2510.c：源码内容
  1. #include <msp430x14x.h>
  2. #include "MCP2510.h"
  4. void Init_SPI (void);
  5. void Init_Port(void);
  6. void Init_CLK(void);
  7. void CS_Enable(void);
  8. void CS_Disable(void);
  10. void RessetMcp2510(void);
  11. int GetStatusMcp2510(void);
  12. void RtsMcp2510(char RTSn);
  13. void BitModiMcp2510(char addr,char mask,char data);
  14. void ReadMcp2510(int addr,int n,char outBuf[]);
  15. void WriteMcp2510(int addr,int n,char inBuf[]);
  16. void SetNormal(void);
  17. void IsSendComplete(int addr);
  18. void InitMcp2510(void);
  19. void SendMsg(int nDLC,char inBuf[]);
  20. int ReceiveMsg(char outBuf[]);
  24. int nTX0_Len;
  25. char nTX0_Flag;
  26. int nSend_TX0;
  27. char UART0_TX_BUF[26];
  28. int nRX0_Len_temp;
  30. int nRX0_Len;
  31. char nRX0_Flag;
  32. int nRev_UART0;
  33. char UART0_RX_BUF[26];
  35. char nRecID_Hi;
  36. char nRecID_Lo;
  38. void main(void)
  39. {
  40. char inBuf[8];
  41. char outBuf[8];
  42. int i;
  43. WDTCTL = WDTPW + WDTHOLD;   // 关闭看门狗
  44.         
  45.     _DINT(); // 关闭中断    
  46.     /////////////////////////////////
  47.     // 初始化
  48.     Init_CLK();
  49.     Init_Port();
  50. Init_SPI();
  51. nSend_TX0 = 0;
  52. nRecID_Hi = 0;
  53.     nRecID_Lo = 0;
  54. for(i = 0;i < 8;i++)
  55. {
  56. inBuf[i] = i;
  57. outBuf[i] = 0;
  58. }
  59. _EINT();
  60. for(;;)
  61. {
  62. ReceiveMsg(outBuf);
  63. SendMsg(8,inBuf);
  64. }
  65. }
  67. void Init_CLK(void)
  68. {
  69.     unsigned int i;
  70.     BCSCTL1 = 0X00; //将寄存器的内容清零
  71. //XT2震荡器开启
  72. //LFTX1工作在低频模式
  73. //ACLK的分频因子为1
  75.     do 
  76.     {
  77. IFG1 &= ~OFIFG; // 清除OSCFault标志
  78. for (i = 0x20; i > 0; i--);                
  79.     }
  80.     while ((IFG1 & OFIFG) == OFIFG); // 如果OSCFault =1   
  82.     BCSCTL2 = 0X00; //将寄存器的内容清零
  83.     BCSCTL2 += SELM1; //MCLK的时钟源为TX2CLK，分频因子为1
  84.     BCSCTL2 += SELS; //SMCLK的时钟源为TX2CLK，分频因子为1
  85. }
  86. void Init_SPI (void)
  87. {
  88. //SPI0模块允许     
  89. ME1 |= USPIE0; 
  90. //将寄存器的内容清零
  91.     U0CTL = 0X00;
  92.     //数据为8比特，选择SPI模式，单片机为主机模式
  93.     U0CTL |= CHAR + SYNC + MM;
  94. //将寄存器的内容清零
  95.     U0TCTL = 0X00;
  96.     // 时钟源为SMCLK，选择3线模式
  97.     U0TCTL = CKPH + SSEL1 + SSEL0 + STC; 
  98. //传输时钟为SMCLK / 4
  99.     UBR0_0 = 0X02;  
  100.     UBR1_0 = 0X00;
  101. //调整寄存器,没有调整
  102.     UMCTL_0 = 0X00;     
  103. //发送接收中断允许
  104. IE1 |= UTXIE0; 
  105. IE1 |= URXIE0; 
  106. }
  107. void Init_Port(void)
  108. {
  109.     //将P3口所有的管脚在初始化的时候设置为输入方式
  110.     P3DIR = 0;
  111.     //将P3口所有的管脚设置为一般I/O口
  112.     P3SEL = 0;
  113. //P3.1 P3.2 P3.3被分配为SPI口
  114.     P3SEL = BIT3 + BIT2 + BIT1;
  115. //P1.0作为输出管脚
  116. P1DIR |= BIT0;
  117. //P3.3作为输出管脚
  118. P3DIR |= BIT3;
  119. //P3.1作为输出管脚
  120. P3DIR |= BIT1;
  121. //P1.0 输出高电平，MCP2510不被选通
  122. P1OUT |= BIT0; 
  123.     return;
  124. }
  125. void CS_Enable(void)
  126. {
  127. //P1.0输出低电平
  128. P1OUT &=~(BIT0);
  129. return ;
  130. }
  131. void CS_Disable(void)
  132. {
  133. //P1.0输出高电平
  134. P1OUT|=BIT0;
  135. return ;
  136. }
  137. interrupt [UART0TX_VECTOR] void UART0_TX_ISR(void)
  138. {
  139.     if(nTX0_Len != 0)
  140.     {
  141. // 表示缓冲区里的数据没有发送完
  142.      nTX0_Flag = 0;     
  143.      TXBUF0 = UART0_TX_BUF[nSend_TX0];
  144.      nSend_TX0 += 1;   
  145.      if(nSend_TX0 >= nTX0_Len)
  146.      {
  147.          nSend_TX0 = 0;
  148.          nTX0_Len = 0;
  149.          nTX0_Flag = 1;
  150.      }
  151.     }
  152. }
  153. interrupt [UART0RX_VECTOR] void UART0_RX_ISR(void)
  154. {
  155. //接收来自的数据
  156.     UART0_RX_BUF[nRX0_Len_temp] = RXBUF0;
  157.     
  158.     nRX0_Len_temp += 1;
  159. if(nRX0_Len_temp >= nRX0_Len)
  160. {
  161.         nRev_UART0 = 1;
  162.      nRX0_Len_temp = 0;
  163. nRX0_Len = 0;
  164. }
  165. }
  167. void RessetMcp2510(void)
  168. {
  169. int i;
  170. CS_Enable();
  171. for(i = 10;i > 0;i--) ;
  172. //复位命令
  173.     UART0_TX_BUF[0] = (char)(0xC0);
  174.     nTX0_Len = 1;
  175.     // 设置中断标志，进入发送中断程序
  176.     IFG1 |= UTXIFG0;
  177. for(i = 100;i > 0;i--) ;
  178. CS_Disable();
  179. return;
  180. }
  181. int GetStatusMcp2510(void)
  182. {
  183. int i;
  184. int nStatus = 0;
  185. CS_Enable();
  186. for(i = 10;i > 0;i--) ;
  187. //读状态命令
  188.     UART0_TX_BUF[0] = 0xA0;
  189.     nTX0_Len = 1;
  190.     // 设置中断标志，进入发送中断程序
  191.     IFG1 |= UTXIFG0;
  193. nRX0_Len = 1;
  194. while(1)
  195. {
  196. if(nRev_UART0 == 1)
  197. {
  198. nRev_UART0 = 0;
  199.             nStatus = (int)(UART0_RX_BUF[0]);
  200. break;
  201. }
  202. }
  203. for(i = 100;i > 0;i--) ;
  204. CS_Disable();
  205. return nStatus;
  206. }
  207. void RtsMcp2510(char RTSn)
  208. {
  209. int i;
  210. CS_Enable();
  211. for(i = 10;i > 0;i--) ;
  212. //请求发送命令
  213. UART0_TX_BUF[0] = (char)(0x80 | RTSn);
  214.     nTX0_Len = 1;
  215.     // 设置中断标志，进入发送中断程序
  216.     IFG1 |= UTXIFG0;
  217. for(i = 100;i > 0;i--) ;
  218. CS_Disable();
  219. return;
  220. }
  221. void BitModiMcp2510(char addr,char mask,char data)
  222. {
  223. int i;
  224. CS_Enable();
  225. for(i = 10;i > 0;i--) ;
  226. //位修改送命令
  227. UART0_TX_BUF[0] = 0x05;
  228. UART0_TX_BUF[0] = addr;
  229. UART0_TX_BUF[0] = mask;
  230. UART0_TX_BUF[0] = data;
  231.     nTX0_Len = 4;
  232.     // 设置中断标志，进入发送中断程序
  233.     IFG1 |= UTXIFG0;
  234. for(i = 100;i > 0;i--) ;
  235. CS_Disable();
  236. return;
  237. }
  238. void ReadMcp2510(int addr,int n,char outBuf[])
  239. {
  240. int i;
  241. CS_Enable();
  242. for(i = 10;i > 0;i--) ;
  243. //读命令
  244. UART0_TX_BUF[0] = 0x03;
  245. UART0_TX_BUF[0] = addr;
  246. for(i = 0;i < n;i++)
  247. {
  248. UART0_TX_BUF[i + 2] = 0;
  249. }
  250.     nTX0_Len = 2 + n;
  251.     // 设置中断标志，进入发送中断程序
  252.     IFG1 |= UTXIFG0;
  253. //接收数据
  254.     nRX0_Len = n;
  255. while(1)
  256. {
  257. if(nRev_UART0 == 1)
  258. {
  259. nRev_UART0 = 0;
  260. for(i = 0;i < n;i++)
  261. {
  262. outBuf[i] = UART0_RX_BUF[i];
  263. }
  264. break;
  265. }
  266. }
  267. for(i = 100;i > 0;i--) ;
  268. CS_Disable();
  269. return;
  270. }
  271. void WriteMcp2510(int addr,int n,char inBuf[])
  272. {
  273. int i;
  274. CS_Enable();
  275. for(i = 10;i > 0;i--) ;
  276. //写命令
  277. UART0_TX_BUF[0] = 0x02;
  278. UART0_TX_BUF[0] = addr;
  279. for(i = 0;i < n;i++)
  280. {
  281. UART0_TX_BUF[i + 2] = inBuf[i];
  282. }
  283.     nTX0_Len = 2 + n;
  284.     // 设置中断标志，进入发送中断程序
  285.     IFG1 |= UTXIFG0;
  286. for(i = 100;i > 0;i--) ;
  287. CS_Disable();
  288. return;
  289. }
  290. void SetNormal(void)
  291. {
  292.     int nFlag = 1;
  293. int i;
  294. char outBuf[10];
  295. for(i = 0;i < 10;i++)
  296. {
  297. outBuf[i] = 0;
  298. }
  299. //设置成正常模式
  300. BitModiMcp2510(CANSTAT,0xe0,0x00);
  301. do
  302. {
  303.         ReadMcp2510(CANSTAT,1,outBuf);
  304. nFlag = outBuf[0] & 0xe0;
  305. }while(nFlag);
  307.     return;
  308. }
  309. void IsSendComplete(int addr)
  310. {
  311. int i;
  312. int nFlag = 1;
  313. char outBuf[10];
  314. for(i = 0;i < 10;i++)
  315. {
  316. outBuf[i] = 0;
  317. }
  319. do
  320. {
  321.         ReadMcp2510(addr,1,outBuf);
  322. nFlag = outBuf[0] & 0x08;
  323. }while(nFlag);
  324.     return;
  325. }
  326. void InitMcp2510(void)
  327. {
  328. char inBuf[10];
  329. //复位
  330. RessetMcp2510();
  331. //设置拨特率
  332. inBuf[0] = 0x02;
  333. inBuf[1] = 0x90;
  334. inBuf[2] = 0x07;
  335.     WriteMcp2510(CNF3,3,inBuf);
  336. //RX0接收，屏蔽位为0，过滤器为0
  337.     inBuf[0] = 0x00;
  338. inBuf[1] = 0x00;
  339.     WriteMcp2510(RXM0SIDH,2,inBuf);
  340. inBuf[0] = 0x00;
  341. inBuf[1] = 0x00;
  342.     WriteMcp2510(RXF0SIDH,2,inBuf);
  343. //CAN中断不使能
  344.     inBuf[0] = 0x00;
  345.     WriteMcp2510(CANINTE,1,inBuf);
  346. //设置成正常模式
  347. SetNormal();
  348. }
  349. void SendMsg(int nDLC,char inBuf[])
  350. {
  351. int i;
  352. char sndBuf[16];
  353. for(i = 0;i < nDLC;i++)
  354. {
  355. sndBuf[i] = inBuf[i];
  356. }
  357. WriteMcp2510(TXB0D0,nDLC,sndBuf);
  358.     sndBuf[0] = nDLC;
  359.     WriteMcp2510(TXB0DLC,1,sndBuf);
  360.     sndBuf[0] = 0x03;
  361. sndBuf[1] = nRecID_Hi;
  362. sndBuf[2] = nRecID_Lo;
  363.     WriteMcp2510(TXB0CTRL,3,sndBuf);
  364. RtsMcp2510(0x01);
  365. IsSendComplete(TXB0CTRL);
  366. return;
  367. }
  368. int ReceiveMsg(char outBuf[])
  369. {
  370. int i;
  371. int nFlag;
  372. int nDLC;
  373. char revBuf[16];
  374. for(i = 0;i < 16;i++)
  375. {
  376. revBuf[i] = 0;
  377. }
  378. ReadMcp2510(CANINTF,1,revBuf);
  379.     nFlag = revBuf[0] & 0x01;
  380. if(nFlag == 0)
  381. {
  382. return 0;
  383. }
  384. BitModiMcp2510(CANINTF,0x01,0x00);
  385. ReadMcp2510(TXB0SIDH,2,revBuf);
  386. nRecID_Hi = revBuf[0];
  387. nRecID_Lo = revBuf[1] & 0xe0;
  388. ReadMcp2510(RXB0DLC,1,revBuf);
  389.     nDLC = revBuf[0] & 0x0f;
  390.     ReadMcp2510(RXB0D0,nDLC,outBuf);
  391. return 1;
  392. }