Funktionierendes CAN Bus Projekt entwickeln unter Bascom

Hallo zusammen,
ich möchte gemeinsam mit mehreren (und Euch) enlich mal das Problem des CAN Busses unter Bascom lösen.
Ich habe mich zu der Version mit dem MCP 2115 Controller und einem Mega 8 entschieden. Der MCP 2515 ist ein CAN Bustreiber auf SPI Basis, somit kann man sinnvoll die Programmierports nutzen.

Ich weiß, diese Kombination gibt es schon in diesem Forum - und das auch noch funktionstätig - jedoch nur unter C!
ich habe viel im Netz gesucht und bin leider immer nur unter C fündig geworden und ein nicht vollendetes Bascomprogramm.

Ich denke das kann man auch unter Bascom lösen, vielleicht gemeinsam.

Ich habe mal in einem Forum einen Quelltext unter Bascom gefunden, der schafft auch irgendeine Kommunikation mit dem Chip, aber senden tut das Ding nix. Man muss nur zwischen den SPI Befehlen einen 21ms wait Befehl einfügen.



Zum Verständniss des Chips MCP 2515 und die Funktion um senden zu können:

1. Slave Select auf Masse und das Manuel
2. Register 1 anwählen und mit Daten beschreiben
3. Register 2 anwählen und mit Daten beschreiben
4. Register 3 anwählen und mit Daten beschreiben
5. Slave Select wieder manuell auf Potential

...... und die Kiste müsste senden.

Kann mir das jemand bestätigen? Mal abgesehen das vorher ein Reset und der Takt eingestellt werden müssen.

Besten Dank

Hi Michael_avr,

vielleicht hilft Dir dieses Buch?

Programmieren der AVR RISC Mikrocontroller mit BASCOM-AVR
von Claus Kühnel

2. Auflage - 2004

ISBN: 3-907857-04-6

Dort ist u. a. der CAN-Bus inkl Softwarebeispiel beschrieben - evtl. als Anregung.

CAN´sche Gruesse

Karl

Hallo,

warum denn nicht ein AVR mit einbebauten CAN like 90CAN32?

An den werde ich mich bei gelegenheit machen, Atmel war so freundlich mir ein paar Muster zur Verfügung zu stellen ;-)

Gruß

Danke für Eure Antworten.
Ich bin selber Besitzer des Bascom Buches- wie ich finde ein sehr gutes Buch, hier ist auch ein Programm für den Can Baustein von Atmel mit drin.
Danke an Karl, dich empfehle auch gerne jedem dieses Buch.

Jedoch möchte ich bei diesem Projekt nicht auf nur einen speziellen AVR angewiesen sein, der noch dazu mit 13,15€ sehr teuer ist. Weiterer Nachteil ist das TQFP Gehäuse mit 64 Pins.

Meine Testboards haben an Bauteilen ca. 10€ gekostet, inklusive der CAN Komponenten und einem Mega8. Dies Board kann noch weitere 8 Ein/ Ausgänge verwalten und hat eine Anschluss für ein LCD, wahlweise somit auch freie Ports.
Als modulares System denke ich ganz gut – Steuerplatine dran und schon sind Hausbuskomponenten für unter 20€ fertig!

Also MCP 2515 ist für eine vernünftige Kombination mit anderen Chips schon sehr sinnvoll!

Und wie gesagt eine Kommunikation steht mit dem oberen Programm.
Gruß

hier mal ein Beispielcode von mir:

Code:

---


$regfile = "m16def.dat"                                  ' ATMega16
$crystal = 14745600                                      ' Baudratenquarz
$hwstack = 40                                              ' default use 32 for the hardware stack
$swstack = 80                                              ' default use 10 for the SW stack
$framesize = 90

Declare Sub Can_init()
Declare Sub Mcp2515_write(byval Reg_add As Byte , Byval Reg_val As Byte)
Declare Sub Mcp2515_bitmodify(byval Reg_add As Byte , Byval Reg_mask As Byte , Byval Reg_val As Byte)
Declare Function Mcp2515_read(byval Reg_add As Byte) As Byte

Mcp2515cs Alias Portb.4
Config Mcp2515cs = Output

Const Cmd_read = &H03                                      ' Read Command
Const Cmd_write = &H02                                      ' Write Command
Const Cmd_bitmodify = &H05                                  ' Bit-modify Command
Const Cmd_readstatus = &HA0                                ' Read Status Command (poll)
Const Cmd_read_rx_status = &HB0
Const Cmd_reset = &HC0                                      ' Reset Command
Const Cmd_rts0 = &H81
Const Cmd_rts1 = &H82


Const Caninte = &H2B
Const Canctrl = &H0F
Const Canstat = &H0E                                        ' Statusregister
Const Eflg = &H2D                                          ' Error Flag Register
Const Cnf3 = &H28                                          ' Configuration Register 3
Const Cnf2 = &H29                                          ' Configuration Register 2
Const Cnf1 = &H2A                                          ' Configuration Register 1
Const Txb0ctrl = &B00110000                                ' Transmit Buffer 0 Control Register
Const Txb0sidh = &B00110001                                ' Transmit Buffer 0 Std Identifier High
Const Txb0sidl = &B00110010                                ' Transmit Buffer 0 Std Identifier Low
Const Txb0eid8 = &B00110011                                ' Transmit Buffer 0 Ext Identifier High
Const Txb0eid0 = &B00110100                                ' Transmit Buffer 0 Ext Identifier Low
Const Txb0dlc = &B00110101                                  ' Transmit Buffer 0 Data Length Code
Const Txb0d0 = &B00110110                                  ' Transmit Buffer 0 Data Byte 0
Const Txb0d1 = &B00110111                                  ' Transmit Buffer 0 Data Byte 1
Const Txb0d2 = &B00111000                                  ' Transmit Buffer 0 Data Byte 2
Const Txb0d3 = &B00111001                                  ' Transmit Buffer 0 Data Byte 3
Const Txb0d4 = &B00111010                                  ' Transmit Buffer 0 Data Byte 4
Const Txb0d5 = &B00111011                                  ' Transmit Buffer 0 Data Byte 5
Const Txb0d6 = &B00111100                                  ' Transmit Buffer 0 Data Byte 6
Const Txb0d7 = &B00111101                                  ' Transmit Buffer 0 Data Byte 7
Const Rxm0sidh = &B00100000                                ' Receive Buffer 0 Std Identifier High
Const Rxm0sidl = &B00100001                                ' Receive Buffer 0 Std Identifier Low
Const Rxm0eid8 = &B00100010                                ' Receive Buffer 0 Ext Identifier High
Const Rxm0eid0 = &B00100011                                ' Receive Buffer 0 Ext Identifier low
Const Rxm1sidh = &B00100100                                ' Receive Buffer 1 Std Identifier High
Const Rxm1sidl = &B00100101                                ' Receive Buffer 1 Std Identifier Low
Const Rxm1eid8 = &B00100110                                ' Receive Buffer 1 Ext Identifier High
Const Rxm1eid0 = &B00100111                                ' Receive Buffer 1 Ext Identifier low

Const Rxb0ctrl = &H60
Const Rxb1ctrl = &H70


' Hardware SPI-Schnittstelle konfigurieren
Config Portb.6 = Input
Config Portb.5 = Output
Config Portb.7 = Output
Spcr = &B01010010

Config Pind.2 = Input
Config Int0 = Falling
On Int0 Int_canint
Enable Int0
Enable Interrupts

Call Can_init()

Do
  ' Zu übertragende Daten setzen:
  Mcp2515_bitmodify Txb0ctrl , &B00000011 , &B00000011    ' TX-Konfiguration
  Mcp2515_write Txb0sidh , &B01010101                      ' Empfängeradresse setzen
  Mcp2515_write Txb0sidl , &B01010101                      ' Empfängeradresse setzen
  Mcp2515_write Txb0dlc , &H04                            ' Paketlänge festlegen
  Mcp2515_write Txb0d0 , &B01010101                        ' Zu übertragende Daten setzen
  Mcp2515_write Txb0d1 , &B01010101                        ' Zu übertragende Daten setzen

  ' Übertragung auslösen
  Reset Mcp2515cs
  Waitus 10
  Spdr = Cmd_rts0
  Do
  Loop Until Spsr.spif = 1
  Waitus 10
  Set Mcp2515cs

Loop

Sub Can_init()
  Local Can_tmp As Byte

  Reset Mcp2515cs

  ' Reset MCP2515
  Can_tmp = Cmd_reset
  Spdr = Can_tmp
  Do
  Loop Until Spsr.spif = 1
  Set Mcp2515cs

  Waitms 2000
  Mcp2515_write Canctrl , &B10001000                      ' low nibble: 3=OSM 2=CLK-Pin 1-0=CLK Divider
  Print "speed change done"

  ' F MCP2515 = 16MHz
  Can_tmp = Eram_param_baudrate
  Select Case Can_tmp
      Case 0:
        ' CAN 31,25 KHz
        Mcp2515_write Cnf1 , &B00001111
      Case 1:
        ' CAN 62,5 KHz
        Mcp2515_write Cnf1 , &B00000111
      Case 2:
        ' CAN 125 KHz
        Mcp2515_write Cnf1 , &B00000011
      Case 3:
        ' CAN 250 KHz
        Mcp2515_write Cnf1 , &B00000001
      Case 4:
        ' CAN 500 KHz
        Mcp2515_write Cnf1 , &B00000000
      Case Else :
        Mcp2515_write Cnf1 , &B00001111
  End Select
  Mcp2515_write Cnf2 , &B10010000                          ' Cnf2 = &H29
  Mcp2515_write Cnf3 , &B00000010                          ' Cnf3 = &H28
  Mcp2515_write Caninte , &B00000011
  Mcp2515_write Rxb0ctrl , &B01100000
  Mcp2515_write Rxb1ctrl , &B01100000
  Mcp2515_write Rxm0sidh , 0                              ' Empfängeradressen auf 0, Filter aus
  Mcp2515_write Rxm0sidl , 0
  Mcp2515_write Rxm0eid8 , 0
  Mcp2515_write Rxm0eid0 , 0
  Mcp2515_write Rxm1sidh , 0
  Mcp2515_write Rxm1sidl , 0
  Mcp2515_write Rxm1eid8 , 0
  Mcp2515_write Rxm1eid0 , 0
  Mcp2515_bitmodify Canctrl , &B11100000 , &B00000000
  'Mcp2515_write Canctrl , &B00000000                      ' low nibble: 3=OSM 2=CLK-Pin 1-0=CLK Divider
  'Mcp2515_write Canctrl , &HE0
End Sub

Sub Mcp2515_bitmodify(reg_add , Reg_mask , Reg_val)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_bitmodify
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Waitms 2
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_mask
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_val
  Do
  Loop Until Spsr.spif = 1
  Mcp2515cs = 1
End Sub

Sub Mcp2515_write(reg_add , Reg_val)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_write
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Waitms 2
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_val
  Do
  Loop Until Spsr.spif = 1
  Mcp2515cs = 1
End Sub


Function Mcp2515_read(reg_add)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_read
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = 0
  Do
  Loop Until Spsr.spif = 1
  Mcp2515_read = Spdr
  Mcp2515cs = 1
End Function

---

Hallo Vitis,

wo hast du die Variable "Eram_param_baudrate" her?
Hast du so'ne Art Haus-Automation damit programmiert?
MfG
Stromi

Der Code ist nur n Schnipsel von nem ziemlich großen Projekt.
Sie wird von Randbedingungen festgelegt und dient zur Festlegung
der Baudrate, die in meinem Projekt halt variabel ist, daher die
select-case.

Hallo zusammen,

ich möchte mal auf den Grundgedanken von Michael_avr zurück kommen.
Ein gewöhlicher AVR Chip mit MCP 2515 auf der einen und ein paar Ein- und Ausgängen auf der anderen Seite sowie ggf ein LCD Display.
Das alles für einen verträglichen Preis mit dem auch ein Hobbyelektroniker ein paar Chrashs wegstecken kann.

Ich sitze jetzt schon eine lange Zeit an diesem Thema und gebe immer wieder vor Verzweiflung auf. Ich denke nach den unzähligen Forenbeiträgen über dieses Thema, dass es bisher keinem gelungen ist, ein solches Projekt in Bascom in die Praxis umzusetzen.

Fangen wir doch einmal einfach an.
Über den CAN Bus soll eine LED mit einem Taster ein und aus geschaltet werden. Wie kann man das machen?
Wie sieht die Hardware und die Software aus?

Es wäre schön wenn sich an dieser Stelle viele beteiligen würden, so dass wir in kleinen Schritten zu einem Ergebnis kommen können.

Tobias

Hallo

Ist auch daran gedacht/erweitert werden den CAN Bus im Automobil abzufragen? Also sowohl das OBD, der CANbus als auch die Programmierung etwas transparenter zu machen ?

MFG

Ob Du in Bascom oder C oder ASM oder sonstwas programmierst ist im
Prinzip Wurst. Ich hab mit meinem Projekt die Übertragung von
Daten soweit geregelt bekommen, war gar nicht so knifflig.
Poste doch einfach Dein Problemkind, evtl. fällt mir ja was dazu ein.

Ne LED per CAN und MCP schalten ist im Prionzip kein
Thema, Du musst nur den MCP passend konfigurieren und wenn Du
das dann hinbekommen hast ists egal ob Du ne LED schaltest oder
Gigabyte an Daten überträgst, das Prinzip ist das Gleiche.

Ach so, ich empfehle auch den Einsatz eines PCA82C250 als Buskoppler

Hallo Vitis,

du bist offenbar ganz schön Fit was die Programmierung in Bascom und dem CAN-Bus angeht.
Könntest du nichtmal eine Schaltung aus AVR, einem CAN Chip und einem Beispiel Code ins Forum einstelle?
Ich denke du würdest damit einigen eine große Freude bereiten!

Tobias

Da ich gerade eine ähnliche Anforderung habe, würde ich mich auch sehr darüber freuen !

Grüße !

Hallo,

ich habe vor einiger Zeit eine Schaltung gefunden mit der ein Atmega8 am Can Bus zu betreiben ist. Leider war dort keine Bascom sondern nur C-Software vorhanden. http://www.kreatives-chaos.com/artikel/can-testboard

Kann jemand sagen ob der hier beschriebene Schaltungsaufbau auch mit Bascom funktioniert?

Hi,

klar tut er das, wie Vitis schon sagte: warum sollte eine Schaltung mit einem Compiler funktionieren, mit einem anderen aber nicht (mal von extrem Timing-kritischen Sachen abgesehen)?

Direkt mit einem Bascom Beispiel kann ich nicht dienen, dafür kenne ich den Compiler zu wenig, ich könnte höchstens anbieten eventuellen Code zu testen bzw. mal zu schauen ob mir logische Fehler auffallen. Den MCP2515 kenne ich mittlerweile fast auswendig ;-)

Grüße
Fabian (der die Schaltung erstellt hat :-b)

Hallo Fabian

Dann schreibe doch mal ein kleines Tutorial im WIKI.
Unser Dank wird dir ewig hinterherhinken. :-)

MFG

klar könnte man n wiki schreiben, ich find das aber nicht so den Brüller für n Forum. Ich persönlich bevorzuge die Methode: Hilfe zur Selbsthilfe. Die Copy & Paste-Variante find ich nicht so doll. Es geht doch auch ums Lernen und Verstehen, oder?

Hi Vitis,

bin grundsätzlich deiner Meinung. Für meinen teil muss ich allerdings sagen dass ich entweder zu doof bin oder das Thema zu komplex ist.
Offensichtlich geht es sehr vielen so da es eigentlich noch gar keinen Bascom Code gibt der nur sich nur annähernd damit beschäftigt! Ich weis wovon ich rede da ich schon mind. 2 Jahre auf der Suche bin.

Eine Einstig wärde daher sicher angebracht. Fabian hat einen sehr guten Beitrag auf seiner Seite geleistet. Allerdings nur in C.
Wenn es in Bascom tatsächlich möglich ist, ist jetzt die beste Möglichkeit es nach zu machen!

Tobias

Ich sehe es wie Tobias: Grundsätzlich stimmt das, aber wenn man ständig gefrustet aufgeben muss, weil man bestimmte Kniffe nicht vorher gezeigt bekommt, resigniert man eben. Eine kleine Vorlage, auf die man dan aufbauen und an der man lernen kann, macht sicher Sinn. In der Grundschule wird einem zuerst auch gezeigt, wie man addiert bevor man es selber muss...

Also ich versteh nicht ganz wo Ihr die Probleme seht.
In einem vorangegangenen Posting hab ich doch die Grundzüger der
Kommunikation mit dem MCP geschrieben.
Senderoutine, Konfiguration etc. Gut, die Empfangsroutine fehlt,
aber die ist dann auch nicht mehr schwer daraus abzuleiten.
Dann hackt Ihr noch Euer Programm drumherum und fertig ist die
Laube.
Zu der Geschichte Grundschule ... es macht auch andersrum wenig
Sinn sich mit Differentialrechnung zu beschäftigen, wenn die
Grundrechenarten nicht sitzen O:)

o.k.
ich mache noch einmal einen versuch mit deinem Programm zurecht zu kommen.
Könntest du aber bitte auch noch einmal das Empfangen beschreiben!

Wenns funktioniert werde ich es hier für alle veröffentlichen so dass damit eines der letzten großen Rätsel gelöst ist ;-)

Hallo Vitis,

ich habe jetzt eine Schaltung, analog zu der des CanTestBoard aufgebaut.
Die dort genutzten Pins musste ich etwas anpassen.

Den Code habe ich wie folgt angepasst:

Code:

---

$regfile = "m8def.dat"                                      ' ATMega8
$crystal = 7372800                                          ' Baudratenquarz der AVR (MCP2515 mit 16MHz)
$hwstack = 40                                              ' default use 32 for the hardware stack
$swstack = 80                                              ' default use 10 for the SW stack
$framesize = 90

Declare Sub Can_init()
Declare Sub Mcp2515_write(byval Reg_add As Byte , Byval Reg_val As Byte)
Declare Sub Mcp2515_bitmodify(byval Reg_add As Byte , Byval Reg_mask As Byte , Byval Reg_val As Byte)
Declare Function Mcp2515_read(byval Reg_add As Byte) As Byte

Mcp2515cs Alias Portb.4                                            'MISO
Config Mcp2515cs = Output

Const Cmd_read = &H03                                      ' Read Command
Const Cmd_write = &H02                                      ' Write Command
Const Cmd_bitmodify = &H05                                  ' Bit-modify Command
Const Cmd_readstatus = &HA0                                ' Read Status Command (poll)
Const Cmd_read_rx_status = &HB0
Const Cmd_reset = &HC0                                      ' Reset Command
Const Cmd_rts0 = &H81
Const Cmd_rts1 = &H82


Const Caninte = &H2B
Const Canctrl = &H0F
Const Canstat = &H0E                                        ' Statusregister
Const Eflg = &H2D                                          ' Error Flag Register
Const Cnf3 = &H28                                          ' Configuration Register 3
Const Cnf2 = &H29                                          ' Configuration Register 2
Const Cnf1 = &H2A                                          ' Configuration Register 1
Const Txb0ctrl = &B00110000                                ' Transmit Buffer 0 Control Register
Const Txb0sidh = &B00110001                                ' Transmit Buffer 0 Std Identifier High
Const Txb0sidl = &B00110010                                ' Transmit Buffer 0 Std Identifier Low
Const Txb0eid8 = &B00110011                                ' Transmit Buffer 0 Ext Identifier High
Const Txb0eid0 = &B00110100                                ' Transmit Buffer 0 Ext Identifier Low
Const Txb0dlc = &B00110101                                  ' Transmit Buffer 0 Data Length Code
Const Txb0d0 = &B00110110                                  ' Transmit Buffer 0 Data Byte 0
Const Txb0d1 = &B00110111                                  ' Transmit Buffer 0 Data Byte 1
Const Txb0d2 = &B00111000                                  ' Transmit Buffer 0 Data Byte 2
Const Txb0d3 = &B00111001                                  ' Transmit Buffer 0 Data Byte 3
Const Txb0d4 = &B00111010                                  ' Transmit Buffer 0 Data Byte 4
Const Txb0d5 = &B00111011                                  ' Transmit Buffer 0 Data Byte 5
Const Txb0d6 = &B00111100                                  ' Transmit Buffer 0 Data Byte 6
Const Txb0d7 = &B00111101                                  ' Transmit Buffer 0 Data Byte 7
Const Rxm0sidh = &B00100000                                ' Receive Buffer 0 Std Identifier High
Const Rxm0sidl = &B00100001                                ' Receive Buffer 0 Std Identifier Low
Const Rxm0eid8 = &B00100010                                ' Receive Buffer 0 Ext Identifier High
Const Rxm0eid0 = &B00100011                                ' Receive Buffer 0 Ext Identifier low
Const Rxm1sidh = &B00100100                                ' Receive Buffer 1 Std Identifier High
Const Rxm1sidl = &B00100101                                ' Receive Buffer 1 Std Identifier Low
Const Rxm1eid8 = &B00100110                                ' Receive Buffer 1 Ext Identifier High
Const Rxm1eid0 = &B00100111                                ' Receive Buffer 1 Ext Identifier low

Const Rxb0ctrl = &H60
Const Rxb1ctrl = &H70


' Hardware SPI-Schnittstelle konfigurieren
'Config Portb.6 = Input                'Vitis
'Config Portb.5 = Output        'Vitis
'Config Portb.7 = Output        'Vitis

Config Portb.4 = Input
Config Portb.3 = Output
Config Portb.5 = Output
Spcr = &B01010010

'Config Pind.2 = Input                'Vitis
Config Pind.3 = Input
Config Int0 = Falling
On Int0 Int_canint
Enable Int0
Enable Interrupts

Call Can_init()

Do
  ' Zu übertragende Daten setzen:
  Mcp2515_bitmodify Txb0ctrl , &B00000011 , &B00000011    ' TX-Konfiguration
  Mcp2515_write Txb0sidh , &B01010101                      ' Empfängeradresse setzen
  Mcp2515_write Txb0sidl , &B01010101                      ' Empfängeradresse setzen
  Mcp2515_write Txb0dlc , &H04                            ' Paketlänge festlegen
  Mcp2515_write Txb0d0 , &B01010101                        ' Zu übertragende Daten setzen
  Mcp2515_write Txb0d1 , &B01010101                        ' Zu übertragende Daten setzen

  ' Übertragung auslösen
  Reset Mcp2515cs
  Waitus 10
  Spdr = Cmd_rts0
  Do
  Loop Until Spsr.spif = 1
  Waitus 10
  Set Mcp2515cs

Loop

Sub Can_init()
  Local Can_tmp As Byte

  Reset Mcp2515cs

  ' Reset MCP2515
  Can_tmp = Cmd_reset
  Spdr = Can_tmp
  Do
  Loop Until Spsr.spif = 1
  Set Mcp2515cs

  Waitms 2000
  Mcp2515_write Canctrl , &B10001000                      ' low nibble: 3=OSM 2=CLK-Pin 1-0=CLK Divider
  Print "speed change done"

  ' F MCP2515 = 16MHz
  Can_tmp = Eram_param_baudrate
  Select Case Can_tmp
      Case 0:
        ' CAN 31,25 KHz
        Mcp2515_write Cnf1 , &B00001111
      Case 1:
        ' CAN 62,5 KHz
        Mcp2515_write Cnf1 , &B00000111
      Case 2:
        ' CAN 125 KHz
        Mcp2515_write Cnf1 , &B00000011
      Case 3:
        ' CAN 250 KHz
        Mcp2515_write Cnf1 , &B00000001
      Case 4:
        ' CAN 500 KHz
        Mcp2515_write Cnf1 , &B00000000
      Case Else :
        Mcp2515_write Cnf1 , &B00001111
  End Select
  Mcp2515_write Cnf2 , &B10010000                          ' Cnf2 = &H29
  Mcp2515_write Cnf3 , &B00000010                          ' Cnf3 = &H28
  Mcp2515_write Caninte , &B00000011
  Mcp2515_write Rxb0ctrl , &B01100000
  Mcp2515_write Rxb1ctrl , &B01100000
  Mcp2515_write Rxm0sidh , 0                              ' Empfängeradressen auf 0, Filter aus
  Mcp2515_write Rxm0sidl , 0
  Mcp2515_write Rxm0eid8 , 0
  Mcp2515_write Rxm0eid0 , 0
  Mcp2515_write Rxm1sidh , 0
  Mcp2515_write Rxm1sidl , 0
  Mcp2515_write Rxm1eid8 , 0
  Mcp2515_write Rxm1eid0 , 0
  Mcp2515_bitmodify Canctrl , &B11100000 , &B00000000
  'Mcp2515_write Canctrl , &B00000000                      ' low nibble: 3=OSM 2=CLK-Pin 1-0=CLK Divider
  'Mcp2515_write Canctrl , &HE0
End Sub

Sub Mcp2515_bitmodify(reg_add , Reg_mask , Reg_val)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_bitmodify
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Waitms 2
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_mask
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_val
  Do
  Loop Until Spsr.spif = 1
  Mcp2515cs = 1
End Sub

Sub Mcp2515_write(reg_add , Reg_val)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_write
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Waitms 2
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_val
  Do
  Loop Until Spsr.spif = 1
  Mcp2515cs = 1
End Sub


Function Mcp2515_read(reg_add)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_read
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = 0
  Do
  Loop Until Spsr.spif = 1
  Mcp2515_read = Spdr
  Mcp2515cs = 1
End Function

---

Und jetzt gleich ein paar Fragen:
1. Die Adressierung der einzelnen Knoten spielt eine wichtige Rolle.
Wo ist die Adresse dieses Konoten festgelegt?
2. Verstehe ich es richtig dass der Empfängerknoten unter &B01010101 zu erreichen ist
3. Woraus leitest du die Peketlänge "&H04" ab?


Tobias

Na ich freue mich, dass hier ein wenig schwung wieder rein gekommen ist.

Ich kann mich nur oben anschließen; Ich habe ca. 2Jahre versucht mir selber c beizubringen und wurde leider nur von Francis Büchern unterstützt.

Ich habe aufgegeben und Bascom entdeckt - ich war nach zwei Tagen soweit LCD Displays einwandfrei zu programmieren.....
Jedoch glaube ich in Bezug auf MCP das ich die Grundrechenarten NICHT verstanden habe. Das Mistding kommuniziert einfach nicht mit mir!

Zum übersetzen von C ins viel leichtere Bascom reichts bei mir leider auch nicht....

Ich habe aber mal etwas gelernt und mich mit dem I2C Bus beschäftigt, vielleicht kann ich ja ein wenig Wissen transferieren....
Habe zumindest den I2C zu laufen bekommen (externe Uhr und Porterweiterung als zusätzliche Ausgänge!)

Werde mich nochmals an den MCP machen

Grüße und witer forschen, irgendwann kriegen wir das hin!

Michael

Die Adresse des Senderknotens ist die ID, im vorliegenden Codeschnipsel hier 0. Ist aber unerheblich, weil der Absender nicht mit übertragen wird im CAN-Bus-Frame.

Als Empfänger ist richtig der &B01010101 &B01010101 genannt. Die Zeichenfolge verwend ich gern, weil sie im Oszi schön angesehen werden kann und so das Bittiming für die Übertragungsrate schön nachgemesen werden kann.

Die Paketlänge ist falsch, sollte hier 2 sein weil zwei Bytes gesendet werden, das hast du richtig erkannt. Die übrigen 2 Bytes wurden in meinem Beispiel einfach als 0 gesendet, da kein weiteres Byte geschrieben wurde

@Vitis: Na klar, die Grundrechenarten lerne ich ja auch immernoch. Ist halt alles nicht so einfach, aber ich muss schnell mit meinen Aufgaben wachsen. :)

Teste das mal, vorher noch die Standartwerte für den Prozessor einsetzen
Kommt aus dem Bascom-Forum

Code:

---

$sim
Config Spi = Soft , Din = Pinb.2 , Dout = Portb.1 , Ss = None , Clock = Portb.0
Dim C1 As Byte
Dim A(3) As Byte
Declare Sub Spi_write(byval Reg_add As Byte , Byval Reg_val As Byte)



Const Cmd_read = &H03                                      ' Read Command
Const Cmd_write = &H02                                      ' Write Command
Const Cmd_bitmodify = &H05                                  ' Bit-modify Command
Const Cmd_readstatus = &HA0                                ' Read Status Command (poll)
Const Cmd_reset = &HC0                                      ' Reset Command
Const Canctrl = &H0F

Const Cnf3 = &H28                                          ' Configuration Register 3
Const Cnf2 = &H29                                          ' Configuration Register 2
Const Cnf1 = &H2A                                          ' Configuration Register 1

Const Txb0ctrl = &H30                                      ' Transmit Buffer 0 Control Register
Const Txb0sidh = &H31                                      ' Transmit Buffer 0 Std Identifier High
Const Txb0sidl = &H32                                      ' Transmit Buffer 0 Std Identifier Low
Const Txb0eid8 = &H33                                      ' Transmit Buffer 0 Ext Identifier High
Const Txb0eid0 = &H34                                      ' Transmit Buffer 0 Ext Identifier Low
Const Txb0dlc = &H35                                        ' Transmit Buffer 0 Data Length Code
Const Txb0d0 = &H36                                        ' Transmit Buffer 0 Data Byte 0
Const Txb0d1 = &H37                                        ' Transmit Buffer 0 Data Byte 1
Const Txb0d2 = &H38                                        ' Transmit Buffer 0 Data Byte 2
Const Txb0d3 = &H39                                        ' Transmit Buffer 0 Data Byte 3
Const Txb0d4 = &H3A                                        ' Transmit Buffer 0 Data Byte 4
Const Txb0d5 = &H3B                                        ' Transmit Buffer 0 Data Byte 5
Const Txb0d6 = &H3C                                        ' Transmit Buffer 0 Data Byte 6
Const Txb0d7 = &H3D                                        ' Transmit Buffer 0 Data Byte 7


 Const Rts0 = &H81

Print "Welcome!"

Config Pinb.3 = Output
Config Pinb.4 = Output
Csn Alias Portb.3
Can_reset Alias Portb.4



Spiinit
Can_reset = 1

Print "Reset Done!"


'RESET
Csn = 0
A(1) = Cmd_reset
Spiout A(1) , 1
Csn = 1

Wait 2


'Controls
Spi_write Canctrl , &B00000100
Print "speed change done"

Spi_write Cnf1 , &H07                                      '03
Spi_write Cnf2 , &H90                                      '90
Spi_write Cnf3 , &H02                                      '02



'Do

'Spi_write Txb0d0 , 55                                      'send motor speed

'Csn = 0
'A(1) = &B10000001
'Spiout A(1) , 1
'Csn = 1

 Wait 1
 Print "here we go"


 Wait 1

 Print "senden"


 Spi_write Txb0sidh , &HFF
 Spi_write Txb0sidl , &H00
 Spi_write Txb0dlc , &H3


 Csn = 0
A(1) = Rts0
Spiout A(1) , 1
Csn = 1


' Loop



End


Sub Spi_write(byval Reg_add As Byte , Byval Reg_val As Byte)

Print "Reg: " ; Reg_add ; " Val: " ; Reg_val

A(1) = Cmd_write
A(2) = Reg_add
A(3) = Reg_val
Csn = 0
Spiout A(1) , 3
Csn = 1

End Sub

---

Hey Super,
so langsam kommt ja wirklich was zusammen. Vielleicht bekomme ich meinen Can-Bus so jetzt doch noch zum laufen.

Stromi: Passt dein Programm jetzt zu dem Schaltplan den Elkokiller eingestellt hat.
Ich vermisse bei die die Tasterabfrage.
Wenn ich dein Programm richtig verstehe, dann überträgst du doch einfach nur ein telegram über den Bus?!

Daniel

Hallo Daniel,
ist nicht von mir. Schaltplan kannst du ja mal vergleichen Das kreative Chaos hat ihn ja online. Hatte es mal aufgebaut, hab' es auch nicht mehr, weil "GEFRUSTET" demontiert :-)
Aber im Simulator geht es.
Gibt ja auch einige schlaue Leute hier, ev. schauen die sich das an.

Hoffentlich keine Erinnerungen an einen Mathelehrer, der pflegte immer zu sagen:
Wenn ihr was nicht verstanden habt, fragt mich.
Wenn man ihn dann gefragt hatte sagte er:
SOLL ICH EUCH DAS EIN MAL EINS ERKLÄREN?
spart "Erklärzeit" und man bleibt immer der Schlaue!

