-
        

Ergebnis 1 bis 3 von 3

Thema: MCP2515 Remoteframe wird nicht gesendet.........

  1. #1
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    28
    Beiträge
    3.517
    Blog-Einträge
    9

    MCP2515 Remoteframe wird nicht gesendet.........

    Anzeige

    Hallo Forum,

    ich komme im Moment mit meinen CAN-Controllern nicht weiter.
    Ich habe eine CAN-Platine + ein RN-Control mit einem MCP2515. Die Datenübertragung zwischen beiden Systemen funktioniert fehlerfrei.
    Jetzt habe ich bei meinem RN-Control das Programm etwas angepasst, damit ich abwechselnd einen Remote oder Data-Frame senden kann.
    Das ganze funktioniert auch tadellos, sprich nach dem aufspielen des Programmes tippe ich ein "R" ein und ein Remoteframe wird gesendet. Und das jedes mal wenn ich ein "R" eintippe.
    Tippe ich ein "D" ein und einen Wert zwischen 0-255 wird er auch problemlos gesendet. Und das kann ich auch immer wiederholen.
    Jetzt komme ich zu meinem Problem....
    Wenn ich nach einem Remoteframe einen Datenframe sende funktioniert es problemlos.
    Will ich allerdings nach dem Datenframe wieder einen Remoteframe senden, wird das gesendet was vorher mit dem Datenframe übermittelt wurde und KEIN Remoteframe.
    Dieses Problem verschwindet auch erst wieder wenn ich den Controller vom RN-Control neu flashe, sprich nach einem Druck auf dem Reset-Taster bleibt das Problem :/.
    Hier ein Auszug aus den Terminals:

    Das erscheint bei der Eingabe eines "R"
    Code:
    Buffer: 1
    Frame: 1
    Filter: 0
    Nachricht in Buffer 0
    Standard Remote Frame
    Status: 72
    ID Nachricht: 7
    Das erscheint beim Eingeben eines "D" mit einem Zahlenwert:
    Code:
    Buffer: 1
    Frame: 0
    Filter: 0
    Nachricht in Buffer 0
    Standard Data Frame
    Status: 64
    ID Nachricht: 7
    Länge Nachricht: 8
    Daten 1: 10
    Daten 2: 4
    Daten 3: 9
    Daten 4: 16
    Daten 5: 25
    Daten 6: 36
    Daten 7: 49
    Daten 8: 64
    Und das erscheint wenn ich wieder ein "R" eingebe:
    Code:
    Buffer: 1
    Frame: 0
    Filter: 0
    Nachricht in Buffer 0
    Standard Data Frame
    Status: 64
    ID Nachricht: 7
    Länge Nachricht: 8
    Daten 1: 10
    Daten 2: 4
    Daten 3: 9
    Daten 4: 16
    Daten 5: 25
    Daten 6: 36
    Daten 7: 49
    Daten 8: 64
    Das hier ist das Programm auf dem RN-Control:

    Code:
    'Mikrocontroller
    $regfile = "m32def.dat"
    $crystal = 16000000
    
    'Stacks
    $hwstack = 200
    $swstack = 200
    $framesize = 400
    
    'UART konfigurieren
    $baud = 19200
    
    'SPI konfigurieren
    Config Spi = Hard , Interrupt = Off , Data Order = Msb , Master = Yes , Polarity = Low , Phase = 0 , Noss = 1 , Clockrate = 16
    Spiinit
    
    'Unterprogramme
    Declare Function Read_rx_status As Byte
    Declare Function Read_register(byval Adresse As Byte) As Byte
    Declare Sub Register
    Declare Sub Recieve_can
    Declare Sub Mcp2515_init
    Declare Sub Interrupt_occur
    Declare Sub Config_filter(byval Filter As Byte , Byval Buffer As Byte , Byval Ex_f_enable As Byte)
    Declare Sub Send_can(daten As Byte , Byval Tx_identifier As Long , Byval Ex_id_enable As Byte)
    Declare Sub Bitmodify(byval Reg_add As Byte , Byval Reg_mask As Byte , Byval Reg_val As Byte)
    Declare Sub Send_remote(byval Tx_identifier As Long , Byval Ex_id_enable As Byte)
    Declare Sub Write_register(byval Adresse As Byte , Byval Daten As Byte)
    
    'Befehle
    Const Spi_read = &H03
    Const Spi_write = &H02
    Const Spi_reset = &HC0
    Const Spi_rts0 = &H81
    Const Spi_bitmodify = &H05
    Const Spi_rx_status = &HB0
    Const Spi_read_rx = &H90
    
    'Registeradressen
    'Controlregister
    Const Cnf1 = &H2A
    Const Cnf2 = &H29
    Const Cnf3 = &H28
    Const Canctrl = &H0F                                        'Control Register vom MCP2515
    Const Caninte = &H2B                                        'Interrupt Enable vom MCP2515
    Const Canintf = &H2C                                        'Interrupfflags vom MCP2515
    
    'Transmit Buffer
    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
    
    'Recieve Buffer
    Const Rxm0sidh = &H20                                       'Receive Buffer 0 Std Identifier High
    Const Rxm0sidl = &H21                                       'Receive Buffer 0 Std Identifier Low
    Const Rxm0eid8 = &H22                                       'Receive Buffer 0 Ext Identifier High
    Const Rxm0eid0 = &H23                                       'Receive Buffer 0 Ext Identifier low
    Const Rxm1sidh = &H24                                       'Receive Buffer 1 Std Identifier High
    Const Rxm1sidl = &H25                                       'Receive Buffer 1 Std Identifier Low
    Const Rxm1eid8 = &H26                                       'Receive Buffer 1 Ext Identifier High
    Const Rxm1eid0 = &H27                                       'Receive Buffer 1 Ext Identifier low
    Const Rxb0ctrl = &H60                                       'Recieve Buffer 0 Control Register
    Const Rxb1ctrl = &H70                                       'Recieve Buffer 1 Control Register
    Const Rxb0d0 = &H66                                         'Revieve Buffer 0 Data Byte 0
    Const Rxb0d1 = &H67                                         'Revieve Buffer 0 Data Byte 1
    Const Rxb0d2 = &H68                                         'Revieve Buffer 0 Data Byte 2
    Const Rxb0d3 = &H69                                         'Revieve Buffer 0 Data Byte 3
    Const Rxb0d4 = &H60                                         'Revieve Buffer 0 Data Byte 4
    Const Rxb0d5 = &H6A                                         'Revieve Buffer 0 Data Byte 5
    Const Rxb0d6 = &H6B                                         'Revieve Buffer 0 Data Byte 6
    Const Rxb0d7 = &H6C                                         'Revieve Buffer 0 Data Byte 7
    
    'Error
    Const Eflg = &H2D                                           'Errorflags
    Const Tec = &H1C                                            'Tx Error Counter
    Const Rec = &H1D                                            'Rx Error Counter
    
    'Acceptance Filter
    'RXF0
    'Standard Identifier
    Const Rxf0sidh = &H00
    Const Rxf0sidl = &H01
    
    'Extended Identifier
    Const Rxf0eidh = &H02
    Const Rxf0eidl = &H03
    
    'RXF1
    'Standard Identifier
    Const Rxf1sidh = &H04
    Const Rxf1sidl = &H05
    
    'Extended Identifier
    Const Rxf1eidh = &H06
    Const Rxf1eidl = &H07
    
    'RXF2
    'Standard Identifier
    Const Rxf2sidh = &H08
    Const Rxf2sidl = &H09
    
    'Extended Identifier
    Const Rxf2eidh = &H0A
    Const Rxf2eidl = &H0B
    
    'RXF3
    'Standard Identifier
    Const Rxf3sidh = &H10
    Const Rxf3sidl = &H11
    
    'Extended Identifier
    Const Rxf3eidh = &H12
    Const Rxf3eidl = &H13
    
    'RXF4
    'Standard Identifier
    Const Rxf4sidh = &H14
    Const Rxf4sidl = &H15
    
    'Extended Identifier
    Const Rxf4eidh = &H16
    Const Rxf4eidl = &H17
    
    'RXF5
    'Standard Identifier
    Const Rxf5sidh = &H18
    Const Rxf5sidl = &H19
    
    'Extended Identifier
    Const Rxf5eidh = &H1A
    Const Rxf5eidl = &H1B
    
    'I/O Einstellungen
    Config Portb.4 = Output
    Config Pind.2 = Input
    
    'Namen vergeben
    Cs Alias Portb.4
    
    'Globale Variablen
    Dim Status As Byte
    Dim Interrupt As Byte
    Dim Errorcode As Byte
    Dim Statusflag As Byte
    Dim Input_uart As Long
    Dim Can_message(10) As Byte
    Dim Can_remote(2) As Integer
    Dim Message_id As Long
    
    Dim Identifier As Long
    Dim Test(8) As Byte
    Dim A As String * 10
    
    Identifier = 200
    Test(1) = 2
    Test(2) = 4
    Test(3) = 9
    Test(4) = 16
    Test(5) = 25
    Test(6) = 36
    Test(7) = 49
    Test(8) = 64
    
    
    'Interrupts einstellen
    Enable Interrupts                                           'Interrupts aktivieren                                        '
    Config Int0 = Falling                                       'INT0 auf fallende Flanke einstellen
    On Int0 Mcp2515_int                                         'Sprungmarke für INT0
    'On Urxc Uart_recieved
    'Enable Urxc
    Enable Int0                                                 'INT0 aktivieren
    
    'Chipselect auf High setzen
    Set Cs
    Wait 1
    
    'MCP2515 initialisieren
    Mcp2515_init
    
    'Filter einstellen
    'Config_filter 7 , 0                                         'Filter einstellen (1. Zahl = Filter, 2. Zahl = Buffer)
    
    'Hauptprogramm
    Do
    
    Input "Eingabe: " , A
    Select Case A
       Case "R" : Print "Remote"
                   Send_remote 7 , 0
       Case "D" : Print "Data
                   Input "Daten: " , Test(1)
                    Send_can Test(1) , 7 , 0                    'Daten senden (1. Zahl = ID , 2. Zahl = Identifiertyp - 0 = Standard, 1 = Extended)
                    Incr Test(1)
    End Select
    A = ""
    
    
    
    
    Loop
    End
    
    
    
    'Unterprogramme
    '-------------------------------------------------------------------------------------------------------------------
    
    Function Read_rx_status() As Byte
    
    Reset Cs                                                    'CS auf Low ziehen
    
    Spdr = Spi_rx_status                                        'Befehl zum auslesen des Rx Status Register ins Datenregister schreiben
    Spiout Spdr , 1                                             'Inhalt des Datenregisters über SPI senden
    Waitus 1                                                    'Kurze Zeit warten
    Spiin Read_rx_status , 1                                    'Antwort des MCP2515 unter "Status" speichern
    
    Set Cs
    
    End Function
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Function Read_register(byval Adresse As Byte ) As Byte
    
    Reset Cs                                                    'Chipselect auf Low ziehen
    Spdr = Spi_read                                             'Inhalt von "SPI_Read" im Datenregister speichern
    Spiout Spdr , 1
    Spiout Adresse , 1
    Waitus 1
    Spiin Read_register , 1                                     'Registerinhalt einlesen
    Set Cs                                                      'Chipselect auf High ziehen
    
    End Function
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Mcp2515_init
    
    Reset Cs
    
    Spdr = Spi_reset                                            'MCP2515 reseten
    Do
    Loop Until Spsr.spif = 1
    Set Cs
    
    'Control Register beschreiben
    Write_register Canctrl , &H88                               'Device in Configuration Mode versetzen, Nachrichten nur 1x versenden
    
    'Interrupts einstellen
    Write_register Caninte , &H05                               'Transmit und Recieve Buffer 0 Interrupt aktivieren
    
    'Tx-Konfiguration
    Bitmodify Txb0ctrl , &H03 , &H03                            'Priorität der Nachrichten auf "Highest" stellen
    
    'Bittiming einstellen
    Write_register Cnf1 , &H03                                  'Baudrate einstellen
    Write_register Cnf2 , &HA0                                  'Phasensegmenteinstellungen
    Write_register Cnf3 , &H02
    
    'Rx Buffer einstellen
    Write_register Rxb0ctrl , &H20                              'Standard Identifier erlauben
    Write_register Rxb1ctrl , &H60
    
    Bitmodify Canctrl , &HE0 , &H0                              'CAN-Controller in den "Normal Mode" versetzen
    
    'Tx Message Identifier einstellen
    Write_register Txb0sidh , &H00
    Write_register Txb0sidl , &H00
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Write_register(byval Adresse As Byte , Byval Daten As Byte)
    
    Reset Cs                                                    'Chipselect auf Low ziehen
    Spdr = Spi_write                                            'Inhalt von "SPI-Write" ins SPI_Data_Register schieben
    Do                                                          'Schleife bis SPI Interrupt Flag gesetzt wurde, also bis
    Loop Until Spsr.spif = 1                                    'die Übertragung abgeschlossen ist
    
    Spdr = Adresse
    Do
    Loop Until Spsr.spif = 1
    
    Spdr = Daten
    Do
    Loop Until Spsr.spif = 1
    Set Cs                                                      'Chipselect auf High ziehen
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Bitmodify(reg_add , Reg_mask , Reg_val)
    
    Reset Cs
    Spdr = Spi_bitmodify
    Do
    Loop Until Spsr.spif = 1
    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
    Set Cs
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Interrupt_occur
    Local Errorflag As Byte
    Local Rx_error As Byte
    
    Interrupt = Read_register(canintf)                          'Interruptflags auslesen um zu erfahren welcher Interrupt
                                                                'ausgelöst wurde
    'Select Case Interrupt
    'Case 1 : Recieve_can
    'Case 2 : Recieve_can
    
    'Case Else : Print "Error"
    'End Select
    
    If Interrupt > 32 Then
       Errorflag = Read_register(eflg)
       Rx_error = Read_register(rec)
    End If
    
    
    Print "Interruptflag: " ; Interrupt
    Print "Error: " ; Errorflag
    Print "Errorcounter: " ; Rx_error
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Config_filter(byval Filter As Byte , Byval Buffer As Byte , Byval Ex_f_enable As Byte)
    
    Local Filter_low As Integer
    Local Filter_high As Integer
    Local Id0_high As Byte
    Local Id0_low As Byte
    Local Id1_high As Byte
    Local Id1_low As Byte
    
    Bitmodify Canctrl , &HE0 , &H80,                            'CAN-Controller in den "Configuration Mode" versetzen
    
    'Identifier einstellen
    Filter_low = Filter                                         'Speichert den Identifier in zwei Variablen und schiebt
    Filter_high = Filter                                        'den Wert um 5 Stellen nach rechts um die drei
    Shift Filter_low , Left , 5                                 ' niedrigsten Bits zu gewinnen. Dasselbe passiert für
    Shift Filter_high , Right , 3                               'die acht höchsten Bits. Anschließend werden die Werte
                                                                 'in die passenden Register geschrieben.
    If Buffer = 0 Then
       Id0_high = Filter_high
       Id0_low = Filter_low
    Elseif Buffer = 1 Then
       Id1_high = Filter_high
       Id1_low = Filter_low
    Else
       Print "Unbekannter Buffer"
       Errorcode = 3
    End If
    
    'Maskenbits setzen
    Write_register Rxm0sidh , &HFF
    Write_register Rxm0sidl , &HFF
    Write_register Rxm1sidh , &HFF
    Write_register Rxm1sidl , &HFF
    
    'Filter setzen
    Write_register Rxf0sidh , Id0_high
    Write_register Rxf0sidl , Id0_low
    Write_register Rxf1sidh , Id1_high
    Write_register Rxf1sidl , Id1_low
    
    Bitmodify Canctrl , &HE0 , &H0                              'CAN-Controller in den "Normal Mode" versetzen
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Send_remote(byval Tx_identifier As Long , Byval Ex_id_enable As Byte)
    
    Local Tx_low As Integer
    Local Tx_high As Integer
    Local Id_high As Byte
    Local Id_low As Byte
    
    'Prüfen ob die Nachricht mit einem 29-Bit Identifier versendet werden soll oder nicht
    If Ex_id_enable = 0 Then
    
       'Prüfen ob der Identifier die richtige Länge hat
       If Tx_identifier > 2047 Then
    
          Print "Identifier beträgt " ; Tx_identifier ; " und ist damit zu groß. Maximaler Wert ist 2047!"
          Errorcode = 1
    
       Else
    
          'Identifier einstellen
          Tx_low = Tx_identifier                                'Speichert den Identifier in zwei Variablen und schiebt
          Tx_high = Tx_identifier                               'den Wert um 5 Stellen nach rechts um die drei
          Shift Tx_low , Left , 5                               ' niedrigsten Bits zu gewinnen. Dasselbe passiert für
          Shift Tx_high , Right , 3                             'die acht höchsten Bits. Anschließend werden die Werte
                                                                 'in die passenden Register geschrieben.
          Id_high = Tx_high
          Id_low = Tx_low
    
          'ID in die ID-Register schreiben
          Write_register Txb0sidh , Id_high
          Write_register Txb0sidl , Id_low
    
          'Renotebit setzen
          Bitmodify Txb0ctrl , &H08 , &H08
    
          Reset Cs
          Spdr = Spi_rts0                                       'Übertragung auslösen
          Do
          Loop Until Spsr.spif = 1
          Set Cs
    
       End If
    
    Elseif Ex_id_enable = 1 Then
    
    Else
    
       Print "Error. Unbekannter Identifier!"
       Errorcode = 2
    
    End If
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Send_can(daten(8) As Byte , Byval Tx_identifier As Long , Byval Ex_id_enable As Byte)
    
    Local Tx_low As Integer
    Local Tx_high As Integer
    Local Id_high As Byte
    Local Id_low As Byte
    
    'Prüfen ob die Nachricht mit einem 29-Bit Identifier versendet werden soll oder nicht
    If Ex_id_enable = 0 Then
    
       'Prüfen ob der Identifier die richtige Länge hat
       If Tx_identifier > 2047 Then
    
          Print "Identifier beträgt " ; Tx_identifier ; " und ist damit zu groß. Maximaler Wert ist 2047!"
          Errorcode = 1
          Return
    
       Else
    
          'Identifier einstellen
          Tx_low = Tx_identifier                                'Speichert den Filter in zwei Variablen und schiebt
          Tx_high = Tx_identifier                               'den Wert um 5 Stellen nach rechts um die drei
          Shift Tx_low , Left , 5                               ' niedrigsten Bits zu gewinnen. Dasselbe passiert für
          Shift Tx_high , Right , 3                             'die acht höchsten Bits. Anschließend werden die Werte
                                                                 'in die passenden Register geschrieben.
          Id_high = Tx_high
          Id_low = Tx_low
    
          'ID in die ID-Register schreiben
          Write_register Txb0sidh , Id_high
          Write_register Txb0sidl , Id_low
    
          'Daten in die Datenregister schreiben
          Write_register Txb0dlc , 8
          Write_register Txb0d0 , Daten(1)
          Write_register Txb0d1 , Daten(2)
          Write_register Txb0d2 , Daten(3)
          Write_register Txb0d3 , Daten(4)
          Write_register Txb0d4 , Daten(5)
          Write_register Txb0d5 , Daten(6)
          Write_register Txb0d6 , Daten(7)
          Write_register Txb0d7 , Daten(8)
    
          Reset Cs
          Spdr = Spi_rts0                                       'Übertragung auslösen
          Do
          Loop Until Spsr.spif = 1
          Set Cs
    
       End If
    
    Elseif Ex_id_enable = 1 Then
    
    Else
    
       Print "Error. Unbekannter Identifier!"
       Errorcode = 2
       Return
    
    End If
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Recieve_can
    
    'Variablen für die Empfangsroutine
    Local Id_low As Integer                                     'Buffer für die drei niedrigsten ID-Bits
    Local Id_high As Integer                                    'Buffer für die acht höchsten ID-Bits
    Local Laenge As Byte                                        'Buffer für die vier Längen-Bits
    Local Daten As Byte
    Local Dummy As Byte
    Local Daten_laenge As Byte
    Local Zaehler_laenge As Byte
    
    'Variablen löschen
    Id_high = 0
    Id_low = 0
    Laenge = 0
    
    'Status auslesen und analysieren
    Status = Read_rx_status()
    
    If Status = 128 Then                                        'Nachricht in Rx-Buffer 1
    
    
    
    Elseif Status = 72 Then                                     'Standard Remote Anfrage
    
       'Lesen der Buffer auslösen
       Reset Cs
       Spdr = Spi_read_rx
       Spiout Spdr , 1
       Waitus 1
    
       'CAN-Nachricht nach und nach empfangen
       'ID auslesen
       Spiin Id_high , 1
       Spiin Id_low , 1
    
       Spiin Dummy , 1                                          'Beide Bytes des Extended Identifiers einlesen
       Spiin Dummy , 1                                          'und in einem Dummy speichern
    
       'Länge auslesen
       Spiin Laenge , 1
    
       'CAN-Nachricht bearbeiten
       'Standard Identifier auslesen                              'High Identifier erkennen funktioniert!
       Shift Id_high , Left , 3                                 'Verschiebung beim Senden rückgängig machen
       Shift Id_low , Right , 5
    
       Can_remote(1) = Id_high                                  'und Werte logisch miteiander verknüpfen um daraus
       Can_remote(1) = Can_remote(1) Or Id_low                  'die komplette ID zu gewinnen
       Can_remote(2) = Laenge
    
    Elseif Status = 64 Then                                     'Nachricht in Rx-Buffer 0
    
       'Lesen der Buffer auslösen
       Reset Cs
       Spdr = Spi_read_rx
       Spiout Spdr , 1
       Waitus 1
    
       'CAN-Nachricht nach und nach empfangen
       'ID auslesen
       Spiin Id_high , 1
       Spiin Id_low , 1
    
       Spiin Dummy , 1                                          'Beiden Bytes des Extended Identifiers einlesen
       Spiin Dummy , 1
    
       'Länge auslesen
       Spiin Laenge , 1
       Zaehler_laenge = Laenge + 2
       Laenge = Laenge And &H0F
    
       'Daten auslesen
       For Daten_laenge = 3 To Zaehler_laenge
          Spiin Can_message(daten_laenge) , 1
       Next
    
       'CAN-Nachricht bearbeiten
       'Standard Identifier auslesen
       Shift Id_high , Left , 3                                 'Verschiebung beim Senden rückgängig machen
       Shift Id_low , Right , 5
       Laenge = Laenge And &H0F
       Can_message(1) = Id_high                                 'und Werte logisch miteiander verknüpfen um daraus
       Can_message(1) = Can_message(1) Or Id_low                'die komplette ID zu gewinnen
       Can_message(2) = Laenge
    
    Else
    Print "Keine neue Nachricht vorhanden!"
    
    End If
    
    Set Cs
    Waitus 1                                                    'Kurz warten
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Register
    
    'Terminalausgabe
    Print "Registereinstellungen:"
    Print "Registerinhalt CNF1: " ; Read_register(cnf1)
    Print "Registerinhalt CNF2: " ; Read_register(cnf2)
    Print "Registerinhalt CNF3: " ; Read_register(cnf3)
    Print "Registerinhalt CAN Control: " ; Read_register(canctrl)
    Print "Registerinhalt TXB0 Control: " ; Read_register(txb0ctrl)
    Print "Tx Identifier: " ; Identifier
    Print "Registerinhalt TXB0 Data Lenght: " ; Read_register(txb0dlc)
    Print "Registerinhalt CAN Interrupt Enable: " ; Read_register(caninte)
    Print "Registerinhalt CAN Datenregister: " ; Read_register(txb0d0)
    Print "----------------------------------------------------------"
    
    End Sub
    
    
    'ISRs
    '-------------------------------------------------------------------------------------------------------------------
    
    'ISR von INT0
    Mcp2515_int:
    
    Statusflag = 1                                              'Interrupt ausgelöst
    
    Return
    
    '-------------------------------------------------------------------------------------------------------------------
    
    'ISR vom UART
    'Uart_recieved:
    
    '   Input_uart = Udr
    
    'Return
    
    '-------------------------------------------------------------------------------------------------------------------
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

  2. #2
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    28
    Beiträge
    3.517
    Blog-Einträge
    9
    Da der Thread in einem Stück zu lang ist....

    Hier das Programm auf meinem CAN-Knoten:

    Code:
    'Mikrocontroller
    $regfile = "m32def.dat"
    $crystal = 16000000
    
    'Stacks
    $hwstack = 200
    $swstack = 200
    $framesize = 400
    
    'Watchdog konfigurieren
    Config Watchdog = 2048
    
    'UART konfigurieren
    $baud = 19200
    
    'SPI konfigurieren
    Config Spi = Hard , Interrupt = Off , Data Order = Msb , Master = Yes , Polarity = Low , Phase = 0 , Noss = 1 , Clockrate = 16
    Spiinit
    
    'TWI konfigurieren
    Config Sda = Portc.1
    Config Scl = Portc.0
    Config Twi = 100000                                         'TWI Frequenz
    
    'Unterprogramme
    Declare Function Read_rx_status() As Byte
    Declare Function Read_temperature() As Byte
    Declare Function Read_register(byval Adress As Byte) As Byte
    Declare Function Read_eeprom(byval Adress As Integer) As Byte
    Declare Sub Recieve_can
    Declare Sub Mcp2515_init
    Declare Sub Interrupt_occur
    Declare Sub Write_eeprom(byval Data_eeprom As Byte , Byval Adress As Integer)
    Declare Sub Config_filter(byval Filter_wert As Byte , Byval Buffer As Byte , Byval Filter As Byte , Byval Ex_f_enable As Byte)
    Declare Sub Send_can(daten As Byte , Byval Tx_identifier As Long , Byval Ex_id_enable As Byte , Byval Remote As Byte)
    Declare Sub Bitmodify(byval Reg_add As Byte , Byval Reg_mask As Byte , Byval Reg_val As Byte)
    Declare Sub Send_remote(byval Tx_identifier As Long , Byval Ex_id_enable As Byte)
    Declare Sub Write_register(byval Adresse As Byte , Byval Daten As Byte)
    
    'Befehle
    Const Spi_read = &H03
    Const Spi_write = &H02
    Const Spi_reset = &HC0
    Const Spi_rts0 = &H81
    Const Spi_bitmodify = &H05
    Const Spi_rx_status = &HB0
    Const Spi_read_rx0 = &H90
    Const Spi_read_rx1 = &H96
    
    'Registeradressen
    'Controlregister
    Const Cnf1 = &H2A
    Const Cnf2 = &H29
    Const Cnf3 = &H28
    Const Canctrl = &H0F                                        'Control Register vom MCP2515
    Const Caninte = &H2B                                        'Interrupt Enable vom MCP2515
    Const Canintf = &H2C                                        'Interrupfflags vom MCP2515
    
    'Transmit Buffer
    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
    
    'Recieve Buffer
    Const Rxm0sidh = &H20                                       'Receive Buffer 0 Std Identifier High
    Const Rxm0sidl = &H21                                       'Receive Buffer 0 Std Identifier Low
    Const Rxm0eid8 = &H22                                       'Receive Buffer 0 Ext Identifier High
    Const Rxm0eid0 = &H23                                       'Receive Buffer 0 Ext Identifier low
    Const Rxm1sidh = &H24                                       'Receive Buffer 1 Std Identifier High
    Const Rxm1sidl = &H25                                       'Receive Buffer 1 Std Identifier Low
    Const Rxm1eid8 = &H26                                       'Receive Buffer 1 Ext Identifier High
    Const Rxm1eid0 = &H27                                       'Receive Buffer 1 Ext Identifier low
    Const Rxb0ctrl = &H60                                       'Recieve Buffer 0 Control Register
    Const Rxb1ctrl = &H70                                       'Recieve Buffer 1 Control Register
    Const Rxb0d0 = &H66                                         'Revieve Buffer 0 Data Byte 0
    Const Rxb0d1 = &H67                                         'Revieve Buffer 0 Data Byte 1
    Const Rxb0d2 = &H68                                         'Revieve Buffer 0 Data Byte 2
    Const Rxb0d3 = &H69                                         'Revieve Buffer 0 Data Byte 3
    Const Rxb0d4 = &H60                                         'Revieve Buffer 0 Data Byte 4
    Const Rxb0d5 = &H6A                                         'Revieve Buffer 0 Data Byte 5
    Const Rxb0d6 = &H6B                                         'Revieve Buffer 0 Data Byte 6
    Const Rxb0d7 = &H6C                                         'Revieve Buffer 0 Data Byte 7
    
    'Error
    Const Eflg = &H2D                                           'Errorflags
    Const Tec = &H1C                                            'Tx Error Counter
    Const Rec = &H1D                                            'Rx Error Counter
    
    'Acceptance Filter
    'RXF0
    'Standard Identifier
    Const Rxf0sidh = &H00
    Const Rxf0sidl = &H01
    
    'Extended Identifier
    Const Rxf0eidh = &H02
    Const Rxf0eidl = &H03
    
    'RXF1
    'Standard Identifier
    Const Rxf1sidh = &H04
    Const Rxf1sidl = &H05
    
    'Extended Identifier
    Const Rxf1eidh = &H06
    Const Rxf1eidl = &H07
    
    'RXF2
    'Standard Identifier
    Const Rxf2sidh = &H08
    Const Rxf2sidl = &H09
    
    'Extended Identifier
    Const Rxf2eidh = &H0A
    Const Rxf2eidl = &H0B
    
    'RXF3
    'Standard Identifier
    Const Rxf3sidh = &H10
    Const Rxf3sidl = &H11
    
    'Extended Identifier
    Const Rxf3eidh = &H12
    Const Rxf3eidl = &H13
    
    'RXF4
    'Standard Identifier
    Const Rxf4sidh = &H14
    Const Rxf4sidl = &H15
    
    'Extended Identifier
    Const Rxf4eidh = &H16
    Const Rxf4eidl = &H17
    
    'RXF5
    'Standard Identifier
    Const Rxf5sidh = &H18
    Const Rxf5sidl = &H19
    
    'Extended Identifier
    Const Rxf5eidh = &H1A
    Const Rxf5eidl = &H1B
    
    'I²C Adressen
    'Adresse des LM75
    Const Lm75r = &H9F                                          'Adresse des Temperatursensors
    
    'Adresse des EEPROM
    Const 24lc128w = &HA0
    Const 24lc128r = &HA1
    
    'I/O Einstellungen
    Config Portb.4 = Output
    Config Pind.2 = Input
    
    'Namen vergeben
    Cs Alias Portb.4
    
    'Watchdog starten
    'Start Watchdog
    
    'I²C starten
    I2cinit
    
    'Globale Variablen
    'I²C EEPROM
    Dim Eeprom_in As Byte
    Dim Eeprom As Byte
    
    'LM75
    Dim Temperatur As Byte
    
    'CAN
    Dim Status As Byte
    Dim Interrupt As Byte
    Dim Errorcode As Byte
    Dim Statusflag As Byte
    Dim Can_message(10) As Byte
    
    'UART
    Dim Input_string As String * 20
    Dim Input_string_overlay(20) As Byte At Input_string Overlay
    Dim Bytes_received As Byte
    
    'Variablen setzen
    Eeprom = 100
    Bytes_received = 0
    Can_message(1) = 0
    Can_message(2) = 0
    Can_message(3) = 0
    Can_message(4) = 0
    Can_message(5) = 0
    Can_message(6) = 0
    Can_message(7) = 0
    Can_message(8) = 0
    Can_message(9) = 0
    Can_message(10) = 0
    
    'Interrupts einstellen
    Enable Interrupts                                           'Interrupts aktivieren                                        '
    Config Int0 = Falling                                       'INT0 auf fallende Flanke einstellen
    On Int0 Mcp2515_int                                         'Sprungmarke für INT0
    On Urxc Uart_recieved
    Enable Urxc
    Enable Int0                                                 'INT0 aktivieren
    
    Set Cs                                                      'Chipselect auf High setzen
    Wait 1
    
    'MCP2515 initialisieren
    Mcp2515_init
    
    'EEPROM beschreiben
    'Write_eeprom Eeprom , 2                                     'EEPROM beschreiben (1. Zahl = Daten, 2. Zahl = Speicheradresse)
    
    'Filter einstellen
    Config_filter 7 , 0 , 0 , 0                                 'Filter einstellen (1. Zahl = Filterwert, 2. Zahl = Buffer, 3. Zahl = Filter, 4. Zahl = Identifiertyp - 0 = Standard, 1 = Extended)
    
    'Hauptprogramm
    '-------------------------------------------------------------------------------------------------------------------
    
    Do
    
    'Empfangene Nachricht auswerten
    If Statusflag = 1 Then
    
       Interrupt_occur                                          'Interruptquelle auslesen
    
    
    End If
    
    Wait 1
    
    Loop
    End
    
    
    'Unterprogramme
    '-------------------------------------------------------------------------------------------------------------------
    
    Function Read_rx_status() As Byte
    
    Reset Cs                                                    'CS auf Low ziehen
    
    Spdr = Spi_rx_status                                        'Befehl zum auslesen des Rx Status Register ins Datenregister schreiben
    Spiout Spdr , 1                                             'Inhalt des Datenregisters über SPI senden
    Waitus 1                                                    'Kurze Zeit warten
    Spiin Read_rx_status , 1                                    'Antwort des MCP2515 unter "Status" speichern
    
    Set Cs
    
    End Function
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Function Read_register(byval Adresse As Byte ) As Byte
    
    Reset Cs                                                    'Chipselect auf Low ziehen
    Spdr = Spi_read                                             'Inhalt von "SPI_Read" im Datenregister speichern
    Spiout Spdr , 1
    Spiout Adress , 1
    Waitus 1
    Spiin Read_register , 1                                     'Registerinhalt einlesen
    Set Cs                                                      'Chipselect auf High ziehen
    
    End Function
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Mcp2515_init
    
    Reset Cs
    
    Spdr = Spi_reset                                            'MCP2515 reseten
    Do
    Loop Until Spsr.spif = 1
    Set Cs
    
    'Control Register beschreiben
    Write_register Canctrl , &H88                               'Device in Configuration Mode versetzen, Nachrichten nur 1x versenden
    
    'Interrupts einstellen
    Write_register Caninte , &HFF                               'Transmit und Recieve Buffer 0 Interrupt aktivieren
    
    'Tx-Konfiguration
    Bitmodify Txb0ctrl , &H03 , &H03                            'Priorität der Nachrichten auf "Highest" stellen
    
    'Bittiming einstellen
    Write_register Cnf1 , &H03                                  'Baudrate einstellen
    Write_register Cnf2 , &HA0                                  'Phasensegmenteinstellungen
    Write_register Cnf3 , &H02
    
    'Rx Buffer einstellen
    Write_register Rxb0ctrl , &H20                              'Standard Identifier erlauben
    Write_register Rxb1ctrl , &H20
    
    'Maskenbits setzen
    Write_register Rxm0sidh , &HFF
    Write_register Rxm0sidl , &HFF
    Write_register Rxm1sidh , &HFF                              '
    Write_register Rxm1sidl , &HFF
    
    Bitmodify Canctrl , &HE0 , &H0                              'CAN-Controller in den "Normal Mode" versetzen
    
    'Tx Message Identifier einstellen
    Write_register Txb0sidh , &H00
    Write_register Txb0sidl , &H00
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Write_register(byval Adress As Byte , Byval Daten As Byte)
    
    Reset Cs                                                    'Chipselect auf Low ziehen
    Spdr = Spi_write                                            'Inhalt von "SPI-Write" ins SPI_Data_Register schieben
    Do                                                          'Schleife bis SPI Interrupt Flag gesetzt wurde, also bis
    Loop Until Spsr.spif = 1                                    'die Übertragung abgeschlossen ist
    
    Spdr = Adresse
    Do
    Loop Until Spsr.spif = 1
    
    Spdr = Daten
    Do
    Loop Until Spsr.spif = 1
    Set Cs                                                      'Chipselect auf High ziehen
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Bitmodify(reg_add , Reg_mask , Reg_val)
    
    Reset Cs
    Spdr = Spi_bitmodify
    Do
    Loop Until Spsr.spif = 1
    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
    Set Cs
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Interrupt_occur
    Local Errorflag As Byte
    Local Rx_error As Byte
    
    Interrupt = Read_register(canintf)                          'Interruptflags auslesen um zu erfahren welcher Interrupt
                                                                'ausgelöst wurde
    Recieve_can
    
    If Interrupt > 32 Then
       Errorflag = Read_register(eflg)
       Rx_error = Read_register(rec)
    End If
    
    Print "Interruptflag: " ; Interrupt
    Print "Errorflag: " ; Errorflag
    Print "------------------------------------------------------------------------"
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Config_filter(byval Filter_wert As Byte , Byval Buffer As Byte , Byval Filter As Byte , Byval Ex_f_enable As Byte)
    
    Local Filter_low As Integer
    Local Filter_high As Integer
    Local Id_high As Byte
    Local Id_low As Byte
    
    Bitmodify Canctrl , &HE0 , &H80,                            'CAN-Controller in den "Configuration Mode" versetzen
    
    If Ex_f_enable = 0 Then
    
       'Standardidentifier einstellen
       Filter_low = Filter_wert                                 'Speichert den Identifier in zwei Variablen und schiebt
       Filter_high = Filter_wert                                'den Wert um 5 Stellen nach rechts um die drei
       Shift Filter_low , Left , 5                              ' niedrigsten Bits zu gewinnen. Dasselbe passiert für
       Shift Filter_high , Right , 3                            'die acht höchsten Bits. Anschließend werden die Werte
                                                                 'in die passenden Register geschrieben.
       If Buffer = 0 Then
    
          Select Case Filter
            Case 0 : Id_high = Filter_high
                         Id_low = Filter_low
                         Write_register , Rxf0sidh , Id_high
                         Write_register , Rxf0sidl , Id_low
    
             Case 1 : Id_high = Filter_high
                         Id_low = Filter_low
                         Write_register , Rxf1sidh , Id_high
                         Write_register , Rxf1sidl , Id_low
          End Select
    
       Elseif Buffer = 1 Then
    
          Select Case Filter
            Case 5 : Id_high = Filter_high
                         Id_low = Filter_low
                         Write_register , Rxf0sidh , Id_high
                         Write_register , Rxf0sidl , Id_low
          End Select
    
       Else
    
          Print "Unbekannter Buffer"
          Errorcode = 3
    
       End If
    
    Elseif Ex_f_enable = 1 Then
    
    
    
    Else
    
       Print "Error. Unbekannter Identifier!"
       Errorcode = 2
    
    End If
    
    Bitmodify Canctrl , &HE0 , &H0                              'CAN-Controller in den "Normal Mode" versetzen
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Send_remote(byval Tx_identifier As Long , Byval Ex_id_enable As Byte)
    
    Local Tx_low As Integer
    Local Tx_high As Integer
    Local Id_high As Byte
    Local Id_low As Byte
    
    'Prüfen ob die Nachricht mit einem 29-Bit Identifier versendet werden soll oder nicht
    If Ex_id_enable = 0 Then
    
       'Prüfen ob der Identifier die richtige Länge hat
       If Tx_identifier > 2047 Then
    
          Print "Identifier beträgt " ; Tx_identifier ; " und ist damit zu groß. Maximaler Wert ist 2047!"
          Errorcode = 1
    
       Else
    
          'Identifier einstellen
          Tx_low = Tx_identifier                                'Speichert den Identifier in zwei Variablen und schiebt
          Tx_high = Tx_identifier                               'den Wert um 5 Stellen nach rechts um die drei
          Shift Tx_low , Left , 5                               ' niedrigsten Bits zu gewinnen. Dasselbe passiert für
          Shift Tx_high , Right , 3                             'die acht höchsten Bits. Anschließend werden die Werte
                                                                 'in die passenden Register geschrieben.
          Id_high = Tx_high
          Id_low = Tx_low
    
          'ID in die ID-Register schreiben
          Write_register Txb0sidh , Id_high
          Write_register Txb0sidl , Id_low
    
          'Renotebit setzen
          Bitmodify Txb0ctrl , &H08 , &H08
    
          Reset Cs
          Spdr = Spi_rts0                                       'Übertragung auslösen
          Do
          Loop Until Spsr.spif = 1
          Set Cs
    
       End If
    
    Elseif Ex_id_enable = 1 Then
    
    Else
    
       Print "Error. Unbekannter Identifier!"
       Errorcode = 2
    
    End If
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Send_can(daten(8) As Byte , Byval Tx_identifier As Long , Byval Ex_id_enable As Byte , Byval Remote As Byte)
    
    Local Tx_low As Integer
    Local Tx_high As Integer
    Local Id_high As Byte
    Local Id_low As Byte
    
    'Prüfen ob die Nachricht mit einem 29-Bit Identifier versendet werden soll oder nicht
    If Ex_id_enable = 0 Then
    
       'Prüfen ob der Identifier die richtige Länge hat
       If Tx_identifier > 2047 Then
    
          Print "Identifier beträgt " ; Tx_identifier ; " und ist damit zu groß. Maximaler Wert ist 2047!"
          Errorcode = 1
          Return
    
       Else
    
          'Identifier einstellen
          Tx_low = Tx_identifier                                'Speichert den Filter in zwei Variablen und schiebt
          Tx_high = Tx_identifier                               'den Wert um 5 Stellen nach rechts um die drei
          Shift Tx_low , Left , 5                               ' niedrigsten Bits zu gewinnen. Dasselbe passiert für
          Shift Tx_high , Right , 3                             'die acht höchsten Bits. Anschließend werden die Werte
                                                                 'in die passenden Register geschrieben.
          Id_high = Tx_high
          Id_low = Tx_low
    
          'ID in die ID-Register schreiben
          Write_register Txb0sidh , Id_high
          Write_register Txb0sidl , Id_low
    
          'Daten in die Datenregister schreiben
          Write_register Txb0dlc , 8
          Write_register Txb0d0 , Daten(1)
          Write_register Txb0d1 , Daten(2)
          Write_register Txb0d2 , Daten(3)
          Write_register Txb0d3 , Daten(4)
          Write_register Txb0d4 , Daten(5)
          Write_register Txb0d5 , Daten(6)
          Write_register Txb0d6 , Daten(7)
          Write_register Txb0d7 , Daten(8)
    
          Reset Cs
          Spdr = Spi_rts0                                       'Übertragung auslösen
          Do
          Loop Until Spsr.spif = 1
          Set Cs
    
       End If
    
    Elseif Ex_id_enable = 1 Then
    
    Else
    
       Print "Error. Unbekannter Identifier!"
       Errorcode = 2
    
    End If
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Recieve_can
    
    'Variablen für die Empfangsroutine
    Local Id_low As Integer                                     'Buffer für die drei niedrigsten ID-Bits
    Local Id_high As Integer                                    'Buffer für die acht höchsten ID-Bits
    Local Laenge As Byte                                        'Buffer für die vier Längen-Bits
    Local Daten As Byte
    Local Dummy As Byte
    Local Daten_laenge As Byte
    Local Zaehler_laenge As Byte
    Local Buffer As Byte
    Local Frame As Byte
    Local Filter As Byte
    
    'Variablen löschen
    Id_high = 0
    Id_low = 0
    Laenge = 0
    
    'Status auslesen und analysieren
    Status = Read_rx_status()
    
    'Buffer ausfiltern
    Buffer = Status
    Shift Buffer , Right , 6
    
    'Frame ausfiltern
    Frame = Status
    Frame = Frame And &H18
    Shift Frame , Right , 3
    
    'Filter ausfiltern
    Filter = Status
    Filter = Filter And &H07
    
    Print "Buffer: " ; Buffer
    Print "Frame: " ; Frame
    Print "Filter: " ; Filter
    Print ""
    
    If Buffer = 2 Then                                          'Nachricht in Rx-Buffer 1
    
       Print "Nachricht in Buffer 1"
    
    
    Elseif Buffer = 1 Then                                      'Nachricht in Rx-Buffer 0
    
       Print "Nachricht in Buffer 0"
    
          If Frame = 0 Then
    
             Print "Standard Data Frame"
    
            'Lesen vom Buffer auslösen
             Reset Cs
             Spdr = Spi_read_rx0
             Spiout Spdr , 1
             Waitus 1
    
             'CAN-Nachricht nach und nach empfangen
             'ID auslesen
             Spiin Id_high , 1
             Spiin Id_low , 1
    
             Spiin Dummy , 1                                    'Beiden Bytes des Extended Identifiers einlesen
             Spiin Dummy , 1
    
             'Länge auslesen
             Spiin Laenge , 1
             Zaehler_laenge = Laenge + 2
             Laenge = Laenge And &H0F
    
             'Daten auslesen
             For Daten_laenge = 3 To Zaehler_laenge
                Spiin Can_message(daten_laenge) , 1
             Next
    
             'CAN-Nachricht bearbeiten
             'Standard Identifier auslesen
             Shift Id_high , Left , 3                           'Verschiebung beim Senden rückgängig machen
             Shift Id_low , Right , 5
             Laenge = Laenge And &H0F
             Can_message(1) = Id_high                           'und Werte logisch miteiander verknüpfen um daraus
             Can_message(1) = Can_message(1) Or Id_low          'die komplette ID zu gewinnen
             Can_message(2) = Laenge
    
             'Ausgabe
             Print "Status: " ; Status
             Print "ID Nachricht: " ; Can_message(1)
             Print "Länge Nachricht: " ; Can_message(2)
             Print "Daten 1: " ; Can_message(3)
             Print "Daten 2: " ; Can_message(4)
             Print "Daten 3: " ; Can_message(5)
             Print "Daten 4: " ; Can_message(6)
             Print "Daten 5: " ; Can_message(7)
             Print "Daten 6: " ; Can_message(8)
             Print "Daten 7: " ; Can_message(9)
             Print "Daten 8: " ; Can_message(10)
             Print "------------------------------------------------------------------------"
    
          Elseif Frame = 1 Then
    
             Print "Standard Remote Frame"
    
             'Lesen vom Buffer auslösen
             Reset Cs
             Spdr = Spi_read_rx0
             Spiout Spdr , 1
             Waitus 1
    
             'CAN-Nachricht nach und nach empfangen
             'ID auslesen
             Spiin Id_high , 1
             Spiin Id_low , 1
    
             Spiin Dummy , 1                                    'Beide Bytes des Extended Identifiers einlesen
             Spiin Dummy , 1                                    'und in einem Dummy speichern
             Spiin Dummy , 1
    
             'CAN-Nachricht bearbeiten
             'Standard Identifier auslesen                              'High Identifier erkennen funktioniert!
             Shift Id_high , Left , 3                           'Verschiebung beim Senden rückgängig machen
             Shift Id_low , Right , 5
    
             Can_message(1) = Id_high                           'und Werte logisch miteiander verknüpfen um daraus
             Can_message(1) = Can_message(1) Or Id_low          'die komplette ID zu gewinnen
    
             'Ausgabe
             Print "Status: " ; Status
             Print "ID Nachricht: " ; Can_message(1)
             Print "------------------------------------------------------------------------"
    
          End If
    
    Else
    
       Print "Keine neue Nachricht vorhanden!"
    
    End If
    
    Set Cs
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Function Read_temperature() As Byte
    Local Lm75high As Byte
    Local Lm75low As Byte
    
    I2cstart                                                    'TWI Startkondition
    I2cwbyte Lm75r                                              'Übergabe der Leseadresse
    I2crbyte Lm75high , Ack                                     'Auslesen des Registers für die Temperatur
    I2crbyte Lm75low , Nack                                     'Auslesen des Registers für die Nachkommastelle
    I2cstop                                                     'TWI Stopkondition
    If Lm75high > 127 Then
       Temperatur = Lm75high And 127
       Temperatur = Not Temperatur
       Incr Temperatur
    Else
       Temperatur = Lm75high
    End If
    
    End Function
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Function Read_eeprom(byval Adress As Integer) As Byte
    Local Adress_high As Byte
    Local Adress_low As Byte
    
    Adress_high = High(adress)                                  'High Byte der Adresse speichern
    Adress_low = Low(adress)                                    'Low Byte der Adresse speichern
    
    I2cstart                                                    'Startkondition
    I2cwbyte 24lc128w                                           'Schreibadresse übertragen
    I2cwbyte Adress_high                                        'High Byte der Adresse schreiben
    I2cwbyte Adress_low                                         'Low Byte der Adresse schreiben
    
    I2cstart                                                    'Startkondition
    I2cwbyte 24lc128r                                           'Leseadresse übertragen
    I2crbyte Read_eeprom , Nack                                 'Daten auslesen
    I2cstop                                                     'Stopkondition
    
    End Function
    
    '-------------------------------------------------------------------------------------------------------------------
    
    Sub Write_eeprom(byval Data_eeprom As Byte , Byval Adress As Integer)
    Local Data_lenght As Byte
    Local Adress_high As Byte
    Local Adress_low As Byte
    
    Adress_high = High(adress)                                  'High Byte der Adresse speichern
    Adress_low = Low(adress)                                    'Low Byte der Adresse speichern
    
    I2cstart                                                    'Startkondition
    I2cwbyte 24lc128w                                           'Schreibadresse übertragen
    I2cwbyte Adress_high                                        'High Byte der Adresse schreiben
    I2cwbyte Adress_low                                         'Low Byte der Adresse schreiben
    I2cwbyte Data_eeprom                                        'Daten schreiben
    I2cstop                                                     'Stopkondition
    Waitms 10                                                   '10ms warten um den Schreibvorgang abzuschließen
    
    End Sub
    
    '-------------------------------------------------------------------------------------------------------------------
    
    'ISRs
    '-------------------------------------------------------------------------------------------------------------------
    
    'ISR von INT0
    Mcp2515_int:
    
    Statusflag = 1                                              'Interrupt ausgelöst
    
    Return
    
    '-------------------------------------------------------------------------------------------------------------------
    
    'ISR vom UART
    Uart_recieved:
    
    Bytes_received = Bytes_received + 1
    Input_string_overlay(bytes_received) = Udr
    
    
    Return
    
    '-------------------------------------------------------------------------------------------------------------------
    Danke für die Hilfe!

    Edit:
    Ich habe es nun auf den MCP2515 vom RN-Control eingrenzen können.
    Wenn ich den MCP abziehe, wieder anstecke und den Controller resete sodass der MCP neu initialisiert wird, kann ich wieder einen Remoteframe senden.
    Aber das oben beschriebene Problem kehrt wieder sobald ich einen Datenframe gesendet habe.
    Habe ich irgendwas in der Routine zum senden eines Remoteframes vergessen oder falsch gemacht?
    Geändert von Kampi (30.08.2012 um 18:46 Uhr)
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

  3. #3
    Moderator Robotik Einstein Avatar von Kampi
    Registriert seit
    21.11.2009
    Ort
    Monheim, Nordrhein-Westfalen, Germany
    Alter
    28
    Beiträge
    3.517
    Blog-Einträge
    9
    Ok das Problem hat sich geklärt. Die Lösung ist mir beim Stöbern des Datenblattes auf der Couch vorm Fernseher ins Gehirn geschossen ^.^
    Ich habe das falsche Register beschrieben.
    Und zwar habe ich habe folgendes geschrieben:

    Bitmodify Txb0ctrl , &H08 , &H08

    Aber dieses Bit "TxREQ" signalisiert nur, dass eine Remote Transmission Anfrage eingegangen ist.
    Richtig ist allerdings das hier:

    Write_register Txb0dlc , &H40

    Und laut Datenblatt bestimmt Bit 6 im Datalenght Register was für ein Frame gesendet wird.
    Eine 1 ist ein Remoteframe und eine 0 ein Datenframe
    Nun klappt es problemlos.
    Schaut ruhig mal auf meiner Homepage vorbei :
    http://kampis-elektroecke.de

    Oder folge mir auf Google+:
    Daniel Kampert

    Es gibt 10 Arten von Menschen. Die einen können Binär, die anderen nicht.

    Gruß
    Daniel

Ähnliche Themen

  1. TWI_BTR wird nicht 1
    Von Che Guevara im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 0
    Letzter Beitrag: 12.09.2011, 19:34
  2. Pro-Bot 128 wird von der IDE nicht erkannt
    Von Kosmogoniker im Forum Sonstige Roboter- und artverwandte Modelle
    Antworten: 7
    Letzter Beitrag: 02.02.2011, 18:49
  3. Antworten: 25
    Letzter Beitrag: 21.08.2008, 23:33
  4. controller wird nicht erkannt?!
    Von newbee im Forum AVR Hardwarethemen
    Antworten: 1
    Letzter Beitrag: 05.07.2007, 17:50
  5. I2C Adapter Software es wird immer WRITE gesendet
    Von yunscher im Forum C - Programmierung (GCC u.a.)
    Antworten: 8
    Letzter Beitrag: 29.03.2007, 19:12

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •