CAN-BUS mit dsPIC30F6014

i made some changes in my file, but it doesn't work. the can-port 
wouldn`t send the message...is there anyone who can help me?

thx



#include "p30f6014.h"
#include "can.h"
/* ***********************************
included functions
can_clk_init
can_init
can_receive
can_transmit
  *********************************** */

void can_clk_init (void)    // Initialize CAN_CLK
{
// ***********************************
// CAN1 Control Register
// FCAN Clock = FCY
C1CTRLbits.CANCKS = 0x1;   // Bit CANCKS set 1
// ***********************************
// CAN1 Baud Rate Control Register
// PHASE Segment 1 = 8TQ
// PHASE Segment 2 = 6TQ
// Propagation Delay = 5TQ
// Synchronization Jump width = 4TQ
// Baud Rate Prescaler = BRP_VAL defined in can.h
// Sync. Segment = 1TQ
// Phase Segment 2 Time select bit = 6TQ

C1CFG1bits.BRP = BRP_VAL;   // Bit BRP set BRP_VAL
C1CFG1bits.SJW = 0x3;    // Bit SJW set 11
C1CFG2bits.PRSEG = 0x4;    // Bit PRSEG set 100
C1CFG2bits.SEG1PH = 0x7;    // Bit SEG1PH set 111
C1CFG2bits.SAM = 0x1;    // Bit SAM set 1
C1CFG2bits.SEG2PHTS = 0x1;   // Bit SEG2PHTS set 1
C1CFG2bits.SEG2PH = 0x5;   // Bit SEG2PH set 101

}
void can_init (void)     // Initialisier CAN
{
// ***********************************
// Request Configuration Mode
// Request Operation Mode = 4
C1CTRLbits.REQOP = 0x4;   // Bit REQ0P set 100
while (C1CTRLbits.OPMODE != 0x4);
can_clk_init();

// ***********************************
// Filter configuration
// Standard Identifier
// Standard Identifier Bit = 1111111111
// Extendes Identifier Enable Bit = 0 (MIDE = 1)
C1RXF0SIDbits.EXIDE = 0x0;   // Filter 0
C1RXF0SIDbits.SID = 0x3FF;

// Extended Identifier
// not included -> MIDE disabled
// ***********************************
// Mask Configuration
// Standard Identifier
// Identifier Mode Selection Bit = 0
// Standard Identifier Mask Bit = 1111111111
C1RXM0SIDbits.MIDE = 0x1;   // Bit Mide set 1
C1RXM0SIDbits.SID = 0x3FF;   // BIT SID set
// Extended Identifier
// not included
// ***********************************
// Normal Mode
// Request Operation Mode = 0
C1CTRLbits.REQOP = 0x0;   // Bit REQ0P set 000
while(C1CTRLbits.OPMODE != 0x0);
}
void can_receive (void)
{
}
void can_transmit (void)
{
// Message Transmit Priority Level 00
C1TX0CONbits.TXPRI = 0x0 ;   // Bit TXPRI set 00
}

Hi

Ich hab mit dem CAN-Modul leider noch nichts gemacht, aber probiers mal 
im Microchip Forum oder im Fernando Heitor Forum.

forum.microchip.com
www.fernando-heitor.com

mfg schoasch

PS.: Schreib dann auch dazu was sich nicht tut. Schickst du irgendwas 
hinaus? Hast du das mit dem OSzi geprüft?

also danke für die beiden posts,

ich hab mal unter beiden geschaut und auch gepostet, bin mal gespannt.

was nicht geht:

eigentlich wollt ich eine folge von bits ausgeben lassen und mit dem 
oszi anzeigen, also erst so, bevor ich an das 2te board gehe, aber ich 
bekomm nichts raus, und ich vermute, dass es an der init liegt...

da kommt nichts raus, aber rein gar nichts..aber ich hab jetzt glaub ich 
was entdeck, wenn ich schritt für schritt debugge, dann hängt mir das 
progi in einer schleife fest und geht nimmer raus (schleife im normal 
mode)
und dann kann ich ja net weitermachen, wenns da immer hängt

hier mal das ganze projekt, nur die dspic30f6014.h und die dazugehörige 
*.gld hab ich jetzt nicht mit gepostet....

problemstellung: Ich bekomm keine Datan am Can-port ausgegeben
Board: dspicdem 1.1 von microchip
Controller: dspic30f6014
programm: mplab
compiler: c30
programmer: icd 2

wenn mir da jemand weiterhelfen könnt, wäre ich dankbar

code below:
-main.c
-can.c
-can.h
-global_variables.c
-global_variables.h
-define_portpins.h

*******************main.c***********************
#include <stdio.h>
#include "p30f6014.h"
#include "can.h"
#include "global_variables.h"
#include "define_portpins.h"
int main (void)
{
TRISA = 0xF000;
TRISB = 0x017B;
TRISC = 0x0000;
PORTD = 0x00EF;
TRISD = 0x0010;
PORTF = 0x002A;
TRISF = 0x0055;
TRISG = 0x1080;
// enable interrupts
C1INTE = 0x00FF;
// set operation mode
can_set_op_mode_1();
while (C1CTRLbits.OPMODE <=3);
// load configuration register
can_init();
// load acceptance filter
can_acceptance_filter();
// load mask filter
can_mask();
// set transmit and receive mode
can_tx_mode();
can_rx_mode();
// load message ID, data_transmit -> transmit buffer, transmit request 
bit
unsigned char *tx_data_ptr;
tx_data_ptr = &tx_data[0];
can_transmit(tx_data_ptr);
// set operation mode
can_set_op_mode_2();
while (C1CTRLbits.REQOP !=2);
// wait till transmit is finished
while (!C1TX0CONbits.TXREQ);
// wait till receive buffer contains message
while (C1RX0CONbits.RXFUL);
// received data -> data_received
unsigned char *rx_data_ptr;
rx_data_ptr = &rx_data[0];
can_receive(rx_data_ptr);
// loop
while (1);
return 0;
}


**********************can.c************************
#include "can.h"
#include "p30f6014.h"
#include "global_variables.h"
void can_set_op_mode_1()
{
C1CTRLbits.CSIDL = 0x0;    // continue can modul operation in idle mode
C1CTRLbits.CANCKS = 0x1;   // fcan = fcy
C1CTRLbits.REQOP = 0x4;    // set operation mode
}
void can_init()
{
C1CFG1bits.SJW = 0x1;    // synchronized jump width = 01
C1CFG1bits.BRP = 0x3F;    // baud rate 128/fcsn
C1CFG2bits.WAKFIL = 0x0;   // can bus line filter is not used for wake 
up
C1CFG2bits.SEG2PH = 0x4;   // phase buffer segment 2 = 100
C1CFG2bits.SEG2PHTS = 0x1;   // phase segment 2 time select = freely 
programmable
C1CFG2bits.SAM = 0x0;    // sample can bus line = 0 (1x)
C1CFG2bits.SEG1PH = 0x3;   // phase buffer segment 1 = 011
C1CFG2bits.PRSEG = 0x3;    // propagation time = 011
}
void can_acceptance_filter()
{
C1RXF0SID = 0x555;     // standard identifier bits
C1RXF0SIDbits.EXIDE = 0x1;   // enable filter SID=0 EID=1
C1RXF0EIDH = 0xAAA;     // extended identifier bits upper byte
C1RXF0EIDL = 0x2A;     // extended identifier bits lower byte
}
void can_mask()
{
C1RXM0SID = 0x2AA;     // standard identifier mask bits
C1RXM0SIDbits.MIDE = 0x0;   // identifier mode 0
C1RXM0EIDH = 0x555;     // extended identifier mask bits upper byte
C1RXM0EIDL = 0x25;     // extendet identifier mask bits lower byte
}
void can_tx_mode()
{
C1TX0CONbits.TXPRI = 0x2;   // message transmission priority (high = 10)
C1TX0CONbits.TXREQ = 0x0;   // message send request bit (1 = request)
}
void can_rx_mode()
{
C1RX0CONbits.DBEN = 0x1;   // receive buffer 0 double buffer enable bit
C1RX0CONbits.RXFUL = 0x0;   // receive full status (buffer open = 0)
}
void can_transmit(unsigned char *data)
{
int i;
C1TX0SID = 0x2AA;     // standard identifier bits
C1TX0EID = 0x1555;     // extended identifier bits

for(i=0;i<data_length;i++)
    {
      *((unsigned char *)&C1TX0B1+i) = data;
       }
C1TX0DLCbits.DLC = data_length;  // data length code bits
   C1TX0CONbits.TXREQ = 0x1;   // message send request bit

}
void can_set_op_mode_2()
{
C1CTRLbits.CSIDL = 0x0;    // continue can modul operation in idle mode
C1CTRLbits.CANCKS = 0x1;   // fcan = fcy
C1CTRLbits.REQOP = 0x2;    // set loopback mode
C1CTRLbits.CANCAP = 0x0;   // can message receive capture disable
}
void can_receive(unsigned char *data)
{
int i;
   for(i = 0;i<data_length;i++)
    {
  data = *((unsigned char *)&C1RX0B1+i);
       }
C1RX0CONbits.RXFUL = 0x0;   // receive full status bit
}


***********************can.h*******************************
extern void can_set_op_mode_1();
extern void can_init();
extern void can_acceptance_filter();
extern void can_mask();
extern void can_tx_mode();
extern void can_rx_mode();
extern void can_transmit(unsigned char *);
extern void can_set_op_mode_2();
extern void can_receive( unsigned char *);

************************global_variables.c**************************
#include "global_variables.h"
unsigned char tx_data[data_length] ={1,0,1,0,1,0,1,0};
unsigned char rx_data[data_length];

***********************define_portpins.h**************************
#include "p30f6014.h"
#define LED1 LATDbits.LATD0
#define LED2 LATDbits.LATD1
#define LED3 LATDbits.LATD2
#define LED4 LATDbits.LATD3
#define LEDS_OFF (LATD |= 0x000F)
#define LEDS_ON  (LATD &= 0xFFF0)
#define _CS_LCD  PORTGbits.RG9
#define _CS_POTI  PORTDbits.RD7
#define CAN_RXD  PORTFbits.RF0
#define CAN_TXD  PORTFbits.RF1
#define CTS PORTDbits.RD4
#define RTS PORTDbits.RD5


***********************global_variables.h**********************
#define data_length 8
extern unsigned char rx_data[data_length];
extern unsigned char tx_data[data_length];


**********************assemlby code****************************
---  P:\CAN-BUS\Sender\can.c 
--------------------------------------------------------------------
1:                 #include "can.h"
2:                 #include "p30f6014.h"
3:                 #include "global_variables.h"
4:
5:                 void can_set_op_mode_1()
6:                 {
0001EC  FA0000     lnk #_dinit_tblpage
7:                  C1CTRLbits.CSIDL = 0x0;    // continue can modul 
operation in idle mode
0001EE  A9A391     bclr.b 0x391,#5
8:                  C1CTRLbits.CANCKS = 0x1;   // fcan = fcy
0001F0  A86391     bset.b 0x391,#3
9:                  C1CTRLbits.REQOP = 0x4;    // set operation mode
0001F2  203911     mov.w #0x391,w1
0001F4  784091     mov.b [w1],w1
0001F6  B3CF80     mov.b #0xf8,w0
0001F8  60C000     and.b w1,w0,w0
0001FA  A02400     bset w0,#2
0001FC  B7E391     mov.b w0,0x391
10:                }
0001FE  FA8000     ulnk
11:
12:                void can_init()
13:                {
000202  FA0000     lnk #_dinit_tblpage
14:                 C1CFG1bits.SJW = 0x1;    // synchronized jump width 
= 01
000204  BFC392     mov.b C1CFG1bits,w0
000206  B243F0     and.b #0x3f,w0
000208  B3C401     mov.b #0x40,w1
00020A  704001     ior.b w0,w1,w0
00020C  B7E392     mov.b w0,C1CFG1bits
15:                 C1CFG1bits.BRP = 0x3F;    // baud rate 128/fcsn
00020E  203921     mov.w #0x392,w1
000210  784091     mov.b [w1],w1
000212  B3C3F0     mov.b #0x3f,w0
000214  70C000     ior.b w1,w0,w0
000216  B7E392     mov.b w0,C1CFG1bits
16:                 C1CFG2bits.WAKFIL = 0x0;   // can bus line filter is 
not used for wake up
000218  A9C395     bclr.b 0x395,#6
17:                 C1CFG2bits.SEG2PH = 0x4;   // phase buffer segment 2 
= 100
00021A  203951     mov.w #0x395,w1
00021C  784091     mov.b [w1],w1
00021E  B3CF80     mov.b #0xf8,w0
000220  60C000     and.b w1,w0,w0
000222  A02400     bset w0,#2
000224  B7E395     mov.b w0,0x395
18:                 C1CFG2bits.SEG2PHTS = 0x1;   // phase segment 2 time 
select = freely programmable
000226  A8E394     bset.b C1CFG2bits,#7
19:                 C1CFG2bits.SAM = 0x0;    // sample can bus line = 0 
(1x)
000228  A9C394     bclr.b C1CFG2bits,#6
20:                 C1CFG2bits.SEG1PH = 0x3;   // phase buffer segment 1 
= 011
00022A  203941     mov.w #0x394,w1
00022C  784091     mov.b [w1],w1
00022E  B3CC70     mov.b #0xc7,w0
000230  60C000     and.b w1,w0,w0
000232  B34180     ior.b #0x18,w0
000234  B7E394     mov.b w0,C1CFG2bits
21:                 C1CFG2bits.PRSEG = 0x3;    // propagation time = 011
000236  203941     mov.w #0x394,w1
000238  784091     mov.b [w1],w1
00023A  B3CF80     mov.b #0xf8,w0
00023C  60C000     and.b w1,w0,w0
00023E  B34030     ior.b #0x3,w0
000240  B7E394     mov.b w0,C1CFG2bits
22:                }
000242  FA8000     ulnk
23:
24:                void can_acceptance_filter()
25:                {
000246  FA0000     lnk #_dinit_tblpage
26:                 C1RXF0SID = 0x555;     // standard identifier bits
000248  205550     mov.w #0x555,w0
00024A  881800     mov.w w0,CAN1
27:                 C1RXF0SIDbits.EXIDE = 0x1;   // enable filter SID=0 
EID=1
00024C  A80300     bset.b CAN1,#0
28:                 C1RXF0EIDH = 0xAAA;     // extended identifier bits 
upper byte
00024E  20AAA0     mov.w #0xaaa,w0
000250  881810     mov.w w0,C1RXF0EIDHbits
29:                 C1RXF0EIDL = 0x2A;     // extended identifier bits 
lower byte
000252  2002A0     mov.w #0x2a,w0
000254  881820     mov.w w0,C1RXF0EIDL
30:                }
000256  FA8000     ulnk
31:
32:                void can_mask()
33:                {
00025A  FA0000     lnk #_dinit_tblpage
34:                 C1RXM0SID = 0x2AA;     // standard identifier mask 
bits
00025C  202AA0     mov.w #0x2aa,w0
00025E  881980     mov.w w0,C1RXM0SID
35:                 C1RXM0SIDbits.MIDE = 0x0;   // identifier mode 0
000260  A90330     bclr.b C1RXM0SID,#0
36:                 C1RXM0EIDH = 0x555;     // extended identifier mask 
bits upper byte
000262  205550     mov.w #0x555,w0
000264  881990     mov.w w0,C1RXM0EIDH
37:                 C1RXM0EIDL = 0x25;     // extendet identifier mask 
bits lower byte
000266  200250     mov.w #0x25,w0
000268  8819A0     mov.w w0,C1RXM0EIDLbits
38:                }
00026A  FA8000     ulnk
39:
40:                void can_tx_mode()
41:                {
00026E  FA0000     lnk #_dinit_tblpage
42:                 C1TX0CONbits.TXPRI = 0x2;   // message transmission 
priority (high = 10)
000270  2036E1     mov.w #0x36e,w1
000272  784091     mov.b [w1],w1
000274  B3CFC0     mov.b #0xfc,w0
000276  60C000     and.b w1,w0,w0
000278  A01400     bset w0,#1
00027A  B7E36E     mov.b w0,C1TX0CON
43:                 C1TX0CONbits.TXREQ = 0x0;   // message send request 
bit (1 = request)
00027C  A9636E     bclr.b C1TX0CON,#3
44:                }
00027E  FA8000     ulnk
45:
46:                void can_rx_mode()
47:                {
000282  FA0000     lnk #_dinit_tblpage
48:                 C1RX0CONbits.DBEN = 0x1;   // receive buffer 0 
double buffer enable bit
000284  A8438E     bset.b C1RX0CONbits,#2
49:                 C1RX0CONbits.RXFUL = 0x0;   // receive full status 
(buffer open = 0)
000286  A9E38E     bclr.b C1RX0CONbits,#7
50:                }
000288  FA8000     ulnk
51:
52:                void can_transmit(unsigned char *data)
53:                {
00028C  FA0004     lnk #WREG2
54:                 int i;
55:
56:                 C1TX0SID = 0x2AA;     // standard identifier bits
000290  202AA0     mov.w #0x2aa,w0
000292  881B00     mov.w w0,C1TX0SIDbits
57:                 C1TX0EID = 0x1555;     // extended identifier bits
000294  215550     mov.w #0x1555,w0
000296  881B10     mov.w w0,C1TX0EIDbits
58:
59:                 for(i=0;i<data_length;i++)
000298  EB0000     clr.w w0
00029A  780F00     mov.w w0,[w14]
00029C  37000B     bra .L14
0002B2  E80F1E     inc.w [w14],[w14]
0002B4  200070     mov.w #0x7,w0
0002B6  100F9E     subr.w w0,[w14],[w15]
0002B8  34FFF2     bra les, .L15
60:                     {
61:                       *((unsigned char *)&C1TX0B1+i) = data;
00029E  78001E     mov.w [w14],w0
0002A0  780080     mov.w w0,w1
0002A2  203660     mov.w #0x366,w0
0002A4  408100     add.w w1,w0,w2
0002A6  78001E     mov.w [w14],w0
0002A8  780080     mov.w w0,w1
0002AA  90001E     mov.w [w14+2],w0
0002AC  408000     add.w w1,w0,w0
0002AE  784010     mov.b [w0],w0
0002B0  784900     mov.b w0,[w2]
62:                        }
63:
64:                 C1TX0DLCbits.DLC = data_length;  // data length code 
bits
0002BA  203641     mov.w #0x364,w1
0002BC  784091     mov.b [w1],w1
0002BE  B3C870     mov.b #0x87,w0
0002C0  60C000     and.b w1,w0,w0
0002C2  B3C401     mov.b #0x40,w1
0002C4  704001     ior.b w0,w1,w0
0002C6  B7E364     mov.b w0,C1TX0DLC
65:                    C1TX0CONbits.TXREQ = 0x1;   // message send 
request bit
0002C8  A8636E     bset.b C1TX0CON,#3
66:
67:                }
0002CA  FA8000     ulnk
68:
69:                void can_set_op_mode_2()
70:                {
0002CE  FA0000     lnk #_dinit_tblpage
71:                 C1CTRLbits.CSIDL = 0x0;    // continue can modul 
operation in idle mode
0002D0  A9A391     bclr.b 0x391,#5
72:                 C1CTRLbits.CANCKS = 0x1;   // fcan = fcy
0002D2  A86391     bset.b 0x391,#3
73:                 C1CTRLbits.REQOP = 0x2;    // set loopback mode
0002D4  203911     mov.w #0x391,w1
0002D6  784091     mov.b [w1],w1
0002D8  B3CF80     mov.b #0xf8,w0
0002DA  60C000     and.b w1,w0,w0
0002DC  A01400     bset w0,#1
0002DE  B7E391     mov.b w0,0x391
74:                 C1CTRLbits.CANCAP = 0x0;   // can message receive 
capture disable
0002E0  A9E391     bclr.b 0x391,#7
75:                }
0002E2  FA8000     ulnk
76:
77:                void can_receive(unsigned char *data)
78:                {
0002E6  FA0004     lnk #WREG2
79:                 int i;
80:
81:                    for(i = 0;i<data_length;i++)
0002EA  EB0000     clr.w w0
0002EC  780F00     mov.w w0,[w14]
0002EE  37000B     bra .L21
000304  E80F1E     inc.w [w14],[w14]
000306  200070     mov.w #0x7,w0
000308  100F9E     subr.w w0,[w14],[w15]
00030A  34FFF2     bra les, .L22
82:                     {
83:                   data = *((unsigned char *)&C1RX0B1+i);
0002F0  78001E     mov.w [w14],w0
0002F2  780080     mov.w w0,w1
0002F4  90001E     mov.w [w14+2],w0
0002F6  408100     add.w w1,w0,w2
0002F8  78001E     mov.w [w14],w0
0002FA  780080     mov.w w0,w1
0002FC  203860     mov.w #0x386,w0
0002FE  408000     add.w w1,w0,w0
000300  784010     mov.b [w0],w0
000302  784900     mov.b w0,[w2]
84:                        }
85:
86:                 C1RX0CONbits.RXFUL = 0x0;   // receive full status 
bit
00030C  A9E38E     bclr.b C1RX0CONbits,#7
87:                }
00030E  FA8000     ulnk
---  P:\CAN-BUS\Sender\main.c
35:
36:                #include <stdio.h>
37:                #include "p30f6014.h"
38:                #include "can.h"
39:                #include "global_variables.h"
40:                #include "define_portpins.h"
41:
42:                int main (void)
43:                {
000180  FA0004     lnk #WREG2
44:                 TRISA = 0xF000;
000182  2F0000     mov.w #0xf000,w0
000184  881600     mov.w w0,TRISAbits
45:                 TRISB = 0x017B;
000186  2017B0     mov.w #0x17b,w0
000188  881630     mov.w w0,TRISBbits
46:                 TRISC = 0x0000;
00018A  EB0000     clr.w w0
00018C  881660     mov.w w0,TRISC
47:                 PORTD = 0x00EF;
00018E  200EF0     mov.w #0xef,w0
000190  8816A0     mov.w w0,PORTD
48:                 TRISD = 0x0010;
000192  200100     mov.w #0x10,w0
000194  881690     mov.w w0,TRISD
49:                 PORTF = 0x002A;
000196  2002A0     mov.w #0x2a,w0
000198  881700     mov.w w0,PORTFbits
50:                 TRISF = 0x0055;
00019A  200550     mov.w #0x55,w0
00019C  8816F0     mov.w w0,TRISF
51:                 TRISG = 0x1080;
00019E  210800     mov.w #0x1080,w0
0001A0  881720     mov.w w0,TRISG
52:
53:                // enable interrupts
54:
55:                 C1INTE = 0x00FF;
0001A2  200FF0     mov.w #0xff,w0
0001A4  881CC0     mov.w w0,C1INTEbits
56:
57:                // set operation mode
58:
59:                 can_set_op_mode_1();
0001A6   70022     rcall can_set_op_mode_1
60:                 while (C1CTRLbits.OPMODE <=3);
0001A8  BFC390     mov.b C1CTRLbits,w0
0001AA  FB8000     ze.b w0,w0
0001AC  DE0045     lsr w0,#5,w0
0001AE  FB8000     ze.b w0,w0
0001B0  500FE3     sub.w w0,#3,[w15]
0001B2  34FFFA     bra les, .L2
61:
62:                // load configuration register
63:
64:                 can_init();
0001B4   70026     rcall can_init
65:
66:                // load acceptance filter
67:
68:                 can_acceptance_filter();
0001B6   70047     rcall can_acceptance_filter
69:
70:                // load mask filter
71:
72:                 can_mask();
0001B8   70050     rcall can_mask
73:
74:                // set transmit and receive mode
75:
76:                 can_tx_mode();
0001BA   70059     rcall can_tx_mode
77:                 can_rx_mode();
0001BC   70062     rcall can_rx_mode
78:
79:                // load message ID, data_transmit -> transmit buffer, 
transmit request bit
80:
81:                 unsigned char *tx_data_ptr;
82:                 tx_data_ptr = &tx_data[0];
0001BE  208080     mov.w #0x808,w0
0001C0  980710     mov.w w0,[w14+2]
83:
84:                 can_transmit(tx_data_ptr);
0001C2  90001E     mov.w [w14+2],w0
0001C4   70063     rcall can_transmit
85:
86:                // set operation mode
87:
88:                 can_set_op_mode_2();
0001C6   70083     rcall can_set_op_mode_2
89:                 while (C1CTRLbits.REQOP !=2);
0001C8  BFC391     mov.b 0x391,w0
0001CA  604067     and.b w0,#7,w0
0001CC  504FE2     sub.b w0,#2,[w15]
0001CE  3AFFFC     bra nz, .L4
90:
91:                // wait till transmit is finished
92:
93:                 while (!C1TX0CONbits.TXREQ);
0001D0  BFC36E     mov.b C1TX0CON,w0
0001D2  604068     and.b w0,#8,w0
0001D4  E00400     cp0.b w0
0001D6  32FFFC     bra z, .L5
94:
95:                // wait till receive buffer contains message
96:
97:                 while (C1RX0CONbits.RXFUL);
0001D8  BFC38E     mov.b C1RX0CONbits,w0
0001DA  B3C801     mov.b #0x80,w1
0001DC  604001     and.b w0,w1,w0
0001DE  E00400     cp0.b w0
0001E0  3AFFFB     bra nz, .L6
98:
99:                // received data -> data_received
100:
101:                unsigned char *rx_data_ptr;
102:                rx_data_ptr = &rx_data[0];
0001E2  208000     mov.w #0x800,w0
0001E4  780F00     mov.w w0,[w14]
103:
104:                can_receive(rx_data_ptr);
0001E6  78001E     mov.w [w14],w0
0001E8   7007E     rcall can_receive
105:
106:               // loop
107:
108:                while (1);
0001EA  37FFFF     bra .L8



thanks :-)

kein thema,

hab ich falsch verstanden...

hab noch ein fehler gefunden..und zwar waren die configuration bits 
falsch...gesetzt, also in mplab, habs jetzt ins progi mit eingebunden...

mach gerade nen neuen test

thx

*    also mit dem debugger bleibt er nur hängen, bzw. bleibt in der 
while schleife, wenn ich auf die empfangene nachricht abfrage, ansonsten 
läuft der durch...

while (C1RX0CONbits.RXFUL);

*    ja, ich setz den CAN in den loopbackmode, ist das falsch?

*    wieso ohne interrupt? kann ich nicht wirklich gut...also interrupt 
routinen aufrufen und richtig behandeln...aber werd dass dann später 
noch versuchen, wenn das jetzt so mal irgendwann laufen sollte

*    das ich am Oszi nichts darstellen kann, also die frames, liegt das 
am loopbackmode?

*    das mit dem return 1; habe ich schon geändert gehabt, war nur ein 
fehler, der mir erst nach dem posten aufgefallen ist...

*    bei void main(void) gibt der c30 nen fehler raus, dass da ein int 
hin muss...(Version 6.6 hier auf dem rechner, bei version 7.6 nimmt er 
auch das void)

und das mit dem code ist überlegens- und probiersache...

ich hab mich durch den ganzen papierkram gewühlt und mir das versucht 
irgendwie zu verinnerlichen...hab auch schon im netz rumgesucht, aber da 
findet sich nicht wirklich was zum can mid dem dspic30f6014...

Stimmt das was ich im code mach? oder hab ich da noch nen großen 
verständnissfehler?

z.b. ist mir noch nicht klar, wie das mit den buffern ist. wenn ich die 
daten in den buffer schiebe und den dann sende, woher weiß das prog. 
wohin er die buffer ausgeben muss?

ich hab zwar in der define_portpins:

#define CAN_RXD    PORTFbits.RF0
#define CAN_TXD    PORTFbits.RF1

die sache deklariert, aber wirklich an CAN_*XD übergeben tu ich nich

muss ich statt in den loopback mode in den normal operation mode (000)?

loopback brauch ich dann für was?

? wenn ich ein echo an den selben pic zurücksenden will?

okay, die eine frage mit dem mode hat sich geklärt:

Normal Operation Mode
Normal Operating mode is selected when REQOP<2:0> = ‘000’. In this mode, 
the module is
activated, the I/O pins will assume the CAN bus functions. The module 
will transmit and receive
CAN bus messages as described in subsequent sections.

Loopback Mode
If the Loopback mode is activated, the module will connect the internal 
transmit signal to the
internal receive signal at the module boundary. The transmit and receive 
pins revert to their
PORT I/O function.
The transmitter will receive an acknowledge for its sent messages. 
Special hardware will
generate an acknowledge for the transmitter.

dann ist mir schon klar, wieso ich da nix sehe...

ja und wie, bin gerade dabei das signal mit dem oszi darzustellen und 
den frame auseinander zu nehmen, damit ich seh obs richtige raus 
kommt...

wie ist das mit den SID und EID?

gibts da was zu beachten?

stimmen die so in meinem progi?

ah okay, mit dem SID, bzw. EID stelle ich dann an den einzelnen Knoten 
ein, welche der vielen nachrichten empfangen werden kann, bzw. werden 
darf.
ist also bildlich die adresse des senders (also die maske) und der 
filter entscheidet dann, ob angenommen werden darf via vergleich?

Knoten A:

SID: 1
Filter: 2

Knoten B:

SID: 2
Filter: 1

----> Knoten B, kann nachrichten von A empfangen und umgekehrt, wenn 
jetzt aber eine nachricht mit SID: 3 kommt, dann kann weder A noch B 
empfangen?

also wenn ich alle masken auf 0 gesetzt habe, dann geht alles durch, wie 
du geschrieben hast...

weißt du was der unterschied zwischen

message acceptance filter (CiRXFnSID)

und

acceptance filter mask (CiRXMnSID)

ist?

also irgendwie check ich das nicht....

ich bekomme vom bus einmal den identifier und die daten

identifier -> SID oder EID

dann habe ich den filter und die maske

kannst du mir das irgendwie an einem bsp. erklären?

z.b.

SID = 0x3BF = 1111011111   -> das ist der SID, der vom Knoten B stammt

Knoten A empfängt SID und Data

Filter & Maske ?

aha, also muss ich mir das so vorstellen:

SID = 0x7BF = 11111011111   Knoten B

Acceptance mask: Knoten A

CiRXMnSID = 0x000 = 00000000000  -> alle kommenden id`s werden 
durchgelassen

