Les Maitres Artisans Index du Forum
 
 
 
Les Maitres Artisans Index du ForumFAQRechercherS’enregistrerConnexion

A la recherche d'un traducteur talentueux...

 
Poster un nouveau sujet   Répondre au sujet    Les Maitres Artisans Index du Forum -> Auberge -> Général
Sujet précédent :: Sujet suivant  
Auteur Message
Rakdos
Membres actifs

Hors ligne

Inscrit le: 05 Juin 2012
Messages: 1 224
Localisation: Avignon
Masculin Vierge (24aoû-22sep)

MessagePosté le: Lun 2 Juil - 12:36 (2012)    Sujet du message: A la recherche d'un traducteur talentueux... Répondre en citant

Bonjour,

Je recherche une personne connaissant bien l'assembleur afin de me traduire - dans les grandes lignes - un code source en C s'vous plait. Ce code source me sera utile afin de modifier le noyau (Kernel) d'un OS temps réel (RTOS)...

Voici:
;   #include "device.inc"
#include <p18cxxx.inc>

;/*  Should be equal to .tmpdata + MATH_DATA size (from map file)      */
#define TEMP_SIZE   0x1E    ;/* ==> Changed */

;/**********************************************************************
; * Kernel RAM area.
; **********************************************************************/
KERNEL_RAM      UDATA
id_tsk_run      RES 1                   ; ID of the running task
id_tsk_pre      RES 1                   ; ==> Monitor for two last tasks
temp            RES 1
temp2           RES 1
permut          RES 1                   ; flag on continue permut or not
kernelState     RES 1
kernelPanic     RES 1                   ; Left nibble holds the taskID in
                                        ; which stack overflow occurred
                                        ; Right nibble: neighbor task got
                                        ; impacted by the stack overflow
startAddressL   RES 1                   ; Holds the task's code address
startAddressH   RES 1
startAddressU   RES 1


;/**********************************************************************
; * Share global variables with other sections.
; **********************************************************************/
    GLOBAL  id_tsk_run 
    GLOBAL  id_tsk_pre                  ;/* ==> Added */
    GLOBAL  kernelState
    GLOBAL  kernelPanic

;/**********************************************************************
; * Shared variables defined in other section.
; **********************************************************************/
    extern  tsk_1_state_ID              ; @ pro_man.c
    extern  tsk_16_state_ID

    extern  tsk_1_activ_prio            ; @ pro_man.c
    extern  tsk_16_activ_prio

    extern  FSR1H_MAIN                  ; @ pro_man.c
    extern  FSR1L_MAIN

    extern  taskdesc_addr               ; @ taskdesc.c (User Defined)

    extern  stack_low                   ; @ pro_man.c
    extern  stack_high

;/**********************************************************************
; * Hook routines activated by the -D compiler option.
; **********************************************************************/
#IFDEF STARTUPHOOK
    extern StartupHook
#ENDIF

#IFDEF PRETASKHOOK
    extern PreTaskHook
#ENDIF

#IFDEF POSTTASKHOOK
    extern PostTaskHook
#ENDIF

;/**********************************************************************
; * Macros used by KERNEL.
; **********************************************************************/
setupTBLPTR  macro   pointer2rom
    movff   pointer2rom+2, TBLPTRU      ; Load TBLPTR with the address of
    movff   pointer2rom+1, TBLPTRH      ; taskdesc table located in ROM
    movff   pointer2rom, TBLPTRL        ;
    endm

locateTaskIdField   macro
    movlw   7
    addwf   TBLPTRL, f                  ; Adjust TBLPTR to point to the
    clrf    WREG                        ; Task ID field of the current
    addwfc  TBLPTRH, f                  ; entry of the taskdesc table
    addwfc  TBLPTRU, f
    endm

locateStackAddrField   macro
    movlw   7                           ; After extracting the task ID,
    subwf   TBLPTRL, f                  ; Rewind the pointer back, to 
    clrf    WREG                        ; point to stack address field
    subwfb  TBLPTRH, f                  ; of the current taskdesc entry
    subwfb  TBLPTRU, f
    endm

swapTaskCtrlEntry  macro
    movff   POSTDEC0, temp2             ; SWAP 2 successive task entries
    movf    INDF0, w                    ; same macro can be used for
    movff   temp2, POSTINC0             ; various TCT(task control table)
    movwf   INDF0
    endm

