icanap_2.inc

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

;*       C_ORDER_BUF.PARAM[1] := R5;
;*       C_ORDER_BUF.PARAM[2] := Wert an der Adresse BUFFER_PTR+1 (* R4,R5 *)
;*       (* Der CAN-Task sendet 乥er die Mailbox den Index des empfangenen *)
;*       (* Objektes, dieser Index wird an die Adresse BUFFER_PTR          *)
;*       (* abgespeichert -> BUFFER_PTR als Argument bei RTX_WAIT          *)
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,0FFH,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;
;* END CAN_RECEIVE;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*     R7      : TIMEOUT           Timeout falls in einer bestimmten Zeit
;*                                 kein Objekt empfangen wurde. Definition
;*                                 analog RTX-51;
;*                                 0        :  Kein Timeout, falls kein
;*                                             Objekt vorhanden ist, l剈ft
;*                                             der Applikations-Task weiter
;*                                             ohne zu warten
;*                                 1..254   :  Anzahl RTX-51 Systemticks
;*                                             die der Applikations-Task
;*                                             auf ein Objekt warten soll
;*                                 255      :  Warten bis ein Objekt
;*                                             empfangen wurde
;*                                             (wait forever)
;*
;*     R4/R5   : BUFFER_PTR        Pointer zu einer Struktur von Typ
;*                                 CAN_MESSAGE_STRUCT im externen RAM.
;*                                 Der CAN-Treiber kopiert das empfangene
;*                                 Objekt in diese Variable.
;*
;*
;*     Returnwert in R7 :
;*
;*        C_OK                 Es wurde ein Objekt empfangen
;*        C_TIMEOUT            Es wurde innerhalb der mit TIMEOUT
;*                             angegebenen Zeit kein Objekt empfangen
;*        C_BUS_OFF            CAN-Controller ist im Bus-Off Zustand
;*        C_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/


?CAN?_can_receive?ICANAPIF        SEGMENT CODE
                                 RSEG    ?CAN?_can_receive?ICANAPIF

_can_receive:
                        MOV     A, R7
                        MOV     R3, A
                        MOV     A, R4
                        PUSH    ACC
                        MOV     A, R5
                        PUSH    ACC
                        MOV     R7, #(K_MBX+K_TMO+7)
                        MOV     B, R3
                        MOV     A, R4
                        MOV     R2, A
                        MOV     A, R5
                        MOV     R3, A
                        MOV     R5, B
                        CALL    _os_wait
                        POP     ACC
                        MOV     R5, A
                        POP     ACC
                        MOV     R4, A

                        ; Test ob Timeout
                        CJNE    R7, #TMO_EVENT, CRE_1
                        MOV     R7, #C_TIMEOUT
                        RET

                        ; Testen ob CAN-Task besetzt
CRE_1:                  CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CRE_2

                        ; Befehle an CAN-Task aufsetzen
                        MOV     DPTR, #C_ORDER_BUF_ORDER
                        MOV     A, #CAN_READ_W_IND_ORDER
                        MOVX    @DPTR, A
                        INC     DPL
                        INC     DPL
                        MOV     A, R4
                        MOVX    @DPTR, A
                        INC     DPL
                        MOV     A, R5
                        MOVX    @DPTR, A

                        MOV     DPH, R4
                        MOV     DPL, R5
                        INC     DPTR      ; Nur Low-Byte nehmen
                        MOVX    A, @DPTR
                        MOV     DPTR, #C_ORDER_BUF_PARAM+2
                        MOVX    @DPTR, A
                        CALL    os_running_task_id
                        MOV     DPTR, #C_ORDER_BUF_ID
                        MOV     A, R7
                        MOVX    @DPTR, A

                        ; 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

CRE_2:                  MOV     R7, #C_CAN_FAILURE
                        RET