Man kann die Software-SPI verwenden, geht fast genauso gut wie die Hardware, aber halt nur fast. Sie hat den Nachteil, dass sie deutlich langsamer ist und die Codegröße in die Höhe schnellt. Der AVR hat ne Hardware-SPI und die würde ich auch raten zu verwenden, wenn die Datenübertragung auch hurtig vonstatten gehen soll ;)

@Michael_avr
Wenns mit C nicht klappt und mit Bascom schon, dann verlässt Du dich scheinbar voll auf die Bascominternen Funktionen. Das ist so auch ganz ok, knifflig wirds bei Peripheriebausteinen, die nicht den Bascomfunktionen entsprechen. LCDs sind da n schönes Beispiel. Dann stehst Du nämlich genau da wo du mit C hingekommen bist. Wichtig bei der Programmierung egal welcher Sprache oder Syntax ist das Verstehen der zugrundeliegenden Logik. Sitzt die einmal ist der Rest drum herum nur Fassade. Ob die Sytax dann
if x=y then
endif

oder

if (x==y) {
}

ist ist Dir dann sowas von egal. Im Grunde unterscheiden sich die Programmiersprachen nur in ihrer Syntax und was halt der Interpreter oder Compiler daraus wurstelt. Obs dann C, C++, Bascom, Java, VBasic oder PHP ist macht Dir dann echt keinen Kummer mehr.
Mit C hättest Du halt den deutlichen Vorteil auch auf anderen Bausteinen wie ARM oder AVR32 zu werkeln. Für die Bascom-Fraktion wirds dann schon eng.

@nikolaus10
Ich für meinen Teil lass liber die Finger weg vom KFz-Bus, das kann (!) mächtig ins Auge gehen. Hab schon genug Blech verbogen und auch verbogen bekommen, mein Bedarf daran ist gedeckt.

Zum geposteten Code, also ich kann da auf den ersten Blick nix verkehrtes dran finden ... achso, doch evtl. Du setzt:

Spi_write Canctrl , &B00000100 also CLK-Pin aktiv, ok. Aber den REQUOP2 lässt Du 0. Das ist Bit 7, und ist zuständig dafür das der MCP in den Configuration-Mode geht und nur dann ist CNF1 - CNF3, Filter und Maskenregister änderbar.
Spi_write Cnf1 , &H07 '03
Spi_write Cnf2 , &H90 '90
Spi_write Cnf3 , &H02 '02
geht dann nicht. (Datenblatt Seite 55-56)

Na, das ist ja schonmal ein Prima Hinweis.
Vielleicht hole ich ja doch nochmal die Bauteile und baue das CAN-Teil wieder auf. Damit aus den "Nicht-CAN" ein "CAN-Do" wird. :-)
Danke Vitis

Ich habe auch gerade nochmal neue Teile bestellt und werde sofort nächste Woche loslegen.

Hallo,

ich hab mich auch ein wenig mit CAN-Bus befasst und dem MCP. Jetzt mal ne doofe Frage :

Wie mach ich es das ich zwei CAN-Bus-Controller (als Übersetzter) an einen AVR häng?

Es geht darum :

Ich hab ein Bordcomputer welcher an den CAN-Bus gehängt werden kann um Daten wie Drehzahl etc abzufragen. Da aber im BUS keine Aussentemperatur mitübertragen wird (aber der Bordcomputer sie anzeigen kann) wollte ich ein Zwischenmodul basteln welches einen A-Tempsensor abfrägt und und in den CAN-Bus (richtung BC) einschleift.

Wie müsste ich soetwas anstellen?

Grüße
Alex

@Alex
hast du diesen Bordcomputer in Bascom programmiert?
Gehe mal davon aus, sonst würdest du ja nicht im Bascom-Forum landen, kannst du den Code mal hier reinstellen?

Hi Stromi,

nein hab ich nicht. Ich hab den von nem Bekannten. Sonst würde ich den Code so anpassen das ein TempSensor abgefragt werden kann.
Den Adapter würde ich aber gerne in Bascom schreiben.

Hallo,

ich habe mal ein paar grundsätzliche Frage zum Anschluss des MCP2515!
Wenn ich über den ISP auf den CAN zugreife und damit eine eigene Beschaltung vornehme, wie kann ich diesen dann in Zukunft zum Programmieren nehmen?
Der AVR wertet doch ständig die Informationen des Busses aus. Dadurch kann es doch zu erheblichen Verzögerungen im Programm kommen!?
Ist es richtig dass der Atmega 8 über einen Interrupt vom MCP2515 angesprochen wird?

Ich bin echt froh dass wir diesmal offensichtlich eine funktionierende Schaltung hinbekommen!
Daniel =D>

@Duesentrieb:
Der ISP ist ja nur in Funktion wenn der Reset low gezogen wird (vom Programmierdongle). Ansonsten ist der AVR im normalen Arbeitsmodus und dann ist die ISP ne SPI-Schnittstelle. kommt sich also nicht direkt ins Gehege ... mal abgesehen vom Verify. Da kommts dann tatsächlich zu Differenzen beim Flashen. Nicht darüber wundern, einfach ignorieren :)

@Alex20q90
Mehr als einen MCP? ... naja, Du kannst natürlich x MCP anhängen, indem Du diese über Software-SPI benutzt. Dann kannst Du soviele anhängen wie Du Port-Pins zur Verfügung hast. Bascom unterstützt zwar meines Wissens nach nur eine Software SPI, aber die kannst Du recht einfach zu Fuß über Bitschupserei und Pingewackel emulieren.

Danke Vitis! D.h. der CAN-Controller wertet das Protokoll aus und gibt bei Bedarf einen Interrupt an den AVR.
Welche Empfängeradresse muss ich setzen um alle Nachrichten des Busses an den AVR weitergeleitet zu bekommen?
Damit würde ich doch dann testen können ob und was über den Bus geht (ein Oszi habe ich leider noch nicht)

Übrigens, programmieren kann ich nach der Schaltung, die hier auf der ersten Seite vorgestellt wurde, nur noch wenn ich den CAN Controller rausziehe!

Ja, habs schon gesehen, der Reset in der Schaltung geht auf den Reset vom ISP. Ist nicht gut. Den Reset vom MCP würd ich entweder per Pullup fest
legen oder auf nem Pin vom AVR, aber auch da nen Pullup mit dran.
Alle Nachrichten bekommst du mit ID 0 (sprich Null)

EDIT: Für solche Geschichten rate ich dringend zur Anschaffung eines Oszilloskopes !!! Das erspart zig Stunden Debuggen.
N Speicheroszi währ optimal, aber auch mit nem analogen kann man
schon sehr viel sehen. Beispielsweise ob der Oszillator schwingt, oder
auf dem CLK-Pin was kommt etc.

Hallo zusammen,

ich habe mich zwischenzeitlich mal an die Hardware gemacht und das hier beschriebene CAN-MEGA8 Modul nach dem Entwurf aus "kreatives-chaos.com" nachgebaut.
Nach regem Kontakt mit Vitis habe ich das folgende Programm in so weit angepasst dass es zumindes möglich sein sollte, eine Nachricht (welcher Taster gedückt wurde) über den CAN Bus zu senden.

Code:

---

'Testprogramm CAN Sender und Empfänger

$regfile = "m8def.dat"                                      ' ATMega8
$crystal = 7372800                                          ' Baudratenquarz der AVR (MCP2515 mit 16MHz)
$hwstack = 40                                              ' default use 32 for the hardware stack
$swstack = 80                                              ' default use 10 for the SW stack
$framesize = 90
$baud = 9600

' Allgemeine Config ************************************************************

Const Keys = 5                                              '5 angeschlossene Taster

Config Pinc.0 = Input                                      'Eingang 1 bis 5
Config Pinc.1 = Input
Config Pinc.2 = Input
Config Pinc.3 = Input
Config Pinc.4 = Input
Config Pinc.5 = Input

Config Portb.0 = Output                                    'Relaisausgang 1 bis 5
Config Portb.1 = Output
Config Portb.2 = Output
Config Portd.7 = Output
Config Portd.6 = Output


Dim I As Byte
Dim Key As Byte

Dim T1 As Bit                                              'Variable für Tasterzustand
Dim T2 As Bit
Dim T3 As Bit
Dim T4 As Bit
Dim T5 As Bit

Dim Taster As Byte

Portb.0 = 0                                                'Grunsstellung fixieren
Portb.1 = 0
Portb.2 = 0
Portd.7 = 0
Portd.6 = 0


'CAN relevante Config **********************************************************


Declare Sub Mcp2515_write(byval Reg_add As Byte , Byval Reg_val As Byte)
Declare Sub Mcp2515_bitmodify(byval Reg_add As Byte , Byval Reg_mask As Byte , Byval Reg_val As Byte)
Declare Function Mcp2515_read(byval Reg_add As Byte) As Byte

Mcp2515cs Alias Portd.4                                    'CS am 2515
Config Mcp2515cs = Output

Const Cmd_read = &H03                                      ' Read Command
Const Cmd_write = &H02                                      ' Write Command
Const Cmd_bitmodify = &H05                                  ' Bit-modify Command
Const Cmd_readstatus = &HA0                                ' Read Status Command (poll)
Const Cmd_read_rx_status = &HB0
Const Cmd_reset = &HC0                                      ' Reset Command
Const Cmd_rts0 = &H81
Const Cmd_rts1 = &H82
Const Caninte = &H2B
Const Canctrl = &H0F
Const Canstat = &H0E                                        ' Statusregister
Const Eflg = &H2D                                          ' Error Flag Register
Const Cnf3 = &H28                                          ' Configuration Register 3
Const Cnf2 = &H29                                          ' Configuration Register 2
Const Cnf1 = &H2A                                          ' Configuration Register 1
Const Txb0ctrl = &B00110000                                ' Transmit Buffer 0 Control Register
Const Txb0sidh = &B00110001                                ' Transmit Buffer 0 Std Identifier High
Const Txb0sidl = &B00110010                                ' Transmit Buffer 0 Std Identifier Low
Const Txb0eid8 = &B00110011                                ' Transmit Buffer 0 Ext Identifier High
Const Txb0eid0 = &B00110100                                ' Transmit Buffer 0 Ext Identifier Low
Const Txb0dlc = &B00110101                                  ' Transmit Buffer 0 Data Length Code
Const Txb0d0 = &B00110110                                  ' Transmit Buffer 0 Data Byte 0
Const Txb0d1 = &B00110111                                  ' Transmit Buffer 0 Data Byte 1
Const Txb0d2 = &B00111000                                  ' Transmit Buffer 0 Data Byte 2
Const Txb0d3 = &B00111001                                  ' Transmit Buffer 0 Data Byte 3
Const Txb0d4 = &B00111010                                  ' Transmit Buffer 0 Data Byte 4
Const Txb0d5 = &B00111011                                  ' Transmit Buffer 0 Data Byte 5
Const Txb0d6 = &B00111100                                  ' Transmit Buffer 0 Data Byte 6
Const Txb0d7 = &B00111101                                  ' Transmit Buffer 0 Data Byte 7
Const Rxm0sidh = &B00100000                                ' Receive Buffer 0 Std Identifier High
Const Rxm0sidl = &B00100001                                ' Receive Buffer 0 Std Identifier Low
Const Rxm0eid8 = &B00100010                                ' Receive Buffer 0 Ext Identifier High
Const Rxm0eid0 = &B00100011                                ' Receive Buffer 0 Ext Identifier low
Const Rxm1sidh = &B00100100                                ' Receive Buffer 1 Std Identifier High
Const Rxm1sidl = &B00100101                                ' Receive Buffer 1 Std Identifier Low
Const Rxm1eid8 = &B00100110                                ' Receive Buffer 1 Ext Identifier High
Const Rxm1eid0 = &B00100111                                ' Receive Buffer 1 Ext Identifier low

Const Rxb0ctrl = &H60
Const Rxb1ctrl = &H70


' Hardware SPI-Schnittstelle konfigurieren

Config Portb.4 = Input                                      'MISO  von 2515
Config Portb.3 = Output                                    'MOSI  von 2515
Config Portb.5 = Output                                    'SCK
Spcr = &B01010001                                          'Bit7=0:IntAus, Bit6=1:SPIAn, Bit5=0:MSBfirst,
                                                            'Bit4=1:Masterfunktion, Bit3=0:SCK=0wennIdle,
                                                            'Bit2=0:L-H-Flanke, Bit1+0=01:AVRClock/16

'Config Pind.3 = Input                                      'INT1 am AVR und MCP2515

Config Int1 = Falling
On Int1 Int_canint                                          'Interrupt zum empfangen
Enable Int1
Enable Interrupts


'Programm Start*****************************************************************
Print "Start Programm"
Gosub Can_init


Do

 For I = 1 To Keys
 Key = I
 Select Case Key
 Case 1 : Debounce Pinc.0 , 0 , Key_o1 , Sub                'Port 1.
 Case 2 : Debounce Pinc.1 , 0 , Key_o2 , Sub                'Port 2
 Case 3 : Debounce Pinc.2 , 0 , Key_o3 , Sub                'Port 3
 Case 4 : Debounce Pinc.3 , 0 , Key_o4 , Sub                'Port 4
 Case 5 : Debounce Pinc.4 , 0 , Key_o5 , Sub                'Port 5


 End Select