setupFSR0    macro   taskCtrlTable
    clrf    FSR0H                       ; Setup FSR0 to point to the
    movlw   taskCtrlTable               ; 1st entry of one of the four
    movwf   FSR0L                       ; TCTs (task control tables)
    endm
   
loadNextStackAddrTo  macro   StackL, StackH
    TBLRD   *+                          ; Load Regsiter with the next 2
    movf    TABLAT, w                   ; bytes of the task descriptor,
    movwf   StackL                      ; taskdesc entry pointed to by
    TBLRD   *+                          ; TBLPTR
    movf    TABLAT, w
    movwf   StackH
    endm

loadNextCodeAddrTo  macro   CodeL, CodeH, CodeU
    TBLRD   *+                          ; Load Regsiter with the next 2
    movf    TABLAT, w                   ; bytes of the task descriptor,
    movwf   CodeL                       ; taskdesc entry pointed to by
    TBLRD   *+                          ; TBLPTR
    movf    TABLAT, w
    movwf   CodeH
    TBLRD   *+                          ; TBLPTR
    movf    TABLAT, w
    movwf   CodeU
    endm

addStackSizeTo  macro   RegisterL, RegisterH
    TBLRD   *+                          ; By adding the stack size
    movf    TABLAT, w                   ; specified in the taskdesc,
    addwf   RegisterL, f                ; the designated Register will
    TBLRD   *+                          ; ==> Changed
    movf    TABLAT, w                   ; ==> Changed point to the end of stack
    addwfc  RegisterH, f                ; ==> Changed
    movlw   4
    subwf   RegisterL, f
    clrf    WREG
    subwfb  RegisterH, f
    endm

setupStackSentinel    macro
    movlw   0xde                        ; Setup sentinel 0xadde, 2 bytes
    movwf   POSTINC1                    ; ahead of where FSR1 points to.
    movlw   0xad                        ; This is the sentinel to mark
    movwf   POSTINC1                    ; both start and end of stack,
    endm                                ; destroy of signature suggests
                                        ; stack overflow occurred, i.e.
                                        ; kernel panic
locateTaskDescEntry   macro
    local   _matchTaskID, _nextTaskEntry, _found
    setupTBLPTR   taskdesc_addr         ; Locate the Task ID field of
    locateTaskIdField                   ; the 1st Task Descriptor entry
    movlb   0
_matchTaskID 
    movf    id_tsk_run, w               ; Get current running Task ID
    TBLRD   *+                          ; Get the Task ID from taskdesc
    cpfseq  TABLAT                      ; entry, see if it's current Task
    bra     _nextTaskEntry              ; If not, proceed with next Task
    bra     _found                      ; else exit from the macro
_nextTaskEntry
    movlw   9                           ; Move on to next Task entry by
    addwf   TBLPTRL, f                  ; offsetting TBLPTR with +9
    clrf    WREG
    addwfc  TBLPTRH, f
    addwfc  TBLPTRU, f
    bra     _matchTaskID                ; Go back to match task ID
_found 
    endm

ifSentinelDestroyGoto   macro place
    movff   POSTINC0, FSR1L             ; Check stack Sentinel, 0xadde
    movlw   0xde                        ; If the signature was not 
    cpfseq  FSR1L                       ; there any more then
    goto    place                       ; go to the 'place' designated
    movlw   0xad
    movff   POSTINC0, FSR1L
    cpfseq  FSR1L
    goto    place
    endm

markRunningTaskSuspended macro
    local   _nextTableEntry
    setupFSR0    tsk_1_state_ID-1
_nextTableEntry
    incf    FSR0L                       ; Proceed all the way down to
    movlw   0x0F                        ; (taskID) changed from 0x1F
    andwf   INDF0, w                    ; tsk_xx_state_ID task control
    cpfseq  id_tsk_run                  ; table
    bra     _nextTableEntry
    bcf     INDF0, 5                    ; Mark the task as SUSPENDED
    bcf     INDF0, 6
    bcf     INDF0, 7
    endm   