$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ B I N D _ O B J
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Bindet ein bestimmtes (mit CAN_DEF_OBJ) definiertes Objekt an
;*     einen bestimmten Task. Beim Empfang dieses Objekts wird dieser
;*     Task gestartet (er muss mit CAN_WAIT auf dieses Objekt warten).
;*     Diese Funktion implementiert einen besonders schnellen Empfang
;*     eines bestimmten, besonders wichtigen Objektes. Ein Task kann mit
;*     CAN_BIND_OBJ an mehrere Objekte gekoppelt werden (mehrfacher
;*     Aufruf von CAN_BIND_OBJ). Beim Empfang eines dieser Objekte wird
;*     der Task gestartet (wenn er mit CAN_WAIT wartet).
;*
;* BEGIN
;*    R4 := HIGH(IDENTIFIER);
;*    R5 := LOW(IDENTIFIER);
;*    R6 := HIGH(IDENTIFIER);
;*    R7 := LOW(IDENTIFIER);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_BIND_ORDER;
;*       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] := os_running_task_id ();
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,0FFH,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_BIND_OBJ;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*     R6/R7:   IDENTIFIER        Identifikation des Objekts das fest an
;*                                den aufrufenden Task gebunden werden soll
;*
;*  Returnwert in R7 :
;*
;*     C_OK                 Das Objekt IDENTIFIER wurde an den Task
;*                          gebunden
;*     C_OBJ_ERROR          Das Objekt mit der angegebenen Identifikation
;*                          ist nicht bekannt oder das Objekt kann nicht
;*                          empfangen werden
;*     C_MEM_FULL           Es wurden bereits acht CAN_BIND_OBJ
;*                          durchgef乭rt (mit CAN_UNBIND_OBJ kann wieder
;*                          eine Bindung frei gemacht werden)
;*     C_OBJ_REBIND         Warnung : Das Objekt mit dem angegebenen
;*                          Identifier war bereits an einen Task gebunden.
;*                          Die alte Verbindung wurde gel攕t und die neue
;*                          aufgebaut.
;*
;*---------------------------------------------------------------------*/


?CAN?_can_bind_obj?ICANAPIF    SEGMENT CODE
                              RSEG    ?CAN?_can_bind_obj?ICANAPIF

_can_bind_obj:
                        MOV     A, R4
                        MOV     R3, A

                        MOV     A, R5
                        MOV     R4, A

                        MOV     A, R6
                        MOV     R5, A

                        MOV     A, R7
                        MOV     R6, A

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

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_BIND_OBJ_ORDER, 4
                        MOV     DPTR, #C_ORDER_BUF_ID
                        MOVX    A, @DPTR
                        MOV     DPTR, #C_ORDER_BUF_PARAM+4
                        MOVX    @DPTR, A

                        ; 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

CBO_1:                  MOV     R7, #C_CAN_FAILURE
                        RET



$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ U N B I N D _ O B J
;*---------------------------------------------------------------------*
;*  Funktion:
;*     L攕t eine mit CAN_BIND_OBJ aufgebaute Verbindung zwischen
;*     dem Task und dem Objekt IDENTIFIER. Ab sofort kann dieses
;*     Objekt wieder mit CAN_RECEIVE empfangen werden.
;*
;* BEGIN
;*    R4 := HIGH(IDENTIFIER);
;*    R5 := LOW(IDENTIFIER);
;*    R6 := HIGH(IDENTIFIER);
;*    R7 := LOW(IDENTIFIER);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_UNBIND_ORDER;
;*       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.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,0FFH,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_UNBIND_OBJ;
;*
;*---------------------------------------------------------------------*
;*  Parameter (abgespeichert ab ?CAN_UNBIND_OBJ?BYTE) :
;*
;*     R6/R7        IDENTIFIER   Identifikation des Objekts
;*
;*
;*  Returnwert in R7 :
;*
;*     C_OK                 Das Objekt IDENTIFIER wurde vom Task gel攕t
;*     C_OBJ_ERROR          Das Objekt IDENTIFIER existiert nicht (es
;*                          wurde nicht mit CAN_DEF_OBJ definiert oder
;*                          es wurde nie mit CAN_BIND_OBJ an den Task
;*                          gebunden)
;*
;*---------------------------------------------------------------------*/


?CAN?_can_unbind_obj?ICANAPIF    SEGMENT CODE
                                RSEG    ?CAN?_can_unbind_obj?ICANAPIF

_can_unbind_obj:
                        MOV     A, R4
                        MOV     R3, A

                        MOV     A, R5
                        MOV     R4, A

                        MOV     A, R6
                        MOV     R5, A

                        MOV     A, R7
                        MOV     R6, A

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

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_UNBIND_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

CUO_1:                  MOV     R7, #C_CAN_FAILURE
                        RET

$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ B I N D _ L A S T _ O B J
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Bindet 15. (mit CAN_DEF_OBJ) definiertes Objekt an
;*     einen bestimmten Task. Beim Empfang dieses Objekts wird dieser
;*     Task gestartet (er muss mit CAN_WAIT auf dieses Objekt warten).
;*     Diese Funktion implementiert einen besonders schnellen Empfang
;*     eines bestimmten, besonders wichtigen Objektes. Ein Task kann mit
;*     CAN_BIND_OBJ an mehrere Objekte gekoppelt werden (mehrfacher
;*     Aufruf von CAN_BIND_OBJ). Beim Empfang eines dieser Objekte wird
;*     der Task gestartet (wenn er mit CAN_WAIT wartet).
;*
;* BEGIN
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_BIND_L_ORDER;
;*       C_ORDER_BUF.PARAM[1] := os_running_task_id ();
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,0FFH,0);
;*       PUSH(C_ORDER_BUF.PARAM[0]);  (* Returnwert auf Stack pushen *)