CiRXMnSID = 0x700 = 11100000000  -> nur die bits <10:8> werden an den 
filter weitergegeben

Acceptance filter: Knoten A

CiRXFnSID = 0x 7FF = 11111011111  -> nur diese ID wird erlaubt

-> alle bits werden verglichen, message kommt nur durch, wenn bits, die 
durch die maske kommen mit filter übereinstimmen


???

gut dann hab ich das jetzt verstanden....

jetzt ist mir gerade noch was anderes aufgefallen:

wenn ich das signal am scope anschaue das ich sende...ist das immer 
gleich...egal, ob ich daten im register C1TX0B1 = 0xFF
stehen hab oder net...

das was über den CANH rausgeht sollte doch normalerweise so aufgebaut 
sein:

Start of frame <1>
SID <11>
RTR <1>
IDE <1>
RB0 <1>
DLC <4>
Data <8>
CRC <16>
ACK <2>
End of Frame <7>

<anzahl der bits>

im anhang hab ich die beiden scope-auszüge

einmal mit C1TX0B1 = 0x0 und dann mit 0xFF

--> wenn ich mir das so anschau, dann mach ich doch wohl noch irgendwo 
einen fehler....

hier der 2te ausdruck vom scope

ich hab nur einen knoten...vorerst...den zweiten knoten bau ich aber 
genauso auf wie den ersten, änder nur die sid und die maske ab...

