pcanap_2.inc

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

$EJECT
;=======================================================================
;
;     INCLUDE FILE DES MODULS PCANAPIF.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?PCANAPIF     SEGMENT CODE
				 RSEG    ?CAN?can_task_create?PCANAPIF

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
;*    R3 := BUS_TIMING_0;
;*    R4 := BUS_TIMING_1;
;*    R5 := OUT_CONTROL;
;*    R6 := SYNCON
;*    R7 := SLEEP_MODE;
;*    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 : OUT_CONTROL     Konfiguration der Ausgangstreiber des CAN-
;*                               Controllers
;*     4. Byte : SYNCON          Resynchronisations-Mode des CAN-Controllers
;*     5. Byte : SLEEP_MODE      Sleep-Mode des CAN-Controllers
;*                               0  :  kein Sleep-Mode
;*                               1  :  Sleep-Mode ist aktiv
;*
;*
;*  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?CANAPIF        SEGMENT XDATA
				RSEG ?XD?_can_hw_init?CANAPIF
?_can_hw_init?BYTE:
bus_timing_0:           DS 1
bus_timing_1:           DS 1
out_control:            DS 1
syncon:                 DS 1
sleep_mode:             DS 1


?CAN?_can_hw_init?PCANAPIF     SEGMENT CODE
			      RSEG    ?CAN?_can_hw_init?PCANAPIF

_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               ; speichere out-control
			MOV     A, R7
			MOV     R3, A               ; speichere bus-timing-0
			MOV     DPTR, #syncon
			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?PCANAPIF     SEGMENT CODE
			      RSEG    ?CAN?_can_def_obj?PCANAPIF

_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 _ G E T _ S T A T U S
;*---------------------------------------------------------------------*
;*  Funktion:
;*     Lesen des aktuellen CAN-Controller Status.
;*
;* BEGIN
;*    IF C_ENTER_DRIVER THEN
;*       C_ORDER_BUF.ORDER := CAN_GET_STATUS_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_ERR_ACTIVE         Normale Operation
;*        C_ERR_PASSIVE        Error-passive mode erreicht
;*        C_BUS_OFF            CAN-Controller ist Bus-Off
;*        C_CAN_FAILURE        CAN-Error
;*
;*---------------------------------------------------------------------*/

?CAN?can_get_status?PCANAPIF   SEGMENT CODE
			      RSEG    ?CAN?can_get_status?PCANAPIF

can_get_status:
			; Testen ob CAN-Task besetzt
			CALL    C_ENTER_DRIVER
			CJNE    A, #TRUE, CGS_1

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

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?PCANAPIF   SEGMENT CODE
			RSEG    ?CAN?can_stop?PCANAPIF

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?PCANAPIF   SEGMENT CODE
			 RSEG    ?CAN?can_start?PCANAPIF

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: