icanap_2.inc

infineon C515C RTX51 example. it contains example on using this device

$EJECT
;=======================================================================
;
;     INCLUDE FILE DES MODULS ICANAPIF.A51
;
;=======================================================================



;*---------------------------------------------------------------------*
;*     C A N _ T A S K _ C R E A T E
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Starten des CAN-Task. Als erste Operation muss immer diese
;*     Funktion ausgef乭rt werden, alle weiteren CAN-Operationen
;*     d乺fen nur nach dem Aufruf dieser Operation ausgef乭rt werden.
;*
;* VAR
;*    I : BYTE;
;*
;* BEGIN
;*    C_DRIVER_IN_USE := FALSE;
;*    FOR I:=0 TO 2 DO
;*       C_TEMP_ORDER_BUF[I].OCCUPIED := FALSE;
;*    END FOR;
;*    CAN-Task starten;
;*    IF Task-gestartet THEN
;*       RETURN C_OK;
;*    ELSE
;*       RETURN C_NOT_STARTED;
;*    END;
;* END CAN_TASK_CREATE;
;*
;*---------------------------------------------------------------------*
;*  Parameter:
;*
;*     --
;*
;*  Returnwert im AKKU :
;*
;*        C_OK          :   CAN-Task gestartet
;*        C_NOT_STARTED :   CAN-Task konnte nicht gestartet werden
;*
;*---------------------------------------------------------------------*/

?CAN?can_task_create?ICANAPIF     SEGMENT CODE
                                 RSEG    ?CAN?can_task_create?ICANAPIF

can_task_create:
                        ; Globale Variablen Initialisieren
                        CLR     C_DRIVER_IN_USE
                        MOV     A,#FALSE
                        MOV     DPTR,#C_TEMP_BUF_0_OCC
                        MOVX    @DPTR,A
                        MOV     DPTR,#C_TEMP_BUF_1_OCC
                        MOVX    @DPTR,A
                        MOV     DPTR,#C_TEMP_BUF_2_OCC
                        MOVX    @DPTR,A

                        ; CAN-Task starten
                        MOV     R7, #C_DRIVER_ID
                        CALL    _os_create_task
                        ; R乧kgabewert auswerten
                        MOV     A, R7
                        JNZ     CTS_1
                        ; Task gestartet
                        MOV     R7, #C_OK
                        RET
CTS_1:                  ; Task konnte nicht gestartet werden
                        MOV     R7, #C_NOT_STARTED
                        RET

$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ H W _ I N I T
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Grundlegende HW-Initialisierung des CAN-Controllers, L攕chen
;*     aller Kommunikationsobjekte. Nach einem CAN_HW_INIT ist der
;*     CAN-Treiber bereit zu einer kompletten Neudefinition aller
;*     Kommunikationsobjekte.
;*
;* BEGIN
;*            62526 und ANDERE        82527
;*            ----------------        -----
;*    R3 := BUS_TIMING_0;        BUS_TIMING_0
;*    R4 := BUS_TIMING_1;        BUS_TIMING_1
;*    R5 := DUMMY_1;             KEINE VERWENDUNG
;*    R6 := DUMMY_2              KEINE VERWENDUNG
;*    R7 := DUMMY_3;             KEINE VERWENDUNG
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_HW_INIT_ORDER;
;*       C_ORDER_BUF.PARAM[0] := R3;
;*       C_ORDER_BUF.PARAM[1] := R4;
;*       C_ORDER_BUF.PARAM[2] := R5;
;*       C_ORDER_BUF.PARAM[3] := R6;
;*       C_ORDER_BUF.PARAM[4] := R7;
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,FFH,0);
;*       PUSH(C_ORDER_BUF.PARAM[0]);  (* Returnwert auf Stack pushen *)
;*       C_LEAVE_DRIVER;
;*       POP(ACC);                    (* Returnwert in Akku *)
;*       RETURN;
;*    ELSE
;*       RETURN C_CAN_FAILURE;
;*    END IF;
;* END CAN_HW_INIT;
;*
;*---------------------------------------------------------------------*
;*  Parameter (abgespeichert ab ?_can_hw_init?BYTE) :
;*
;*     1. Byte : BUS_TIMING_0    Bus-Timing Register 0 des CAN-Controllers
;*     2. Byte : BUS_TIMING_1    Bus-Timing Register 1 des CAN-Controllers
;*     3. Byte : DUMMY_1         KEINE VERWENDUNG
;*     4. Byte : DUMMY_2         KEINE VERWENDUNG
;*     5. Byte : DUMMY_3         KEINE VERWENDUNGs
;*
;*
;*  Returnwert in R7 :
;*
;*        C_OK                Funktion ausgef乭rt
;*        C_CONF_ERROR        Unm攇liches Bus-Timing oder OUT_CONTROL Wert
;*        C_CAN_FAILURE       Probleme mit dem CAN-Controller
;*                            (falsche Adresse usw.)
;*
;*---------------------------------------------------------------------*/