das die nachricht ständig gesendet wird, klar..hab ich ja so ins prog. 
geschrieben...nur was da gesendet wird...damit komm ich noch nicht 
klar..

normalerweise müsste ich doch aus dem signal am CANH das Frame auslesen 
können und so vergleichen, was ich im prog gesendet hab und was da jetzt 
wirklich rauskommen tut...weil das scheint ja laut scope nicht daselbige 
zu sein..*leider*

wäre ja zu schön gewesen, wenns gleich ohne probleme gefunzt hätt...lol

okay, mach ich mal,bzw. bin schon dabei

mit gleich bei den bildern meinte ich aber nicht, dass die message immer 
gleich bleibt, sondern

das wenn ich das wort 0xff schicke am scope bild 1 kommt

das wenn ich das wort 0x0 schicke am scope bild 2 kommt

jedesmal neu gestartet und initialisiert, deswegen meinte ich das ich da 
nen unterschied sehen müsste

wenn ich 0xff und 0x00 hintereinander schicken würde, dann wärs mir auch 
klar, aber da erst das eine wort (1), dann ein neues programming und 
dann wort 2 geschickt wird....kommt mir das spanisch vor

misst jetzt muss ich mir erst noch so nen can-treiber besorgen, sonst 
kann ich den 2ten knoten nicht anbinden....

naja ich mach mal und poste wieder wenns da ist..

merci

und nen schönes wochenende

also ich hab jetzt versucht den zweiten knoten auf meinem dsPICDem 28 zu 
realisieren, scheitere aber da noch an der mangelnden Beschreibung zu 
dem Board. Die Register für den Can bleiben bei einem dsPIC30F4012 
gleich wie beim 6014, aber die portinitialisierung, bzw. beim clock ist 
irgendwas anders...des funzt net....ich probier mal weiter. Das mit den 
überkreuzten Leitungen lass ich mal lieber, net das ich das aus dusselei 
dann so lass und mich wunder wenn nichts geht....lol

ui ui ui....

jetzt geht ein neuer bug um....habs mal in einem anderen thread 
gepostet...

bitte mal durchlesen wenns geht...

danke

Thomas


Beitrag "dsPIC30F6014 using 2 CAN-Module"

So langsam zweifel ich wieder daran ob ich das richtig gemacht habe...

Wenn ich das Progi so, wie ich es geschrieben habe auf dem gleichen 
board, aber mit verschiedenen ds teste, kommt jedesmal ein anderes 
signal am ende raus....

kann es sein, dass ich beim init, bzw. bei den timings einen 
gravierenden fehler drinn habe, so dass ich wenn ich was senden will, 
immer das error-frame gesendet bekomme?

hab mich mit der frage noch nicht auseinandergesezt. kennst du dich 
damit aus?