hcanap_2.inc

example of using Infineon 81c91 processor.

CGS_1:                  MOV     R7, #C_CAN_FAILURE
                        RET





$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ S T O P
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Anhalten des CAN-Treibers zur Neudefinition von Objekten
;*     (mit CAN_DEF_OBJ) oder zum tempor剅en Unterbrechen der
;*     Kommunikation. Im Unterschied zu CAN_HW_INIT werden bein Aufruf
;*     von CAN_STOP keine schon bestehenden Kommunikationsobjekte
;*     gel攕cht.
;*
;* BEGIN
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_STOP_ORDER;
;*       C_ORDER_BUF.TASK_ID := os_running_task_id ();
;*       os_send_signal an CAN-Task;
;*       os_wait (K_SIG,FFH,0);
;*       C_LEAVE_DRIVER;
;*       RETURN;
;*    ELSE
;*       RETURN C_CAN_FAILURE;
;*    END IF;
;* END CAN_STOP;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*     --
;*
;*  Returnwert in R7 :
;*
;*        C_OK                 Treiber gestoppt
;*        C_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/

?CAN?can_stop?HCANAPIF   SEGMENT CODE
                        RSEG    ?CAN?can_stop?HCANAPIF

can_stop:
                        ; Testen ob CAN-Task besetzt
                        CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CSP_1

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_STOP_ORDER, 0
                        ; Der Rest des Codes ist f乺 CAN_START, CAN_STOP
                        ; und CAN_GET_STATUS gemeinsam
                        JMP   COMMON_START_STOP_STATUS

CSP_1:                  MOV     R7, #C_CAN_FAILURE
                        RET



$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ S T A R T
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Starten des CAN-Treibers nach CAN_STOP oder nach CAN_DEF_OBJ
;*     (CAN_DEF_OBJ kann nur nach CAN_STOP oder CAN_HW_INIT ausgef乭rt
;*     werden).
;*
;* BEGIN
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_STOP_ORDER;
;*       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_START;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*     --
;*
;*     Returnwert in R7:
;*
;*        C_OK                 Treiber gestoppt
;*        C_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/

?CAN?can_start?HCANAPIF   SEGMENT CODE
                         RSEG    ?CAN?can_start?HCANAPIF

can_start:
                        ; Testen ob CAN-Task besetzt
                        CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CST_1

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_START_ORDER, 0


                        ; Der Rest des Codes ist f乺 CAN_START, CAN_STOP
                        ; und CAN_GET_STATUS gemeinsam

                        ; CAN-Task starten
COMMON_START_STOP_STATUS:
                        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

CST_1:                  MOV     R7, #C_CAN_FAILURE
                        RET




$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ S E N D
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Senden eines vorher mit CAN_DEF_OBJ definierten Objektes 乥er
;*     den CAN-Bus.
;*
;* BEGIN
;*    R3 := HIGH(MSG_PTR);
;*    R4 := LOW(MSG_PTR);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_SEND_ORDER;
;*       C_ORDER_BUF.PARAM[0] := R3;
;*       C_ORDER_BUF.PARAM[1] := R4;
;*       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_SEND;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*     R6/R7   : MSG_PTR            Pointer zu einer Struktur vom Typ
;*
;*
;*     Returnwert in R7 :
;*
;*        C_OK                 Objekt wird gesendet
;*        C_OBJ_ERROR          Das Objekt mit der angegebenen
;*                             Identifikation ist nicht bekannt oder
;*                             das Objekt kann nicht gesendet werden
;*                             (OBJECT_TYP in CAN_DEF_OBJ ist nur auf
;*                             Empfang)
;*        C_BUS_OFF            CAN-Controller ist im Bus-Off Zustand
;*        C_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/


?CAN?_can_send?HCANAPIF     SEGMENT CODE
                           RSEG    ?CAN?_can_send?HCANAPIF

_can_send:
                        MOV     A, R6
                        MOV     R3, A
                        MOV     A, R7
                        MOV     R4, A
                        ; Testen ob CAN-Task besetzt
                        CALL    C_ENTER_DRIVER
                        CJNE    A, #TRUE, CSE_1

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_SEND_ORDER, 2

                        ; Der Rest des Codes ist f乺 CAN_WRITE und CAN_SEND
                        ; gemeinsam
                        JMP   COMMON_WRITE_SEND

CSE_1:                  MOV     R7, #C_CAN_FAILURE
                        RET




$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ W R I T E
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Mit CAN_SEND wird ein Objekt direkt 乥er den CAN-Bus gesendet.
;*     Mit CAN_WRITE k攏nen neue Daten in ein Objekt geschrieben werden,
;*     ohne es sofort zu Senden. Falls dieses Objekt auf Remote-Frames
;*     antworten kann (wird mit CAN_DEF_OBJ festgelegt), werden beim
;*     Eintreffen eines entsprechenden Remote-Frames von einem anderen
;*     Knoten, diese neuen Daten ausgesendet.
;*
;* BEGIN
;*    R3 := HIGH(MSG_PTR);
;*    R4 := LOW(MSG_PTR);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_WRITE_ORDER;
;*       C_ORDER_BUF.PARAM[0] := R3;
;*       C_ORDER_BUF.PARAM[1] := R4;
;*       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_WRITE;
;*
;*---------------------------------------------------------------------*
;*  Parameter :
;*
;*     R6/R7   : MSG_PTR         Pointer zu einer Struktur vom Typ
;*
;*
;*     Returnwert in R7 :
;*
;*        C_OK                 Objekt wurde neu beschrieben
;*        C_OBJ_ERROR          Das Objekt mit der angegebenen
;*                             Identifikation ist nicht bekannt oder das
;*                             Objekt kann nicht gesendet werden
;*                             (OBJECT_TYP in CAN_DEF_OBJ ist nur
;*                             auf Empfang)
;*        C_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/


?CAN?_can_write?HCANAPIF     SEGMENT CODE
                            RSEG    ?CAN?_can_write?HCANAPIF

_can_write:
                        MOV     A, R6
                        MOV     R3, A
                        MOV     A, R7
                        MOV     R4, A

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

                        ; Befehle an CAN-Task aufsetzen
                        SETUP_ORDER CAN_WRITE_ORDER, 2

                        ; Der Rest des Codes ist f乺 CAN_WRITE und CAN_SEND
                        ; gemeinsam

                        ; CAN-Task starten
COMMON_WRITE_SEND:
                        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

CWR_1:                  MOV     R7, #C_CAN_FAILURE
                        RET




$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ R E C E I V E
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Empfangen aller normalen Objekte (alle die nicht mit
;*     CAN_BIND_OBJ einem bestimmten Task zugeordnet sind). Die
;*     empfangenen Meldungen werden in einer Mailbox
;*     zwischengespeichert. Es k攏nen maximal 8 Objekte zwischengespeichert
;*     werden. Falls der Applikationstask die Objekte nicht aus
;*     der Mailbox liest gehen alle weiteren Objekte verloren
;*     (sie werden dem Applikationstask nicht 乥ermittelt).
;*
;* BEGIN
;*    R3 := TIMEOUT;
;*    R4 := HIGH(BUFFER_PTR);
;*    R5 := LOW(BUFFER_PTR);
;*    PUSH R4;
;*    PUSH R5;
;*    ret = os_wait (K_TMO + K_MBX + 7, R3, BUFFER_PTR (* R4 und R5 *));
;*    POP R5;
;*    POP R4;
;*    IF ret = TMO_EVENT THEN
;*       RETURN C_TIMEOUT;
;*    END;
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_READ_W_IND_ORDER;
;*       C_ORDER_BUF.PARAM[0] := R4;
;*       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;