icanap_2.inc

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

;*       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_last_obj?ICANAPIF    SEGMENT CODE
                              RSEG    ?CAN?can_bind_last_obj?ICANAPIF

can_bind_last_obj:
                        ; Testen ob CAN-Task besetzt
                        CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CBO_L_1

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_BIND_L_OBJ_ORDER, 0

                        MOV     DPTR, #C_ORDER_BUF_ID
                        MOVX    A, @DPTR
                        MOV     DPTR, #C_ORDER_BUF_PARAM+1
                        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_L_1:                MOV     R7, #C_CAN_FAILURE
                        RET



$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ U N B I N D _ L A S T _ O B J
;*---------------------------------------------------------------------*
;*  Funktion:
;*     L攕t eine mit CAN_BIND_OBJ aufgebaute Verbindung zwischen
;*     dem Task und dem Last Objekt. Ab sofort kann dieses
;*     Objekt wieder mit CAN_RECEIVE empfangen werden.
;*
;* BEGIN
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_UNBIND_L_ORDER;
;*       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_last_obj?ICANAPIF  SEGMENT CODE
                                   RSEG    ?CAN?can_unbind_last_obj?ICANAPIF

can_unbind_last_obj:
                        ; Testen ob CAN-Task besetzt
                        CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CUO_L_1

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_UNBIND_L_OBJ_ORDER, 0

                        ; 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+1
                        MOVX    A, @DPTR
                        PUSH    ACC
                        CALL    C_LEAVE_DRIVER
                        POP     ACC
                        MOV     R7, A
                        RET

CUO_L_1:                MOV     R7, #C_CAN_FAILURE
                        RET




$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ W A I T
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Diese Funktion ist nur im Zusammenhang mit CAN_BIND_OBJ sinnvoll.
;*     Der Task wartet auf den Empfang eines der mit CAN_BIND_OBJ an
;*     diesen Task gebundenen Objekte. Nach dem Empfang wird das
;*     entsprechende Objekt in die durch BUFFER_PTR bezeichnete
;*     Variable kopiert und der Task gestartet.
;*
;* BEGIN
;*    R3 := TIMEOUT;
;*    R4 := HIGH(BUFFER_PTR);
;*    R5 := LOW(BUFFER_PTR);
;*    PUSH R4;
;*    PUSH R5;
;*    PUSH R3;
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_ACTIVATE_WRITE_ORDER;
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       C_LEAVE_DRIVER;
;*       RETURN;
;*    ELSE
;*       POP R3;
;*       POP R5;
;*       POP R4;
;*       RETURN C_CAN_FAILURE;
;*    END;
;*    POP R3;
;*    RTX_WAIT (K_TMO + K_SIG, R3, 0);
;*    POP R5;
;*    POP R4;
;*    IF RTXRETURN = TMO_EVENT THEN
;*       RETURN C_TIMEOUT;
;*    END;
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_READ_W_TID_ORDER;
;*       C_ORDER_BUF.PARAM[0] := R4;
;*       C_ORDER_BUF.PARAM[1] := R5;
;*       C_ORDER_BUF.PARAM[2] := 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;
;* END CAN_WAIT;
;*
;*---------------------------------------------------------------------*
;*  Parameter (abgespeichert ab ?CAN_WAIT?BYTE) :
;*
;*     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   : HIGH(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_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/


?CAN?_can_wait?ICANAPIF       SEGMENT CODE
                             RSEG    ?CAN?_can_wait?ICANAPIF

_can_wait:
                        MOV     A, R7
                        MOV     R3, A
                        MOV     A, R4
                        PUSH    ACC
                        MOV     A, R5
                        PUSH    ACC
                        MOV     A, R3
                        PUSH    ACC

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

                        ; Befehle an CAN-Task aufsetzen
                        MOV     DPTR, #C_ORDER_BUF_ORDER
                        MOV     A, #CAN_ACTIVATE_WAIT_ORDER
                        MOVX    @DPTR, A
                        CALL    os_running_task_id
                        MOV     A, R7
                        MOV     DPTR, #C_ORDER_BUF_ID
                        MOVX    @DPTR, A
                        ; CAN-Task starten
                        MOV     R7, #C_DRIVER_ID
                        CALL    _os_send_signal
                        CALL    C_LEAVE_DRIVER
                        JMP     CWA_4

CWA_3:                  POP     ACC
                        POP     ACC
                        POP     ACC
                        MOV     R7, #C_CAN_FAILURE
                        RET

CWA_4:                  MOV     R7, #(K_TMO+K_SIG)
                        POP     ACC
                        MOV     R5, A
                        CALL    _os_wait
                        POP     ACC
                        MOV     R5, A
                        POP     ACC
                        MOV     R4, A

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

                        ; Testen ob CAN-Task besetzt
CWA_1:                  CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CWA_2

                        ; Befehle an CAN-Task aufsetzen
                        MOV     DPTR, #C_ORDER_BUF_ORDER
                        MOV     A, #CAN_READ_W_TID_ORDER
                        MOVX    @DPTR, A
                        INC     DPTR
                        INC     DPTR
                        MOV     A, R4
                        MOVX    @DPTR, A
                        INC     DPTR
                        MOV     A, R5
                        MOVX    @DPTR, A
                        CALL    os_running_task_id
                        MOV     A, R7
                        MOV     DPTR, #C_ORDER_BUF_ID
                        MOVX    @DPTR, A
                        MOV     DPTR, #C_ORDER_BUF_PARAM+2
                        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

CWA_2:                  MOV     R7, #C_CAN_FAILURE
                        RET




$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ R E Q U E S T
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Sendeanforderung (Remote-Frame) f乺 ein bestimmtes Objekt
;*     aussenden. Der CAN-Treiber sendet ein Remote-Frame und
;*     benachrichtigt die Applikation nach dem Empfang des
;*     entsprechendenden Objekts auf dem 乥lichen Weg (CAN_RECEIVE
;*     oder CAN_WAIT).
;*
;* BEGIN
;*    R4 := HIGH(IDENTIFIER);
;*    R5 := LOW(IDENTIFIER);
;*    R6 := HIGH(IDENTIFIER);
;*    R7 := LOW(IDENTIFIER);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_REQUEST_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 p