;/**********************************************************************
; * ------------------------- KERNEL INIT ------------------------------
; *
; * Here is the init phase of the kernel, it means the main access to
; * the kernel after StartOS call.
; *
; **********************************************************************/
KERNEL_ROM  CODE
_kernel
    GLOBAL  _kernel                     ; Beginning of kernel code
 
    clrf    FSR0H
    clrf    FSR0L
    clrf    FSR1L
    clrf    FSR1H
    clrf    TBLPTRU
    clrf    PCLATH

    movlw   0xFF                        ; Clear the first RAM bank
_kInitBank0
    clrf    POSTINC0
    cpfseq  FSR0L
    bra     _kInitBank0
    clrf    POSTINC0                    ; Clear last byte of the bank
   
    clrf    FSR0H                       ; Point FSR0 back to 0x0000
   
    clrf    STKPTR                      ; Clear the hardware stack
    movlw   0x1F                        ; Total 31 of H/W stack entries
_kInitHardwareStack
    incf    STKPTR
    clrf    TOSU
    clrf    TOSH
    clrf    TOSL
    cpfseq  STKPTR
    bra     _kInitHardwareStack
   
    clrf    STKPTR                      ; Is this redunant? later on
    incf    STKPTR                      ; inside _parser STKPTR will
                                        ; be set to 1 anyway
    movlw   0x88                        ; No prescaler for Timer 0
    movwf   T0CON

    ;clrf    PIE1
    ;clrf    PIE2
    ;clrf    RCON                       ; Removed from BETA3
    ;clrf    IPR1
    ;clrf    IPR2
    movlw   0x80
    movwf   INTCON2                    
    bsf     RCON, 7                     ; IPEN enabled

    movlw   0xA0                        ; GIEH enable
    movwf   INTCON                      ; GIEL disabled (TMR0 enabled)
    bsf     INTCON, 2                   ; Set TM0IF, force update on TMR0

    bsf     INTCON,7                    ; GIEH enabled, GIEL disabled
    bcf     INTCON,6                    ;
    ;bcf     IPR1, 1                     ; Set Timer2 interrupt priority to low      *
    ;bsf     PIE1, 1                     ; Enable Timer2 interrupt      
    bsf     INTCON, 5                   ; TMR0 enabled        *
    bsf     INTCON, 2                   ; Set TM0IF, force update on TMR0

_parser
    movlb   0                           ; Init
    movlw   0x01
    movwf   STKPTR             
    clrf    temp               
    movwf   permut                      ; Setup initial permutaion flag             
    clrf    id_tsk_run                  ; No task running to begin with
    setupFSR0    tsk_1_activ_prio       ; Locate tsk_xx_activ_prio table
    setupTBLPTR  taskdesc_addr          ; Locate 1st Task Desc. entry

;/* ------------ TASKDESC.C CONTENT PARSING -------------------------- */
_parserInit
    TBLRD   *+
    movf    TABLAT, w
    btfsc   STATUS, Z                   ; Task Desc. ends with an entry
    bra     _parserUpdate               ; of all-Zero fileds
    movff   TABLAT, INDF0               ; Extract & Setup task priority

    loadNextStackAddrTo FSR1L, FSR1H    ; Extract & setup stack pointer

    setupStackSentinel                  ; Put a signature 0xadde in
                                        ; front of the stack
   
    TBLRD   *+                          ; Skip over the TASK addr field
    TBLRD   *+                          ; 3 bytes : 24 bit address
    TBLRD   *+

    bcf     FSR0L, 4                    ; Switch to tsk_xx_state_ID table
                                        ; by clearing bit 4, 0x0B0->0x0A0
    TBLRD   *+                          ; Extract & Setup task's state
    movf    TABLAT, w
    addwf   INDF0, f

    TBLRD   *+                          ; Extract & Setup task ID
    movf    TABLAT, w
    addwf   INDF0, f

    TBLRD   *+                          ; ==> By adding the stack size
    movff   TABLAT, startAddressL       ; ==> specified in the taskdesc,
    TBLRD   *-                          ; ==>
    movff   TABLAT, startAddressH       ; ==> point to the end of stack

    addStackSizeTo  FSR1L, FSR1H

    setupStackSentinel                  ; Put a signature, 0xadde at
                                        ; the end of the stack
    ; ==> ************ This code added for fill stack pattern 0xa5
    movf    POSTDEC1, w                 ;
    movf    POSTDEC1, w                 ;
    movf    POSTDEC1, w                 ;
    movlw   7                           ; After extracting the task ID,
    subwf   startAddressL, f            ; Rewind the pointer back, to 
    clrf    WREG                        ; point to stack address field
    subwfb  startAddressH, f            ; of the current taskdesc entry

    movlw   0xa5
