pcanap_2.inc

Philips sja1000 can controller. it contains example on how to control this device

;*       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?PCANAPIF    SEGMENT CODE
				RSEG    ?CAN?_can_unbind_obj?PCANAPIF

_can_unbind_obj:
			MOV     A, R6
			MOV     R3, A
			MOV     A, R7
			MOV     R4, 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, 2

			; 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 _ 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?PCANAPIF       SEGMENT CODE
			     RSEG    ?CAN?_can_wait?PCANAPIF

_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
;*    R3 := HIGH(IDENTIFIER);
;*    R4 := LOW(IDENTIFIER);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_REQUEST_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_REQUEST;
;*
;*---------------------------------------------------------------------*
;*  Parameter (abgespeichert ab ?CAN_REQUEST?BYTE) :
;*
;*     R6/R7        IDENTIFIER   Identifikation des Kommunikationsobjektes
;*                                entsprechend der CAN-Definition (0 .. 7EFH)
;*
;*
;*  Returnwert in R7 :
;*
;*     C_OK                 Das Remote-Frame wird ausgesendet
;*     C_OBJ_ERROR          Das Objekt IDENTIFIER existiert nicht oder
;*                          es kann kein Remote-Frame aussenden
;*     C_BUS_OFF            CAN-Controller ist im Bus-Off Zustand
;*     C_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/


?CAN?_can_request?PCANAPIF    SEGMENT CODE
			     RSEG    ?CAN?_can_request?PCANAPIF

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

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

			; Befehle an CAN-Task aufsetzen
			SETUP_ORDER CAN_REQUEST_ORDER, 2

			; 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

CRQ_1:                  MOV     R7, #C_CAN_FAILURE
			RET




$EJECT
;*---------------------------------------------------------------------*
;*     C A N _ R E A D
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Mit dieser Funktion kann jederzeit die gerade aktuelle Version
;*     jedes Objekts gelesen werden (unabh刵gig davon, ob die Objekte
;*     mit CAN_DEF_OBJ als Empfangs- oder Sende-Objekte konfiguriert
;*     wurden). Diese Funktion ist kein Ersatz f乺 CAN_RECEIVE, sondern
;*     ist vor allem w刪rend der Testphase des Applikationstask n乼zlich.
;*
;* VAR
;*    IND : BYTE;
;* BEGIN
;*    R3 := HIGH(IDENTIFIER);
;*    R4 := LOW(IDENTIFIER)
;*    R5 := HIGH(BUFFER_PTR);
;*    R6 := LOW(BUFFER_PTR);
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_READ_ORDER;
;*       C_ORDER_BUF.PARAM[0] := R5;
;*       C_ORDER_BUF.PARAM[1] := R6;
;*       C_ORDER_BUF.PARAM[2] := R3;
;*       C_ORDER_BUF.PARAM[3] := 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;
;* END CAN_READ;
;*
;*---------------------------------------------------------------------*
;*  Parameter (abgespeichert ab ?CAN_READ?BYTE) :
;*
;*     R6      HIGH(IDENTIFIER)  Identifikation des Kommunikationsobjektes
;*     R7      LOW(IDENTIFIER)   entsprechend der CAN-Definition (0 .. 7EFH)
;*     R4      HIGH(BUFFER_PTR)  Pointer zu einer Struktur von Typ
;*     R5      LOW(BUFFER_PTR)   CAN_MESSAGE_STRUCT im externen RAM.
;*                               Der CAN-Treiber kopiert das Objekt in
;*                               diese Variable.
;*
;*
;*  Returnwert in R7 :
;*
;*     C_OK                 Objekt IDENTIFIER gelesen
;*     C_OBJ_ERROR          Objekt IDENTIFIER existiert nicht
;*
;*---------------------------------------------------------------------*/


?CAN?_can_read?PCANAPIF    SEGMENT CODE
			  RSEG    ?CAN?_can_read?PCANAPIF

_can_read:
			MOV   B, R4
			MOV   A, R6
			MOV   R3, A
			MOV   A, R7
			MOV   R4, A
			MOV   A, R5
			MOV   R6, A
			MOV   R5, B

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

			; Befehle an CAN-Task aufsetzen
			MOV     DPTR, #C_ORDER_BUF_ORDER
			MOV     A, #CAN_READ_ORDER
			MOVX    @DPTR, A
			INC     DPTR
			INC     DPTR
			MOV     A, R5
			MOVX    @DPTR, A
			INC     DPTR
			MOV     A, R6
			MOVX    @DPTR, A
			INC     DPTR
			MOV     A, R3
			MOVX    @DPTR, A
			INC     DPTR
			MOV     A, R4
			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

CRD_1:                  MOV     R7, #C_CAN_FAILURE
			RET




;=======================================================================
;
;     ENDE DES INCLUDE FILE CANAP_2.INC
;
;=======================================================================