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