_parser_mark_stack
    movwf   POSTDEC1
    decfsz  startAddressL, f
    bra     _parser_mark_stack
    movf    startAddressH, f
    bz      _parser_mark_stack_end
    decf    startAddressH, f
    bra     _parser_mark_stack
_parser_mark_stack_end
    ; ==> ***************

    incf    FSR0L                       ; Step to next task entry
    bsf     FSR0L, 4                    ; Point back to tsk_xx_activ_prio
    bra     _parserInit                 ; Loop back for next task
                                        ; in task descriptor
_parser_organize
    GLOBAL  _parser_organize            ; If so requested externally
    movlb   0                           ; Prioritize the TCTs
    clrf    permut
    incf    permut     

;/* - REARRANGE TASK ORDER IN EACH TCT, BASED ON DESCENDING PRIORITY - */
_parserUpdate
    setupFSR0    tsk_1_activ_prio
    movf    permut, w                   ; Is there a bubble in the last
    btfsc   STATUS, Z                   ; iteration?
    bra     _isHook                     ; If No, means TCTs prioritized
    clrf    permut                      ; If Yes, sort still in progress
                                        ; Clear permutation flag for this
                                        ; iteration (Bubble sort is used)
_parserUpdateLoop
    movlw   0x0F
    andwf   INDF0, w
    movwf   temp                        ; Extract task's priority
    btfsc   STATUS, Z                   ; 0 signifies the end of TCT
    bra     _parserUpdate               ; If end of task atble, loop back
                                        ; for next bubble sort iteration
    movff   INDF0, temp2                ; Else backup (activ + prio) byte
    movlw   0x0F
    andwf   PREINC0, w                  ; Extract next task's priority

    cpfseq  temp
    bra     _parserUpdateDiff
    bra     _parserUpdateLoop           ; Equal priority, Loopback for
                                        ; the next control table entry
_parserUpdateDiff
    cpfsgt  temp
    bra     _parserUpdateSwap           ; Go swap on low priority
    bra     _parserUpdateLoop           ; Loopback if priority in place

_parserUpdateSwap
    movf    POSTDEC0, w                 ; Swap entry in tsk_xx_activ_prio
    movwf   POSTINC0                    ; located at 0x0B0
    movff   temp2, INDF0

    bcf     FSR0L, 4                    ; Swap entry in tsk_xx_state_ID
    swapTaskCtrlEntry                   ; located at 0x0A0

    bcf     FSR0L, 5                    ; Swap the task entry in event_xx
    swapTaskCtrlEntry                   ; located at 0x080

    bsf     FSR0L, 4                    ; Swap the task entry in wait_xx
    swapTaskCtrlEntry                   ; located at 0x090

    bsf     FSR0L, 5                    ; Point back to tsk_xx_activ_prio
    incf    permut                      ; Raise the permutation flag to
                                        ; signify a swap has occurred
    bra     _parserUpdateLoop

_isHook                                 ; Hook kernel service routine
    #IFDEF  STARTUPHOOK
        call    StartupHook
    #ENDIF

;/**********************************************************************
; * --------------------- KERNEL TASK SCHEDULER ------------------------
; *
; * The scheduler manage the task switching during application running.
; *
; **********************************************************************/
_sched
    GLOBAL  _sched
    #IFDEF  POSTTASKHOOK
        call    PostTaskHook
    #ENDIF

    movlb   0
    bcf     kernelState, 0              ; Switch to KERNEL mode
    swapf   id_tsk_pre, f               ; ==> Tasks History
    movlw   0xf0                        ; ==> Consist two last active
    andwf   id_tsk_pre, f               ; ==> tasks, include idle (=0)
    movf    id_tsk_run, w               ; ==>
    addwf   id_tsk_pre, f               ; ==>
    movf    id_tsk_run, w
    btfsc   STATUS, Z                   ; Is running task 0 or not?
    bra     _schedPickNext2Run          ; Branch if 0, no task RUNNING,
                                        ; Legal taskID: 1~15, 0 -> none
    setupFSR0    tsk_1_state_ID-1       ; Locate tsk_1_state_ID table