Next

Loop



' Zustandsänderung Ausgänge
  Key_o1:
  Toggle Portb.0
  Print "Portb.0"                                          'Buchse 1
  If T2 = 0 Then
  T2 = 1
  Else
  T2 = 0
  End If
  Gosub Data_send                                          'Statusänderung per CAN übertragen
  Return

  Key_o2:
  Toggle Portb.1
  Print "Portb.1"                                          'Buchse 2
  If T5 = 0 Then
  T5 = 1
  Else
  T5 = 0
  End If
  Gosub Data_send                                          'Statusänderung per CAN übertragen
  Return

  Key_o3:
  Toggle Portb.2                                          'Buchse 3
  Print "Portb.2"
  If T3 = 0 Then
  T3 = 1
  Else
  T3 = 0
  End If
  Gosub Data_send                                          'Statusänderung per CAN übertragen
  Return

  Key_o5:
  Toggle Portd.6                                          'Buchse 4
  Print "Portd.6"
  If T1 = 0 Then
  T1 = 1
  Else
  T1 = 0
  End If
  Gosub Data_send                                          'Statusänderung per CAN übertragen
  Return

  Key_o4:
  Toggle Portd.7                                          'Buchse 5
  Print "Portd.7"
  If T4 = 0 Then
  T4 = 1
  Else
  T4 = 0
  End If
  Gosub Data_send                                          'Statusänderung per CAN übertragen
  Return


End


'CAN Initialisieren *****************************

Can_init:

Reset Mcp2515cs                                            ' Reset MCP2515

  Spdr = &HC0
  Do
  Loop Until Spsr.spif = 1
  Set Mcp2515cs

  Waitms 2000
  'Mcp2515_write Canctrl , &B10001000                      ' low nibble: 3=OSM 2=CLK-Pin 1-0=CLK Divider  &B10001000

  Print "speed change done"


  ' CAN 31,25 KHz
  Mcp2515_write Cnf1 , &B00001111
  Mcp2515_write Cnf2 , &B10010000                          ' Cnf2 = &H29
  Mcp2515_write Cnf3 , &B00000010                          ' Cnf3 = &H28
  Mcp2515_write Caninte , &B00000011
  Mcp2515_write Rxb0ctrl , &B01100000
  Mcp2515_write Rxb1ctrl , &B01100000
  Mcp2515_write Rxm0sidh , 0                              ' Eigene Empfängeradressen auf 00000000 setzen, kein Filter
  Mcp2515_write Rxm0sidl , 0
  Mcp2515_write Rxm0eid8 , 0
  Mcp2515_write Rxm0eid0 , 0
  Mcp2515_write Rxm1sidh , 0
  Mcp2515_write Rxm1sidl , 0
  Mcp2515_write Rxm1eid8 , 0
  Mcp2515_write Rxm1eid0 , 0
  Mcp2515_bitmodify Canctrl , &B11100000 , &B00000000
  Mcp2515_write Canctrl , &B00000000                      ' low nibble: 3=OSM 2=CLK-Pin 1-0=CLK Divider
  Mcp2515_write Canctrl , &HE0


Return


'Daten übertargen    ****************************
Data_send:

  Mcp2515_bitmodify Txb0ctrl , &B00000011 , &B00000011    ' TX-Konfiguration
  Mcp2515_write Txb0sidh , &B01010101                      ' Empfängeradresse setzen
  Mcp2515_write Txb0sidl , &B01010101                      ' Empfängeradresse setzen
  Mcp2515_write Txb0dlc , &H01                            ' Paketlänge festlegen für ein Byte

  'Hier soll der Status abgefragt werden: T1, T2, T3, T4, T5
  Taster = Pinc
  Taster = Taster And &B00011111

  Mcp2515_write Txb0d0 , Taster                            ' Zu übertragende Daten setzen

  ' Übertragung auslösen
  Print "Datenuebertragung"
  Reset Mcp2515cs
  Waitus 20
  Spdr = Cmd_rts0


  Do
  Loop Until Spsr.spif = 1
  Waitus 20
  Set Mcp2515cs
  Print "Datenuebertragung end"

Return


Int_canint:

  Print "Datenempfang - Prüfung"

  'Prüfung der ankommenden Daten


  Print "Daten:"


Return

 Sub Mcp2515_bitmodify(reg_add , Reg_mask , Reg_val)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_bitmodify
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Waitms 2
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_mask
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_val
  Do
  Loop Until Spsr.spif = 1
  Mcp2515cs = 1
End Sub

Sub Mcp2515_write(reg_add , Reg_val)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_write
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Waitms 2
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_val
  Do
  Loop Until Spsr.spif = 1
  Mcp2515cs = 1
End Sub


Function Mcp2515_read(reg_add)
  Local Can_tmp2 As Byte
  Mcp2515cs = 0
  Can_tmp2 = Cmd_read
  Spdr = Can_tmp2
  Do
  Loop Until Spsr.spif = 1
  Spdr = Reg_add
  Do
  Loop Until Spsr.spif = 1
  Spdr = 0
  Do
  Loop Until Spsr.spif = 1
  Mcp2515_read = Spdr
  Mcp2515cs = 1
End Function

---

Beim Empfänger der 1:1 in der Hardware ist, sollte zumindest ein Interrupt ausgelöst werden und dies per Print Befehl ausgeben.

Leider funktioniert dies bei mir noch nicht. Den Fehler konnte ich bisher nicht feststellen.
Aber ich denke dass dies schon mal ein Anfang ist um vielleicht gemeinsam etwas weiter zu kommen.

Mein Vorschlag wäre, dass ihr euch die Schaltung anseht und vielleicht auch nachbaut. Irgent wo hat sich ein (Hardware-)Fehler eingeschlichen. Ich kann ihn einfach nicht finden. Vermutlich sehe ich den Wald vor lauter Bäumen nichtmehr.

Wer macht mit?

Tobias

Hast du denn den Toogle und Print effekt?`
In der Schaltung würde ich den Reset vom CAN-Controller noch mit einem Pullup versehen.
Ich sollte mir doch mal die Hardware bestellen, es geht ja hier doch weiter :-)

der Reset vom ISP geht laut Schaltung nicht auf den Reset vom AVR.
Dafür in den MCP, entweder stimmt Dein Plan nicht mit Deinem
Aufbau überein oder Du drückst beim Proggen jedesmal den Reset-Button?
Ist nicht so elegant, aber das hab ich ja schonmal geschrieben.