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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
Test_MCP2510.c
资源名称：src.rar　[点击查看]
上传用户：jankzhpno
上传日期：2022-08-03
资源大小：4763k
文件大小：21k
源码类别：

Windows CE

开发平台：

Visual C++

Test_MCP2510.c：源码内容
  1. /****************************************************************************
  2. 【文  件  名  称】Test_MCP2510.C
  3. 【功  能  描  述】三星S3C2410A板demo程序代码
  4. 【程  序  版  本】4.0
  5. 【创建人及创建日期】龚俊( gongjun98@sohu.com )//2002年11月19日19:26
  6. 【修改人及修改日期】龚俊( gongjun98@sohu.com )//2004-12-8 17:25
  7. ****************************************************************************/
  9. //***************************************************************************
  10. #include "def.h"
  11. #include "option.h"
  12. #include "2440addr.h"
  13. #include "2440lib.h"
  14. #include "2440slib.h" 
  15. #include "MCP2510.h"
  18. /****************************************************************************
  19. MCP2510_CS GPG2 output ( nSS0 )
  20. MCP2510_SI GPE12 output ( SPIMOSI0 )
  21. MCP2510_SO GPE11 input ( SPIMISO0 )
  22. MCP2510_SCK GPE13 output ( SPICLK0 )
  23. MCP2510_INT GPG0 input ( EINT8 )
  24. ****************************************************************************/
  25. #define MCP2510_DEBUG    1
  26. #define DELAY_TIME 500
  28. #define MCP2510_CS_OUT ( rGPGCON = rGPGCON & (~(3<<4)) | (1<<4) ) //GPG2
  29. #define MCP2510_CS_H ( rGPGDAT = rGPGDAT | (1<<2) )
  30. #define MCP2510_CS_L ( rGPGDAT = rGPGDAT & (~(1<<2))  )
  32. #define MCP2510_SI_OUT ( rGPECON = rGPECON & (~(3<<24)) | (1<<24) ) //GPE12
  33. #define MCP2510_SI_H ( rGPEDAT = rGPEDAT | (1<<12) )
  34. #define MCP2510_SI_L ( rGPEDAT = rGPEDAT & (~(1<<12)) )
  36. #define MCP2510_SCK_OUT ( rGPECON = rGPECON & (~(3<<26)) | (1<<26) ) //GPE13
  37. #define MCP2510_SCK_H ( rGPEDAT = rGPEDAT | (1<<13) )
  38. #define MCP2510_SCK_L ( rGPEDAT = rGPEDAT & (~(1<<13)) )
  40. #define MCP2510_SO_IN ( rGPECON = rGPECON & (~(3<<22)) | (0<<22) ) //GPE11
  41. #define MCP2510_SO_GET ( rGPEDAT & (1<<11) )
  42. #define MCP2510_SO_PULLUP ( rGPEUP = rGPEUP & (~(1<<11)) )
  43. #define MCP2510_SO_DISPULLUP ( rGPEUP = rGPEUP | (1<<11) )
  45. #define MCP2510_INT_IN ( rGPGCON = rGPGCON & (~(3<<0)) ) //GPG0
  46. #define MCP2510_INT_GET ( rGPGDAT & 0x01 )
  47. /********************** MCP2510 Instruction *********************************/
  48. #define MCP2510INSTR_RESET 0xc0 //复位为缺省状态，并设定为配置模式
  49. #define MCP2510INSTR_READ 0x03 //从寄存器中读出数据
  50. #define MCP2510INSTR_WRITE 0x02 //向寄存器写入数据
  51. #define MCP2510INSTR_RTS 0x80 //启动一个或多个发送缓冲器的报文发送
  52. #define MCP2510INSTR_RDSTAT 0xa0 //读取状态
  53. #define MCP2510INSTR_BITMDFY 0x05 //位修改
  54. //***************************************************************************
  56. /****************************************************************************
  57. 【功能说明】SPI接口IO片选初始化
  58. ****************************************************************************/
  59. void MCP2510_IO_CS_Init( void ) 
  60. {
  61.    MCP2510_CS_OUT ;
  62.    MCP2510_SI_OUT ;
  63.    MCP2510_SCK_OUT ;
  64.    MCP2510_SO_IN ;
  65.    MCP2510_SO_PULLUP ; //允许上拉
  66.    //MCP2510_SO_DISPULLUP ; //禁止上拉
  68.    MCP2510_SI_L ; //SI put 0
  69.    MCP2510_SCK_L ; //SCK put 0
  70.    { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  71.    MCP2510_CS_H ; // unselect the MCP2510
  72.    { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  73. }
  75. /****************************************************************************
  76. 【功能说明】SPI接口读写开始，片选有效
  77. ****************************************************************************/
  78. void MCP2510_RW_Start( void ) 
  79. {
  80.    MCP2510_SI_L ; //SI put 0
  81.    MCP2510_SCK_L ; //SCK put 0
  82.    { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  83.    MCP2510_CS_L ; // Select the MCP2510
  84.    { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  85. }
  87. /****************************************************************************
  88. 【功能说明】SPI接口写入数据
  89. ****************************************************************************/
  90. void Spi_Write( U8 Data ) 
  91. {
  92. U8 m ;
  94. for( m = 0; m < 8; m++ )
  95. {
  96. if( (Data&0x80)==0x80 )
  97. MCP2510_SI_H; //SI put 1
  98. else
  99. MCP2510_SI_L; //SI put 0
  101. { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  102. MCP2510_SCK_H ; //SCK put 1
  103. Data = Data<<1 ;
  104. MCP2510_SCK_L ; //SCK put 0
  105. { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  106. }
  107. }
  109. /****************************************************************************
  110. 【功能说明】SPI接口读出数据
  111. ****************************************************************************/
  112. U8 Spi_Read( )
  113. {
  114. U8 m ;
  115. U8 data = 0 ;
  117. for( m = 0; m < 8; m++ )
  118. {
  119. MCP2510_SCK_H ; //SCK put 1
  120. { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  121. data = data<<1;
  122. if( MCP2510_SO_GET != 0 )
  123. data |= 0x01 ;
  124. else
  125. data &= 0xfe;
  127. { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  128. MCP2510_SCK_L ; //SCK put 0
  129. { U16 k=0; for( ; k <= DELAY_TIME; k++ ) ;  }  //延时至少300ns
  130. }
  132. return (data);
  133. }
  135. /****************************************************************************
  136. 【功能说明】 Send Command to MCP2510 via SPI 
  137. ****************************************************************************/
  138. void SendCMDMCP2510( U8 CMD )
  139. {
  140.    MCP2510_RW_Start() ; //Initial IO port and CS is select
  141.    Spi_Write( CMD );
  142.    MCP2510_CS_H ; // Deselect the MCP2510
  143. }
  145. /****************************************************************************
  146. 【功能说明】软件复位MCP2510
  147. ****************************************************************************/
  148. void MCP2510_Reset()
  149. {
  150. MCP2510_RW_Start() ;
  151. Spi_Write( MCP2510INSTR_RESET );
  152. MCP2510_CS_H ;
  153. }
  155. /****************************************************************************
  156. 【功能说明】向MCP2510指定地址写入一个字节
  157. ****************************************************************************/
  158. void MCP2510_Write( U8 address, U8 value)
  159. {
  160. MCP2510_RW_Start() ;
  162. Spi_Write(MCP2510INSTR_WRITE);
  163. Spi_Write( address );
  164. Spi_Write( value );
  166. MCP2510_CS_H ;
  167. }
  169. /****************************************************************************
  170. 【功能说明】修改指定地址寄存器的某些位
  171. ****************************************************************************/
  172. void MCP2510_WriteBits( U8 address, U8 data, U8 mask )
  173. {
  174. MCP2510_RW_Start() ;
  176. Spi_Write( MCP2510INSTR_BITMDFY );
  177. Spi_Write( address);
  178. Spi_Write( mask);
  179. Spi_Write( data);
  181. MCP2510_CS_H ;
  182. }
  184. /****************************************************************************
  185. 【功能说明】              Read often used status
  186. //Status   7     6     5     4     3     2   1 0
  187. // | | | | | | | |
  188. // | | | | | | | |___CANINTF.RX0IF
  189. // | | | | | | |_______CANINTF.RX1IF
  190. // | | | | | |___________TXB0CTRL.TXREQ
  191. // | | | | |_______________CANINTF.TX0IF
  192. // | | | |___________________TXB1CTRL.TXREQ
  193. // | | |_______________________CANINTF.TX1IF
  194. // | |___________________________TXB2CTRL.TXREQ
  195. // |_______________________________CANINTF.TX2IF
  196. ****************************************************************************/
  197. unsigned char MCP2510_ReadStatus()
  198. {
  199. unsigned char result;
  201. MCP2510_RW_Start() ;
  203. Spi_Write(MCP2510INSTR_RDSTAT);
  204. result = Spi_Read() ;
  205. Spi_Write( 0 ) ; //数据重复输出
  206. MCP2510_CS_H ;
  208. //if( MCP2510_DEBUG ) Uart_Printf( "StatusREG = 0x%xn", result ) ;
  209. return result;
  210. }
  212. /****************************************************************************
  213. 【功能说明】从MCP2510指定地址中读出一个字节
  214. ****************************************************************************/
  215. unsigned char MCP2510_Read( U8 address )
  216. {
  217. unsigned char result;
  219. MCP2510_RW_Start() ;
  221. Spi_Write(MCP2510INSTR_READ) ; //0x03
  222. Spi_Write( address ) ;
  223. result = Spi_Read() ;
  225. MCP2510_CS_H ;
  227. return result ;
  228. }
  230. /****************************************************************************
  231. 【功能说明】序列读取MCP2510数据
  232. ****************************************************************************/
  233. void MCP2510_SRead( U8 address, unsigned char* pdata, U8 nlength )
  234. {
  235. int i;
  237. MCP2510_RW_Start() ;
  238. Spi_Write(MCP2510INSTR_READ);
  239. Spi_Write( address );
  241. for (i=0; i<nlength; i++)
  242. {
  243. *pdata=Spi_Read();
  244. //if( MCP2510_DEBUG )    Uart_Printf( "  0x%xn", (unsigned char)*pdata ) ;
  245. pdata++;
  246. }
  247. MCP2510_CS_H ;
  248. }
  251. /****************************************************************************
  252. 【功能说明】序列写入MCP2510数据
  253. ****************************************************************************/
  254. void MCP2510_Swrite( U8 address, unsigned char* pdata, U8 nlength)
  255. {
  256. int i;
  257. MCP2510_RW_Start() ;
  259. Spi_Write(MCP2510INSTR_WRITE);
  260. Spi_Write((unsigned char)address);
  262. for (i=0; i < nlength; i++) 
  263. {
  264. Spi_Write( (unsigned char)*pdata );
  265. //if( MCP2510_DEBUG )    Uart_Printf( "0x%xn", (unsigned char)*pdata ) ;
  266. pdata++;
  267. }
  268. MCP2510_CS_H ;
  269. }
  271. /****************************************************************************
  272. 【功能说明】
  273. ****************************************************************************/
  274. void MCP2510_SetBandRate(CanBandRate bandrate, int IsBackNormal)
  275. {
  276. U8 value=0;
  277. U8 ReadBackCNT = 0;
  279. // Bit rate calculations.
  280. //
  281. //Input clock fre=16MHz
  282. // In this case, we'll use a speed of 125 kbit/s, 250 kbit/s, 500 kbit/s.
  283. // If we set the length of the propagation segment to 7 bit time quanta,
  284. // and we set both the phase segments to 4 quanta each,
  285. // one bit will be 1+7+4+4 = 16 quanta in length.
  286. //
  287. // setting the prescaler (BRP) to 0 => 500 kbit/s.
  288. // setting the prescaler (BRP) to 1 => 250 kbit/s.
  289. // setting the prescaler (BRP) to 3 => 125 kbit/s.
  290. //
  291. // If we set the length of the propagation segment to 3 bit time quanta,
  292. // and we set both the phase segments to 1 quanta each,
  293. // one bit will be 1+3+2+2 = 8 quanta in length.
  294. // setting the prescaler (BRP) to 0 => 1 Mbit/s.
  296. // Go into configuration mode
  297. MCP2510_Write(MCP2510REG_CANCTRL, MODE_CONFIG);
  299. if( MCP2510_DEBUG )  Uart_Printf( "MCP2510REG_CANCTRL =  0x%xn", MCP2510_Read(MCP2510REG_CANCTRL) );
  301. while( ReadBackCNT<8 )
  302. {
  303. value = ( MCP2510_Read( MCP2510REG_CANSTAT ) & 0xe0 );
  304. if(value == MODE_CONFIG ){
  305. //Uart_Printf( "ReadBackCNT = 0x%xn", ReadBackCNT );
  306. break;
  307. }
  308. ReadBackCNT++ ;
  309. }
  311. if( ReadBackCNT == 8 )  //Set mcp2510's mode failed,redo it again
  312. {
  313. Uart_Printf( "Set config mode is failed! CANCTRL = 0x%xn", value );
  314. MCP2510_Reset();
  315. MCP2510_Write(MCP2510REG_CANCTRL, MODE_CONFIG); //redo to set mcp2510 mode
  316. Delay( 150 );
  317. value = ( MCP2510_Read(MCP2510REG_CANCTRL) & 0xe0 ); //read back mode from CANSTAT Register
  318. Uart_Printf( "Set is 0x%x , Read is 0x%xn", MODE_CONFIG, value ) ;
  319. }
  321. switch(bandrate){
  322. case BandRate_10kbps:
  323. MCP2510_Write(CNF1, 0x31); //10k 16TQ
  324. MCP2510_Write(CNF2, 0xb0);  //PS1=7 TQ  PSeg=1 TQ
  325. MCP2510_Write(CNF3, 0x06);  //PS2=7 TQ SYNC=1 TQ
  326. //if( MCP2510_DEBUG )  Uart_Printf( "CNF1 =  0x%xn", MCP2510_Read(CNF1) );
  327. //if( MCP2510_DEBUG )  Uart_Printf( "CNF2 =  0x%xn", MCP2510_Read(CNF2) );
  328. //if( MCP2510_DEBUG )  Uart_Printf( "CNF3 =  0x%xn", MCP2510_Read(CNF3) );
  329. break;
  330. case BandRate_125kbps:
  331. MCP2510_Write(CNF1, SJW1|BRP4); //Synchronization Jump Width Length =1 TQ
  332. MCP2510_Write(CNF2, BTLMODE_CNF3|(SEG4<<3)|SEG7); // Phase Seg 1 = 4, Prop Seg = 7
  333. MCP2510_Write(CNF3, SEG4);// Phase Seg 2 = 4
  334. break;
  335. case BandRate_250kbps:
  336. MCP2510_Write(CNF1, SJW1|BRP2); //Synchronization Jump Width Length =1 TQ
  337. MCP2510_Write(CNF2, BTLMODE_CNF3|(SEG4<<3)|SEG7); // Phase Seg 1 = 4, Prop Seg = 7
  338. MCP2510_Write(CNF3, SEG4);// Phase Seg 2 = 4
  339. break;
  340. case BandRate_500kbps:
  341. MCP2510_Write(CNF1, SJW1|BRP1); //Synchronization Jump Width Length =1 TQ
  342. MCP2510_Write(CNF2, BTLMODE_CNF3|(SEG4<<3)|SEG7); // Phase Seg 1 = 4, Prop Seg = 7
  343. MCP2510_Write(CNF3, SEG4);// Phase Seg 2 = 4
  344. break;
  345. case BandRate_1Mbps:
  346. MCP2510_Write(CNF1, SJW1|BRP1); //Synchronization Jump Width Length =1 TQ
  347. MCP2510_Write(CNF2, BTLMODE_CNF3|(SEG3<<3)|SEG2); // Phase Seg 1 = 2, Prop Seg = 3
  348. MCP2510_Write(CNF3, SEG2);// Phase Seg 2 = 1
  349. break;
  350. }
  352. if( IsBackNormal == TRUE  )
  353. {
  354. //Enable clock output
  355. MCP2510_Write(CLKCTRL, MODE_NORMAL | CLKEN | CLK8);
  356. }
  358. }
  360. /****************************************************************************
  361. 【功能说明】读取MCP2510 CAN总线ID
  362. 参数: address为MCP2510寄存器地址
  363. can_id为返回的ID值
  364. 返回值
  365. TRUE，表示是扩展ID(29位)
  366. FALSE，表示非扩展ID(11位)
  367. ****************************************************************************/
  368. int MCP2510_Read_Can_ID( U8 address, U32* can_id)
  369. {
  370. U32 tbufdata;
  371. unsigned char* p=(unsigned char*)&tbufdata;
  373. MCP2510_SRead(address, p, 4);
  374. *can_id = (tbufdata<<3)|((tbufdata>>13)&0x7);
  375. *can_id &= 0x7ff;
  377. if ( (p[MCP2510LREG_SIDL] & TXB_EXIDE_M) ==  TXB_EXIDE_M ) {
  378. *can_id = (*can_id<<2) | (p[MCP2510LREG_SIDL] & 0x03);
  379. *can_id <<= 16;
  380. *can_id |= tbufdata>>16;
  381. return TRUE;
  382. }
  383. return FALSE;
  384. }
  386. /***********************************************************
  387. * 读取MCP2510 接收的数据 *
  388. * 参数: nbuffer为第几个缓冲区可以为3或者4 *
  389. * can_id为返回的ID值 *
  390. * rxRTR表示是否是RXRTR *
  391. * data表示读取的数据 *
  392. * dlc表示data length code *
  393. * 返回值 *
  394. * TRUE，表示是扩展总线 *
  395. * FALSE，表示非扩展总线 *
  396. ***********************************************************/
  397. int MCP2510_Read_Can(U8 nbuffer, int* rxRTR, U32* can_id, U8* data , U8* dlc)
  398. {
  400. U8 mcp_addr = (nbuffer<<4) + 0x31, ctrl;
  401. int IsExt;
  403. IsExt=MCP2510_Read_Can_ID( mcp_addr, can_id);
  405. ctrl=MCP2510_Read(mcp_addr-1);
  406. *dlc=MCP2510_Read( mcp_addr+4);
  407. if ((ctrl & 0x08)) {
  408. *rxRTR = TRUE;
  409. }
  410. else{
  411. *rxRTR = FALSE;
  412. }
  413. *dlc &= DLC_MASK;
  414. //MCP2510_SRead(mcp_addr+5, data, *dlc);
  415. MCP2510_SRead(mcp_addr+5, data, 8);
  417. return IsExt;
  418. }
  421. /***********************************************************
  422. * 写入MCP2510 发送的数据 *
  423. * 参数: nbuffer为第几个缓冲区可以为0、1、2 *
  424. * ext表示是否是扩展总线 *
  425. * can_id为返回的ID值 *
  426. * rxRTR表示是否是RXRTR *
  427. * data表示读取的数据 *
  428. * dlc表示data length code *
  429. * FALSE，表示非扩展总线 *
  430. ***********************************************************/
  431. void MCP2510_Write_Can( U8 nbuffer, int ext, U32 can_id, int rxRTR, U8* data,U8 dlc )
  432. {
  433. U8 mcp_addr = (nbuffer<<4) + 0x31;
  434. MCP2510_Swrite(mcp_addr+5, data, dlc );  // write data bytes
  435. MCP2510_Write_Can_ID( mcp_addr, can_id,ext);  // write CAN id
  436. if (rxRTR)
  437. dlc |= RTR_MASK;  // if RTR set bit in byte
  438. MCP2510_Write((mcp_addr+4), dlc);            // write the RTR and DLC
  439. }
  441. /*******************************************
  442. * 设置MCP2510 CAN总线ID *
  443. * 参数: address为MCP2510寄存器地址*
  444. * can_id为设置的ID值 *
  445. * IsExt表示是否为扩展ID *
  446. *******************************************/
  447. void MCP2510_Write_Can_ID(U8 address, U32 can_id, int IsExt)
  448. {
  449. U32 tbufdata;
  451. if (IsExt) {
  452. can_id&=0x1fffffff; //29位
  453. tbufdata=can_id &0xffff;
  454. tbufdata<<=16;
  455. tbufdata|=(can_id>>(18-5)&(~0x1f));
  456. tbufdata |= TXB_EXIDE_M;
  457. }
  458. else{
  459. can_id&=0x7ff; //11位
  460. tbufdata= (can_id>>3)|((can_id&0x7)<<13);
  461. }
  462. MCP2510_Swrite(address, (unsigned char*)&tbufdata, 4);
  463. }
  465. /***********************************************************************************
  466. 发送数据
  467. 参数:
  468. data，发送数据
  470. Note: 使用三个缓冲区循环发送，没有做缓冲区有效检测
  471. ***********************************************************************************/
  472. void Can_Write(U32 id, U8 *pdata, unsigned char dlc, int IsExt, int rxRTR)
  473. {
  474. unsigned char err ;
  475. static int ntxbuffer=0;
  476. MCP2510_Write_Can(ntxbuffer, IsExt, id, rxRTR, pdata, dlc);
  478. switch(ntxbuffer){
  479. case 0:
  480. MCP2510_WriteBits(TXB0CTRL, (TXB_TXREQ_M|TXB_TXP10_M), 0xff) ;
  481. do { err = MCP2510_Read(TXB0CTRL) ; }
  482. while( (err &0x08)==0x08 )  ;
  483. if( (err &0x70) != 0 )  Uart_Printf( "  Can Send Err = 0x%xn", err  );
  484. ntxbuffer=1;
  485. break;
  486. case 1:
  487. MCP2510_WriteBits(TXB1CTRL, (TXB_TXREQ_M|TXB_TXP10_M), 0xff) ;
  488. do { err = MCP2510_Read(TXB1CTRL) ; }
  489. while( (err &0x08)==0x08 )  ;
  490. if( (err &0x70) != 0 )  Uart_Printf( "  Can Send Err = 0x%xn", err  );
  491. ntxbuffer=2;
  492. break;
  493. case 2:
  494. MCP2510_WriteBits(TXB2CTRL, (TXB_TXREQ_M|TXB_TXP10_M), 0xff) ;
  495. do { err = MCP2510_Read(TXB2CTRL) ; }
  496. while( (err &0x08)==0x08 )  ;
  497. if( (err &0x70) != 0 )  Uart_Printf( "  Can Send Err = 0x%xn", err  );
  498. ntxbuffer=0;
  499. break;
  500. }
  502. }
  505. /***********************************************************************************
  506. 查询是否收到数据
  507. 返回值:如果没有数据，则返回-1，
  508. 否则，返回收到数据的缓冲区号
  509. Note: 如果两个缓冲区都收到数据，则返回第一个缓冲区
  510. ***********************************************************************************/
  511. int Can_Poll()
  512. {
  513. if( MCP2510_ReadStatus()&RX0INT )
  514. return 0;
  516. if( MCP2510_ReadStatus()&RX1INT )
  517. return 1;
  519. return -1;
  520. }
  522. /****************************************************************************
  523. 【功能说明】
  524. ****************************************************************************/
  525. int Can_Read(int n, U32* id, U8 *pdata,  U8*dlc, int* rxRTR, int *isExt)
  526. {
  527. U8 byte;
  528. byte = MCP2510_Read(CANINTF);
  530. if(n==0)
  531. {
  532. if(byte & RX0INT)
  533. {
  534. *isExt=MCP2510_Read_Can(n+3, rxRTR, id, pdata, dlc);
  535. MCP2510_WriteBits(CANINTF, (U8)(~(RX0INT)), RX0INT); // Clear interrupt
  536. return TRUE ;
  537. }
  538. Uart_Printf( "Error! 0 bytes is Read!!! CANINTF=0x%xn", byte ) ;
  539. return FALSE;
  540. }
  541. else if(n ==1 )
  542. {
  543. if(byte & RX1INT)
  544. {
  545. *isExt=MCP2510_Read_Can(n+4, rxRTR, id, pdata, dlc);
  546. MCP2510_WriteBits(CANINTF, (U8)(~(RX1INT)), RX1INT); // Clear interrupt
  547. return TRUE ;
  548. }
  549. Uart_Printf( "0 bytes is Read!!! CANINTF=0x%xn", byte ) ;
  550. return FALSE;
  551. }
  553. Uart_Printf( "Error! Receive channel=0x%xn", n ) ;
  554. return FALSE;
  555. }
  557. /****************************************************************************
  558. 【功能说明】
  559. ****************************************************************************/
  560. // Setup the CAN buffers used by the application.
  561. // We currently use only one for reception and one for transmission.
  562. // It is possible to use several to get a simple form of queue.
  563. //
  564. // We setup the unit to receive all CAN messages.
  565. // As we only have at most 4 different messages to receive, we could use the
  566. // filters to select them for us.
  567. //
  568. // Init_MCP2510() should already have been called.
  569. void Can_Setup(void)
  570. {
  571.     // As no filters are active, all messages will be stored in RXB0 only if
  572.     // no roll-over is active. We want to recieve all CAN messages (standard and extended)
  573.     // (RXM<1:0> = 11).
  574.     //SPI_mcp_write_bits(RXB0CTRL, RXB_RX_ANY, 0xFF);
  575.     //SPI_mcp_write_bits(RXB1CTRL, RXB_RX_ANY, 0xFF);
  577.     // But there is a bug in the chip, so we have to activate roll-over.
  578. MCP2510_WriteBits(RXB0CTRL, (RXB_BUKT+RXB_RX_ANY), 0xFF); //关闭屏蔽滤波功能，接收所有报文，允许滚存 
  579. MCP2510_WriteBits(RXB1CTRL, RXB_RX_ANY, 0xFF); //关闭屏蔽滤波功能，接收所有报文
  580. }
  582. /****************************************************************************
  583. 【功能说明】
  584. ****************************************************************************/
  585. void Init_MCP2510(CanBandRate bandrate)
  586. {
  587. unsigned char i,j,a;
  589. MCP2510_IO_CS_Init() ;
  590. MCP2510_Reset();
  592. MCP2510_SetBandRate(bandrate,FALSE); //设置波特率
  594. // Disable interrups.
  595. MCP2510_Write(CANINTE, NO_IE);   //禁止所有中断
  597. // Mark all filter bits as don't care:
  598. MCP2510_Write_Can_ID(RXM0SIDH, 0,0);
  599. MCP2510_Write_Can_ID(RXM1SIDH, 0,0);
  600. // Anyway, set all filters to 0:
  601. MCP2510_Write_Can_ID(RXF0SIDH, 0, 0);
  602. MCP2510_Write_Can_ID(RXF1SIDH, 0, 0);
  603. MCP2510_Write_Can_ID(RXF2SIDH, 0, 0);
  604. MCP2510_Write_Can_ID(RXF3SIDH, 0, 0);
  605. MCP2510_Write_Can_ID(RXF4SIDH, 0, 0);
  606. MCP2510_Write_Can_ID(RXF5SIDH, 0, 0);
  608. MCP2510_Write(CLKCTRL, MODE_LOOPBACK| CLKEN | CLK8);//回环模式
  609.     //如果不能用两台设备联机实验的话，可以选择回环模式
  610. //MCP2510_Write(CLKCTRL, MODE_NORMAL| CLKEN | CLK8);//标准模式
  611.   
  612. // Clear, deactivate the three transmit buffers
  613. a = TXB0CTRL;
  614. for (i = 0; i < 3; i++) {
  615. for (j = 0; j < 14; j++) {
  616. MCP2510_Write(a, 0);
  617. a++;
  618.         }
  619.         a += 2; // We did not clear CANSTAT or CANCTRL
  620. }
  621. // and the two receive buffers.
  622. MCP2510_Write(RXB0CTRL, 0);
  623. MCP2510_Write(RXB1CTRL, 0);
  625. // The two pins RX0BF and RX1BF are used to control two LEDs; set them as outputs and set them as 00.
  626. MCP2510_Write(BFPCTRL, 0x3C);
  628. //Open Interrupt
  629. MCP2510_Write(CANINTE, RX0IE|RX1IE);
  630. }
  632. /****************************************************************************
  633. 【功能说明】MCP2510实验程序
  634. ****************************************************************************/
  635. void Test_MCP2510(void)
  636. {
  637. int i;
  638. U32 id;
  639. unsigned char dlc;
  640. int rxRTR, isExt;
  641. int temp;
  643. U8 data_write[8]={1,2,3,4,5,6,7,8};
  644. U8 data_read[8] ;
  646.     Uart_Printf( "nCAN BUS Test[ MCP2510 ], press ESC key to exit !n" ) ;
  648. Init_MCP2510(BandRate_10kbps);
  649. Can_Setup();
  651.     while( Uart_GetKey() != ESC_KEY )
  652.     {
  653. Can_Write( 0x5a5, data_write, 8, FALSE, FALSE);
  655. while( (i=Can_Poll())==-1 ) ;
  657. for( temp=0; temp<8; temp++)  data_read[temp] = 0 ;
  658. temp = Can_Read(i, &id, data_read, &dlc, &rxRTR, &isExt);
  660. Uart_Printf( "  ID=0x%xn",id );
  661. Uart_Printf( "Data=%x,%x,%x,%x,%x,%x,%x,%xn",data_read[0],data_read[1],data_read[2],data_read[3],data_read[4],data_read[5],data_read[6],data_read[7] );
  662. /*
  663. for( temp=0; temp<8; temp++)  data_read[temp] = 0 ;
  664. temp = Can_Read(1, &id, data_read, &dlc, &rxRTR, &isExt);
  665. Uart_Printf( "  ID=0x%xn",id );
  666. Uart_Printf( "Data=%x,%x,%x,%x,%x,%x,%x,%xn",data_read[0],data_read[1],data_read[2],data_read[3],data_read[4],data_read[5],data_read[6],data_read[7] );
  667. */
  668. Delay(500);
  669. }
  671. }