_schedFindRunningTaskEntry
    incf    FSR0L
    movlw   0x0F                        ; ==> Changed from 0x1F
    andwf   INDF0, w
    cpfseq  id_tsk_run                  ; Locate RUNNING task's entry
    bra     _schedFindRunningTaskEntry  ; Proceed to next task entry
    bcf     INDF0, 6                    ; Mark the task: no more RUNNING
    clrf    id_tsk_run                  ; Set running task ID to "none"

    bsf     FSR0L, 4                    ; Point to tsk_xx_activ_prio TCT
    movlw   0x0F                        ; Original code uses 0x0E, why?
    andwf   INDF0, w
    movwf   temp                        ; Extract & save task priority
                                        ; for later matching use
_testIfSamePriority
    movlw   0x0F                        ; Original code uses 0x0E, why?
    andwf   PREINC0, w
    cpfseq  temp                        ; Is it with the same priority?
    bra     _schedPickNext2Run          ; Branch to schedule if not
    bra     _RoundRobin4SamePriority    ; Else Proceed with Round Robin
                                        ; setup for the task
_RoundRobin4SamePriority
    swapTaskCtrlEntry                   ; Tasks having the same priority,
                                        ; Round Robin method used, and
                                        ; current task will be swapped
                                        ; all the way to the bottom of
                                        ; the tasks with same priority
    bcf     FSR0L, 4                    ; Swap tsk_xx_state_ID task entry
    swapTaskCtrlEntry
    bcf     FSR0L, 5                    ; Swap event_xx task entry
    swapTaskCtrlEntry
    bsf     FSR0L, 4                    ; Swap wait_xx task entry
    swapTaskCtrlEntry
    bsf     FSR0L, 5                    ; Point back to tsk_xx_activ_prio
    bra     _testIfSamePriority
   
_schedPickNext2Run
    setupFSR0    tsk_1_state_ID-1       ; Top down and hence prioritized,
                                        ; fetching next candiadte to run   
_schedTaskReadyOrNot
    incf    FSR0L
    btfss   INDF0, 5                    ; READY ?
    bra     _schedTestEndOfCtrlTable    ; Proceed to next if not READY
    btfsc   INDF0, 7                    ; WAITING?
    bra     _schedTestEndOfCtrlTable    ; It's READY, however WAITING
                                        ; for certain event
    movlb   0                           ; If READY and not WAITING then
    bsf     INDF0, 6                    ; Mark the task in RUNNING state
    movlw   0x0F                        ; ==> Changed from 0x1F
    andwf   INDF0, w
    movwf   id_tsk_run                  ; Designate the task in RUNNING

    #IFDEF  PRETASKHOOK                 ; Hook kernel service routine
        call    PreTaskHook
    #ENDIF
   
;/**********************************************************************
; * ------------------------- RESTORE CONTEXT --------------------------
; *
; * Copy the content of the context (task ram area) into Special File
; * Registers.
; *
; **********************************************************************/
_restore_ctx
    GLOBAL  _restore_ctx
   
    movlb   0
    bsf     kernelState, 0              ; Change the kernel to USER mode
    locateTaskDescEntry
    locateStackAddrField  
    loadNextStackAddrTo FSR0L, FSR0H    ; Extract task's stack addr
    loadNextCodeAddrTo startAddressL, startAddressH, startAddressU
                                        ; Extract task's code addr
; Go chech whether the stack overflow occurred
    goto    _checkPanic

; If the stack remains intact, restore the task's context
_restore_now
    GLOBAL  _restore_now
    movlb   0
    movff   POSTDEC1, temp
    movff   POSTDEC1, temp              ; Extract # of H/W stack entries
    clrf    STKPTR                      ; backed up previously
   
restoreNextHardwareStack
    push                                ; push to make room for restoring
    movf    POSTDEC1, w                 ; hardware stack entries
    movwf   TOSU
    movf    POSTDEC1, w
    movwf   TOSH
    movf    POSTDEC1, w
    movwf   TOSL                        ; Restore one H/W stack entry
    movf    STKPTR, w
    cpfseq  temp                        ; Is H/W stack restore done?
    bra     restoreNextHardwareStack    ; Loopback to next restore If not

    setupFSR0    TEMP_SIZE-1            ; Load FSR0, to point to the end
                                        ; of .tmpdata + MATH_DATA section
restoreNextTmpdataByte
    movff   POSTDEC1, POSTDEC0          ; Restore .tmpdata + MATH_DATA
    movf    FSR0L, w                    ; section
    btfss   STATUS, N
    bra     restoreNextTmpdataByte

    movff   POSTDEC1, PCLATH            ; ==> Added
    movff   POSTDEC1, PCLATU            ; ==> Added
    movff   POSTDEC1, PRODL             ; Restore the rest of SFRs saved
    movff   POSTDEC1, PRODH             ; in previously task swapping out
    movff   POSTDEC1, TABLAT
    movff   POSTDEC1, TBLPTRL
    movff   POSTDEC1, TBLPTRH
    movff   POSTDEC1, TBLPTRU
    movff   POSTDEC1, FSR0H
    movff   POSTDEC1, FSR0L
    movff   POSTDEC1, FSR2H
    movff   POSTDEC1, FSR2L
    movff   POSTDEC1, BSR
    movff   POSTDEC1, WREG
    movff   POSTDEC1, STATUS

;    bsf     INTCON, 6                   ; ==> Removed Enable OS/low prior. interrupt
    retfie                              ; Exit to where TOS pointed at
   
_schedTestEndOfCtrlTable
    movlw   tsk_16_state_ID             ; Check for task ctrl table end
    subwf   FSR0L, w
    bnz     _schedTaskReadyOrNot

    ; ==> *********************** Changed and Added for Idle
    movff   FSR1H_MAIN, stack_high           ; No more READY to run, swing
    movff   FSR1L_MAIN, stack_low           ; stack pointer back to point
    movlb   high(stack_low)
    movlw   0x02
    addwf   stack_low, f
    clrf    WREG
    addwfc  stack_high, f
    movlw   0x02
    addwf   stack_low, w
    movwf   FSR1L
    movwf   FSR2L
    clrf    WREG
    addwfc  stack_high, w
    movwf   FSR1H
    movwf   FSR2H
                                        ; to main AP stack
    ; ==> ***********************
_whileIdle
    movlb   0                           ; No task running
    bsf     INTCON, 6                   ; Enable OS/low prior. interrupt
    clrf    STKPTR                      ; waiting for any event to occur
    bra     _whileIdle


immediat_ret
    movff   FSR0L, FSR1L                ; Here FSR0 seems to have task's
    movff   FSR0L, FSR2L                ; stack address + 2
    movff   FSR0H, FSR1H
    movff   FSR0H, FSR2H

    clrf    STKPTR                      ; Faking TOS with a pointer to
    incf    STKPTR                      ; task's start Address as if
    movf    startAddressL, w            ; there was a CALL right before
    movwf   TOSL                        ; task's start Address
    movf    startAddressH, w
    movwf   TOSH
    movf    startAddressU, w
    movwf   TOSU
;    bsf     INTCON, 6                   ; ==> Removed Enable OS/low prior. interrupt
    retfie                              ; Branch to Task's code

;/**********************************************************************
; * --------------------- CHECK STACK OVERFLOW -------------------------
; *
; **********************************************************************/
_checkPanic

; Check 0xadde signature/sentinel before the start of the task's stack
    ifSentinelDestroyGoto   _kernelPanicTrashedByNeighbor

    movff   FSR0L, stack_low            ; Save a copy of stack pointer
    movff   FSR0H, stack_high           ; for later recovery

;    locateTaskDescEntry        ; ==> Removed
    TBLRD   *+                          ; ==> Move TBLPTR to
    TBLRD   *+                          ; ==> the stack size
    addStackSizeTo  FSR0L, FSR0H

; Check 0xadde signature/sentinel before the end of the task's stack
    ifSentinelDestroyGoto   _kernelPanicStackOverflow

_restore_stack                          ; ==> Added
    GLOBAL  _restore_stack              ; ==> Added
    movff   stack_low, FSR0L            ; Restore FSR0 to task's
    movff   stack_high, FSR0H           ; stack address
    movff   POSTINC0, FSR1L             ; Popup from stack top,
    movff   POSTINC0, FSR1H             ; and setup FSR1 to point to
                                        ; where context were saved
                                        ; ==> Any commands removed
    movf    FSR1L, w                    ; Non-null means there is a
    iorwf   FSR1H, w                    ; previous saved context to
    btfsc   STATUS, Z                   ; be restored
    bra     immediat_ret                ; Return immediately if FSR1==0
    bra     _restore_now                ; else restore the context

