hcanap_2.inc

example of using Infineon 81c91 processor.

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

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 := BIT_LENGTH_1_REG;
;*    R4 := BIT_LENGTH_2_REG;
;*    R5 := OUTPUT_CONTROL_REG;
;*    R6 := SLEEP_AND_BR_PRESCALE;
;*    R7 := CLOCK_CONTROL_REG;
;*    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 : BIT_LENGTH_1_REG        Bit-Timing Register 0 des CAN-Controllers
;*     2. Byte : BIT_LENGTH_1_REG        Bit-Timing Register 1 des CAN-Controllers
;*     3. Byte : OUTPUT_CONTROL_REG      Konfiguration der Ausgangstreiber des CAN-
;*                                       Controllers
;*     4. Byte : SLEEP_AND_BR_PRESCAL 
;*     5. Byte : CLOCK_CONTROL_REG             
;*
;*
;*  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?HCANAPIF        SEGMENT XDATA
                                RSEG ?XD?_can_hw_init?HCANAPIF
?_can_hw_init?BYTE:
bit_length_1:           DS 1
bit_length_2:           DS 1
output_control:         DS 1
sleep_and_br_presc:     DS 1
clock_control:          DS 1


?CAN?_can_hw_init?HCANAPIF     SEGMENT CODE
                              RSEG    ?CAN?_can_hw_init?HCANAPIF

_can_hw_init:
                        ; Parameter in die Register holen
                        ; die ersten 3 Parameter sind bereits in den Regs.
                        MOV     A, R5
                        MOV     R4, A               ; speichere bit_length_1

                        MOV     A, R3
                        MOV     R5, A               ; speichere output-control

                        MOV     A, R7
                        MOV     R3, A               ; speichere bit_length_2

                        MOV     DPTR, #sleep_and_br_presc
                        MOVX    A, @DPTR
                        MOV     R6, A

                        INC     DPTR				; speichere clock_control
                        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?HCANAPIF     SEGMENT CODE
                              RSEG    ?CAN?_can_def_obj?HCANAPIF
_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?HCANAPIF   SEGMENT CODE
                              RSEG    ?CAN?can_get_status?HCANAPIF

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