;* Bereich f乺 die Parameter-Uebergabe (mehr als 3 Parameter)
?XD?_can_hw_init?ICANAPIF        SEGMENT XDATA
                                RSEG ?XD?_can_hw_init?ICANAPIF
?_can_hw_init?BYTE:
bus_timing_0:           DS 1
bus_timing_1:           DS 1
dummy_1:                DS 1
dummy_2:                DS 1
dummy_3:                DS 1


?CAN?_can_hw_init?ICANAPIF     SEGMENT CODE
                              RSEG    ?CAN?_can_hw_init?ICANAPIF

_can_hw_init:
                        ; Parameter in die Register holen
                        ; die ersten 3 Parameter sind bereits in den Regs.
                        MOV     A, R5
                        MOV     R4, A               ; speichere Bus-timing-1

                        MOV     A, R3
                        MOV     R5, A

                        MOV     A, R7
                        MOV     R3, A               ; speichere bus-timing-0

                        MOV     DPTR, #dummy_2
                        MOVX    A, @DPTR
                        MOV     R6, A
                        INC     DPTR
                        MOVX    A, @DPTR
                        MOV     R7, A

                        ; Testen ob CAN-Task besetzt
                        CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CHI_1

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_HW_INIT_ORDER, 5

                        ; CAN-Task starten
                        MOV     R7, #C_DRIVER_ID
                        CALL    _os_send_signal
                        MOV     R7, #K_SIG
                        CALL    _os_wait
                        ;Returnwert retten
                        MOV     DPTR, #C_ORDER_BUF_PARAM
                        MOVX    A, @DPTR
                        PUSH    ACC
                        CALL    C_LEAVE_DRIVER
                        POP     ACC
                        MOV     R7, A
                        RET

CHI_1:                  MOV     R7, #C_CAN_FAILURE
                        RET



$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ D E F _ O B J
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Definieren eines neuen Kommunikationsobjekts. Diese Funktion
;*     kann nur nach CAN_HW_INIT oder nach CAN_STOP ausgef乭rt werden.
;*     Es k攏nen Objekte definiert werden, bis der Objekt-Speicher voll
;*     ist (beim Full-CAN ist dies das Controller-interne Dual-Port RAM,
;*     beim Basic-CAN wird der Objekt-Speicher im externen RAM alloziert)
;*     oder die maximale Anzahl von 255 definierten Objekten erreicht ist.
;*     Falls ein Objekt definiert wird, dass bereits existiert, wird eine
;*     Fehlermeldung (in CANRETURN) zur乧kgegeben.
;*     Nach der Beendigung der Initialisierung kann der CAN-Treiber mit
;*     CAN_START gestartet werden.
;*
;* BEGIN
;*    R3 := HIGH(IDENTIFIER);
;*    R4 := LOW(IDENTIFIER);
;*    R5 := DATA_LENGTH;
;*    R6 := OBJECT_TYP;
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_DEF_OBJ_ORDER;
;*       C_ORDER_BUF.PARAM[0] := R3;
;*       C_ORDER_BUF.PARAM[1] := R4;
;*       C_ORDER_BUF.PARAM[2] := R5;
;*       C_ORDER_BUF.PARAM[3] := R6;
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,0,0);
;*       PUSH(C_ORDER_BUF.PARAM[0]);  (* Returnwert auf Stack pushen *)
;*       C_LEAVE_DRIVER;
;*       POP(ACC);                    (* Returnwert in Akku *)
;*       RETURN;
;*    ELSE
;*       RETURN C_CAN_FAILURE;
;*    END IF;
;* END CAN_HW_INIT;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*    R6/R7   : IDENTIFIER       Identifikation des Kommunikationsobjektes
;*                               entsprechend der CAN-Definition (0 .. 7EFH)
;*    R5      : DATA_LENGTH      Anzahl Datenbyte im Objekt (0..8)
;*    R3      : OBJECT_TYP       Genauere Beschreibung der Verwendungsart
;*                               des Objektes
;*
;*
;*  Returnwert in R7 :
;*
;*        C_OK                Objekt definiert
;*        C_NOT_STOPPED       CAN_STOP oder CAN_HW_INIT muss vor der
;*                            Ausf乭rung dieser Funktion aufgerufen werden
;*        C_OBJ_ERROR         Objekt existiert schon
;*        C_TOO_LONG          DATA_LENGTH ist gr攕ser als 8
;*        C_INVALID_TYPE      Falscher Objekttyp
;*        C_MEM_FULL          Objekt-Speicher ist voll, es k攏nen keine
;*                            neuen Objekte definiert werden
;*                            (zuerst alle Objekte mit CAN_HW_INIT l攕chen).
;*                            Entweder sind bereits 255 Objekte definiert
;*                            oder der Objekt-Speicher ist voll.
;*
;*---------------------------------------------------------------------*/


?CAN?_can_def_obj?ICANAPIF     SEGMENT CODE
                              RSEG    ?CAN?_can_def_obj?ICANAPIF
_can_def_obj:
                        XCHR    R6, R3
                        MOV     A, R7
                        MOV     R4, A
                        ; Testen ob CAN-Task besetzt
                        CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CDO_1

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_DEF_OBJ_ORDER, 4

                        ; CAN-Task starten
                        MOV     R7, #C_DRIVER_ID
                        CALL    _os_send_signal
                        MOV     R7, #K_SIG
                        CALL    _os_wait
                        ;Returnwert retten
                        MOV     DPTR, #C_ORDER_BUF_PARAM
                        MOVX    A, @DPTR
                        PUSH    ACC
                        CALL    C_LEAVE_DRIVER
                        POP     ACC
                        MOV     R7, A
                        RET

CDO_1:                  MOV     R7, #C_CAN_FAILURE
                        RET





$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ D E F _ O B J _ E X T
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Definieren eines neuen Kommunikationsobjekts. Diese Funktion
;*     kann nur nach CAN_HW_INIT oder nach CAN_STOP ausgef乭rt werden.
;*     Es k攏nen Objekte definiert werden, bis der Objekt-Speicher voll
;*     ist (beim Full-CAN ist dies das Controller-interne Dual-Port RAM,
;*     beim Basic-CAN wird der Objekt-Speicher im externen RAM alloziert)
;*     oder die maximale Anzahl von 255 definierten Objekten erreicht ist.
;*     Falls ein Objekt definiert wird, dass bereits existiert, wird eine
;*     Fehlermeldung (in CANRETURN) zur乧kgegeben.
;*     Nach der Beendigung der Initialisierung kann der CAN-Treiber mit
;*     CAN_START gestartet werden.
;*
;* BEGIN
;*    R4 := HIGH(IDENTIFIER);
;*    R5 := LOW(IDENTIFIER);
;*    R6 := HIGH(IDENTIFIER);
;*    R7 := LOW(IDENTIFIER);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_DEF_OBJ_ORDER_EXT;
;*       C_ORDER_BUF.PARAM[0] := R4;
;*       C_ORDER_BUF.PARAM[1] := R5;
;*       C_ORDER_BUF.PARAM[2] := R6;
;*       C_ORDER_BUF.PARAM[3] := R7;
;*       C_ORDER_BUF.PARAM[4] := dat_len;
;*       C_ORDER_BUF.PARAM[5] := oby_typ ;
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,0,0);
;*       PUSH(C_ORDER_BUF.PARAM[0]);  (* Returnwert auf Stack pushen *)
;*       C_LEAVE_DRIVER;
;*       POP(ACC);                    (* Returnwert in Akku *)
;*       RETURN;
;*    ELSE
;*       RETURN C_CAN_FAILURE;
;*    END IF;
;* END CAN_HW_INIT;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*    R4/R7   : IDENTIFIER       Identifikation des Kommunikationsobjektes
;*                               entsprechend der CAN-Definition (0 .. 7EFH)
;*    dat_len : DATA_LENGTH      Anzahl Datenbyte im Objekt (0..8)
;*    obj_typ : OBJECT_TYP       Genauere Beschreibung der Verwendungsart
;*                               des Objektes
;*
;*
;*  Returnwert in R7 :
;*
;*        C_OK                Objekt definiert
;*        C_NOT_STOPPED       CAN_STOP oder CAN_HW_INIT muss vor der
;*                            Ausf乭rung dieser Funktion aufgerufen werden