_kernelPanicTrashedByNeighbor
    markRunningTaskSuspended            ; Chances are stack overflow of
    movff   kernelPanic, WREG           ; another task is jeopardizing
    andlw   0xF0                        ; current task
    addwf   id_tsk_run, w
    movff   WREG, kernelPanic           ; Log the task in right nibble
    bra     _sched                      ; of the kernelpanic

_kernelPanicStackOverflow
    markRunningTaskSuspended            ; Stack overflow found
    #IFDEF  RESET_ON_PANIC              ; Reset in case of KERNEL PANIC
        reset                           ; if so requested
    #ENDIF
    movff   kernelPanic, WREG
    swapf   WREG, w
    andlw   0xF0
    addwf   id_tsk_run, w
    swapf   WREG, w
    movff   WREG, kernelPanic           ; Log the task ID in left nibble
    bra     _sched                      ; of the kernelpanic

;/**********************************************************************
; * ----------------------- FOR BASIC TASK ONLY ------------------------
; *
; * After terminating a task, we loose the start address of the task,
; * first located in the first place of the stack.
; *
; **********************************************************************/
_restore_start_adr
    GLOBAL  _restore_start_adr
    locateTaskDescEntry
    locateStackAddrField  
    loadNextStackAddrTo FSR0L, FSR0H

    movlw   0x02                        ; ==> Shift pointer to
    addwf   FSR0L, f                    ; ==> the start address
    clrf    WREG                        ; ==> of task
    addwfc  FSR0H, f                    ;
    movwf   POSTINC0
    movwf   INDF0                       ; Set the value into STKPTR
    goto    _sched                      ; Determine the next RUNNING task

    END                                 ; Directive 'end of program'

;/* End of File : kernel.asm */


http://www.sendspace.com/file/vko5uk

Merci d'avance !

Cordialement, Rakdos.
-------------------
Requiem aeternam dona eis, Domine, et lux perpetua luceat eis. In memoria aeterna erit justus: ab auditione mala non timebit.
Revenir en haut
Visiter le site web du posteur
Publicité






MessagePosté le: Lun 2 Juil - 12:36 (2012)    Sujet du message: Publicité

PublicitéSupprimer les publicités ?
Revenir en haut
NeryK
Membres actifs

Hors ligne

Inscrit le: 01 Juil 2011
Messages: 93
Localisation: 78

MessagePosté le: Ven 6 Juil - 00:25 (2012)    Sujet du message: A la recherche d'un traducteur talentueux... Répondre en citant

Tu cherches quelqu'un pour te faire tes devoirs ? T'inquiètes pas il va pas te mordre ton PIC. Ça fait partie de ta formation Laughing En plus ton code est commenté petit veinard.

C'est pas bien compliqué dans le principe, ton noyau il a 2 choses à faire : ordonnancer (scheduler) les taches, c'est à dire leur donner la main sur le processeur, et leur fournir un contexte d'exécution, c'est à dire de la mémoire pour travailler (context switch). Bref le scheduler se réveille, choisit une tache dans sa liste, en fonction des priorités et de l'ordre (qui tourne avec un round robin), sauvegarde le contexte de la tâche courante (pointeur d'execution, de pile), restaure le contexte de la tâche suivante, et lui donne la main. Je vois qu'il y a même un peu de fioriture pour détecter si une tâche dépasse de la pile qui lui était allouée.

Mais bon, tout ça tu le sais si tu as suivi tes cours Mort de Rire
-------------------
Revenir en haut
Yopsolo
Membres actifs

Hors ligne

Inscrit le: 07 Déc 2010
Messages: 1 001
Localisation: Léognan
Masculin Taureau (20avr-20mai) 虎 Tigre

MessagePosté le: Ven 6 Juil - 08:29 (2012)    Sujet du message: A la recherche d'un traducteur talentueux... Répondre en citant

tu es son prof ou quoi? ^^
-------------------
Mais on va me dire C'est où qu'on signe, bordel!!!
Revenir en haut
Yahoo Messenger Skype
NeryK
Membres actifs

Hors ligne

Inscrit le: 01 Juil 2011
Messages: 93
Localisation: 78

MessagePosté le: Ven 6 Juil - 10:06 (2012)    Sujet du message: A la recherche d'un traducteur talentueux... Répondre en citant

Ptet bin qu'oui, ptet bin qu'non Razz

Enfin surtout j'étais à sa place il y a 10 ans. super content ! Le bagage qu'on acquiert sur des systèmes simples comme celui-ci sert longtemps après la sortie d'école. Donc mon message au fond c'est juste qu'il ne faut pas avoir peur de se palucher un peu d'assembleur, surtout pendant les études car c'est formateur.
-------------------
Revenir en haut
Rakdos
Membres actifs

Hors ligne

Inscrit le: 05 Juin 2012
Messages: 1 224
Localisation: Avignon
Masculin Vierge (24aoû-22sep)

MessagePosté le: Ven 6 Juil - 11:59 (2012)    Sujet du message: A la recherche d'un traducteur talentueux... Répondre en citant

Bonjour,

Ouaip, merci pour les infos NeryK ^^. Mais "tout ça" je le savais déjà. C'est un OS que j'ai utilisé pour la coupe robotique de France (session 2011-2012).

C'est pas vraiment un "devoir" mais plus une envie que de le traduire en code C pour que ce soit plus lisible (mais moins performant, bien sur Sad). Puisque cet OS comporte quelques erreurs dans l’ordonnanceur et c'est panique à bord !
Bref, je m'amuserai surement un de ces quatre... Quand il fera trop chaud et que je ne pourrai pas jouer ^^.

Merci en tout cas Smile.

Cordialement, Rakdos.
-------------------
Requiem aeternam dona eis, Domine, et lux perpetua luceat eis. In memoria aeterna erit justus: ab auditione mala non timebit.
Revenir en haut
Visiter le site web du posteur
NeryK
Membres actifs

Hors ligne

Inscrit le: 01 Juil 2011
Messages: 93
Localisation: 78

MessagePosté le: Ven 6 Juil - 15:15 (2012)    Sujet du message: A la recherche d'un traducteur talentueux... Répondre en citant

Petite remarque en passant, je sais qu'on est entre nous et tout ça, mais c'est de mauvais goût d'enlever l'en-tête qui contient la license (http://www.pragmatec.net/Download/PICos18/1.%20PICos/Sources/PICos18_v3_00_B4/Kernel/kernel.asm). Je sais je pinaille, je suis d'humeur pinailleuse.

Bref amuse toi bien Wink

PS : Whoa il fait mal au yeux le site de PICos (http://www.picos18.com/) ça fleure bon les années 90, le style geocities, le web retro quoi.
-------------------
Revenir en haut
Rakdos
Membres actifs

Hors ligne

Inscrit le: 05 Juin 2012
Messages: 1 224
Localisation: Avignon
Masculin Vierge (24aoû-22sep)

MessagePosté le: Ven 6 Juil - 16:08 (2012)    Sujet du message: A la recherche d'un traducteur talentueux... Répondre en citant

Oui le site de PICos18 est vieux, très vieux et pas mis à jour depuis longtemps. Que ce soit le site ET l'OS Smile .

Et j'ai viré la licence pasque sinon c'est une perte de "ligne" dans le spoiler, et entre nous... Licence ou pas, ça ne sert à rien.
-------------------
Requiem aeternam dona eis, Domine, et lux perpetua luceat eis. In memoria aeterna erit justus: ab auditione mala non timebit.
Revenir en haut
Visiter le site web du posteur
Contenu Sponsorisé






MessagePosté le: Aujourd’hui à 19:29 (2017)    Sujet du message: A la recherche d'un traducteur talentueux...

Revenir en haut
Montrer les messages depuis:   
Poster un nouveau sujet   Répondre au sujet    Les Maitres Artisans Index du Forum -> Auberge -> Général Toutes les heures sont au format GMT + 1 Heure
Page 1 sur 1

 
Sauter vers:  

Portail | Index | créer un forum | Forum gratuit d’entraide | Annuaire des forums gratuits | Signaler une violation | Conditions générales d'utilisation