Tentative de conception d'un noyau sur RTOS 8051 LC

O

opentdoors

Guest
Bonjour Everyones!

Je
suis un nouveau membre sur ce forum.Je viens du Vietnam comme un ingénieur en électronique.
J'ai essayé de concevoir un OS temps réel sur les noyaux 89c52 avec 8KB poste RAM.C'est juste la manière d'apprendre en temps réel sous Linux.

Mon évaluation 89c52 un conseil composé de 8K RAM (6264) à 0x8000.Il y en a 16 dans ma tâche de conception, chaque tâche est de 256 octets de mémoire externe.Exemple:

Task-0 avec les membres de poste 0x8000 à 0x80FF
-Équipe 1 ---------------------- 0x8100 à 0x81FF
...
Task-15 ---------------------- 0x8F00 à 0x8FFF

Alors que DPH task_id OR = 80, DPL = 0x00 à 0xFF.

Chaque tâche a un octets.Quand un Timer interrompre eu lieu, contre de la tâche est décrémenté, et si contre des équipes à zéro puis atteindre cette tâche est prêt.
Compteur tableau est placé à l'intérieur de RAM, ponted par R0.Quand une tâche est en cours d'exécution, elle fera appel à un Ondelay son compteur à zéro.

Il existe deux autres tableaux à l'intérieur de RAM, sémaphore (juste sémaphore binaire) et l'événement array array.Quand une tâche est en attente à un sémaphore, 8051 CPU également en mode veille
jusqu'à la survenue d'un timer interrupt.Et quand une équipe est dans une attente un événement, il
est toujours passé à sheduler routine.

Sheduler est basée sur une routine contre éventail de changer l'ID
de la tâche en deux variables: running_id et blocke_id, il appelle à mettre context_switching pile interne du blocage de la tâche à la mémoire externe de cette tâche, et de rétablir contenu de la pile pour la prochaine mission.Nouvelle tâche sera dans la gestion de l'Etat après "la retraite".

Désolé, dans la prochaine fois je vais poster des codes source écrit en assembleur 8051.

Merci
Dernière édition par opentdoors le 16 février 2005 8:24, édité 1 fois au total

 
Toutes les tâches a été défini dans la mémoire du programme comme ceci:

tasktable:

dw task0
dw task1
...
dw task15

Avec 256 octets de RAM externe pour chaque tâche,
j'ai utilisé l'adresse de 0x00 pour mettre contexte.

pile equ 5FH
page equ 80H
XSP equ 0FDH
_createTask: / * acc = tâche id; R0 = tâche prioritaire * /

mov b, a
mov dptr, # tasktable
rl une
un inc
movc a, @ a dptr
push acc
mov a, b
rl une
movc a, @ a dptr
push acc
push PSW
push 0
push 1
..
poussoir 7
push acc
push b
push DPH
push DPL

mov a, # page
orl a, b; task_id OU 0x80
mov DPH, un
clr une
mov DPL, une
create_xsp: / * mettre la pile à RAM * /
pop acc
movx @ dptr, un
inc dptr
mov a, sp
cjne a, # pile, create_xsp
/ * Créer TCB * /

push DPL; mettre poste pile
mov a, # XSP
mov DPL, une
pop acc
movx @ dptr, un
inc dptr
mov a, R0:
la priorité
de la tâche
movx @ dptr, un
inc dptr
mov a, DPH
movx @ dptr, un
retAjouté après 22 minutes:Squelette de tâches peuvent être définis:

task0:
/ * Corps de la tâche * /
mov a, # counter0
lcall _timeDelay
ajmp task0

task1:
/ * Corps de la tâche * /
mov a, # counter1
lcall _timeDelay
ajmp task1

....
task15:
/ * Corps de la tâche * /
mov a, # counter15
lcall _timeDelay
ajmp task15

Le _timeDelay fonction de réinitialisation du compteur de chaque tâche.Compteur de chaque tâche décrémentée par minuterie d'interrompre la routine.Quand venir contre des équipes à zéro, cette tâche sera dans l'état prêt,
s'il y en a deux ou trois ..tâches a été dans l'état prêt, alors la tâche de priorité plus élevé est venu de lancer l'Etat.

Si Timer rapport de recherche internationale a eu lieu tous les 2 ms, alors la tâche de
lutte counter_n = # * 2 ms,
la tâche sera lancé tous les (# counter_n * 2ms).Compteur de chaque tâche est un mot variable.

 
xTimeDelay equ 0FBH

_timeDelay:
/ * a = counter haut byte, R1 = counter faible octet * /
clr EA; désactiver les interruptions
push DPH
push DPL
push 0
push b

mov b, a
mov a, running_id; running_id est une variable globale à l'intérieur de RAM
mov DPH, un

anl a, # 0FH
ajouter un, # taskcounters; taskcounters est l'adresse du tableau contre
mov R0, a; R0 point pour traiter de la lutte de la tâche courante
mov a, # xTimeDelay; l'adresse de la variable externe WORD RAM
mov DPL, une
mov a, R1
movx @ dptr, un
inc dptr
mov a, b
movx @ dptr, un

mov @ R0, un
b pop
pop 0
pop DPL
pop DPH
setb EA
setb IDL; PCON.0 aller au mode ralenti
retAjouté après 24 minutes:C'est sheduler fonction, il contre-vérifier la gamme de détection task'counter qui viennent à zéro pour modifier le contenu de deux variables: running_id et suspend_id.Ensuite, changement de contexte de routine sur la base de ces variables à passer.

_sheduler:

clr EA
push PSW
push 0
...
poussoir 7
push acc
push b
push DPH
push DPL

mov R2, # 0FFh; première tâche prioritaire
mov R0, # taskcounters
mov DPH, # page; DPH = 0x80
mov R1, # 0FH
mov suspend_id, running_id

_loop:

mov a, @ R0
jnz _next
mov a, # priorité
mov DPL, une
movx a, @ dptr; obtenir
la priorité
de la tâche
mov b, a
Subb a, R2, si a> R2
JNC _next;
mov R2, b; els si a <R2 puis R2 = a
mov a, # task_id
mov DPL, une
movx a, @ dptr; obtenir tâche id (id = task_id OU 0x80)
mov resume_id, un
_next:
inc R0
inc DPH
djnz R1, _loop

mov running_id, resume_id

/ ** /Ajouté après 2 heures:Ce changement de contexte de routine.Cette routine copie pile interne par ponted sp registre de tâche en cours (identifié par DPH) à l'extérieur de RAM, puis enregistrez le contenu de registre à l'emplacement DPL XSP de 256 octets de RAM externe.

_contextSwitching:

mov a, suspend_id
mov DPH, un
clr une
mov DPL, une
save_context:
pop acc
movx @ dptr, un
inc dptr
mov a, sp
cjne a, # pile, save_context
push DPL
mov a, # XSP
mov DPL, une
pop acc
movx @ dptr, un

mov a, resume_id
mov DPH, un
movx a, @ dptr; DPL = [XSP]
mov DPL, une
restore_context:
décembre dptr
movx a, @ dptr
push acc
mov a, DPL
jnz restore_context
pop DPL
pop DPH
b pop
pop acc
pop 7
...
pop 0
pop PSW
retiAjouté après 22 minutes:Cette _timer routine appelée par TimerISR.Quand il a demandé, cette routine décrémenter les compteurs de la tâche par un.

_timer:
push <0,1, dptr,
le CAC a, b>
mov R0, # taskcounters
mov R1, # 0FH; l'indice de boucle
_tloop:
mov a, @ R0
jz _tcheck
décembre @ R0
k1:
inc R0
djnz R1, _tloop
ret
_tcheck:
mov a, R0
Subb a, # taskcounters; obtenir id
orl a, # page; task_id id = 0x80 OU
mov DPH, un
mov a, # xtimeDelay
mov DPL, une
movx a, @ dptr; obtenir haute byte
jz k1
décembre une
movx @ dptr, un
inc dptr
movx a, @ dptr; obtenir faible byte
mov @ R0, un
sjmp k1

 
Est-ce
qu'il ya
quelqu'un peut me donner quelques conseille sur mon dessin?

Je pense que
le meilleur développement sur un RTOS RICS LC-like comme PIC ou AVR.J'ai vu certains de RTOS LC 8 bits comme Salvo, UCOS-ii, TinyRTX Keil ....Ajouté après 39 minutes:Voici sémaphore routines de traitement.Je créer un sémaphore binaire tableau nommé "mutex_buf" dans la RAM interne fait par R0 (ou R1).

mutex_buf est boolean: nul ou non nul.Chaque élément de mutex_buf assigné une ressource comme le port,
de la mémoire ..
ex:

PORT_sem equ 1H
mov a, # PORT_sem; ici sémaphore est PORT_sem id, id = 0 ÷ 15_semCreate:
/ * acc = id
du sémaphore, sémaphore R1 = valeur initiale (zéro) * /

push 0
mov R0, # mutex_buf
ajouter un, R0
mov R0, a; R0 point de [mutex_buf i]
; mov a, R1; mai être "clr un"
mov @ R0, A; * (mutex_buf) = R1
pop 0

ret

Quand une tâche d'accès d'une ressource partagée, il
avait attribué à attendre de cette ressource semphore de prendre un droit d'accès.
void semWait (UCHAR semaphore_id)
(
while (semaphore_id);
semaphore_id = 1;
)

En asm:
_semWait:
/ * a = id semaphore * /
clr EA
push 0
mov R0, # mutex_buf
ajouter un, R0
mov a, @ R0
jnz _semWaiting
mov @ R0, # 1
pop 0
setb EA
ret

_semWaiting:
pop 0
setb EA
setb IDL; goto mode ralenti
sjmp _semWait

_semSignal:
/ * a = id semaphore * /
clr EA
push 0
mov R0, # mutex_buf
ajouter un, R0
mov R0, un
mov @ R0, # 0H
pop 0
setb EA
ret

Ainsi, une tâche peut être écrit comme ceci, avec sémaphore créé par _semCreate routine ci-dessus:

_Task:
.......
mov a, PORT_sem
lcall _semWait
PORT traitement ....
lcall _semSignal
.....
mov a, # counter
lcall _timeDelay
ajmp _Task

 
Salut à tous,

Je suis G kannan, ici, je suis pour la conception d'un planificateur de 8051 (priorité en fonction de préemption).

j'ai besoin d'un help.i veux le flux de conception de l'ordonnanceur et comment le changement de contexte a eu lieu.Hâte d'entendre parler de u.

pls mail me kannan_emb (at) yahoo.com

Merci et salutations
kannan

 
Je
suis désolé.Dans les précédentes fois,
j'ai dit que sheduler appelée quand une tâche en attente un événement État.

Mais l'algorithme de mon RTOS est ronde.Alors que les CPU sont à l'état de repos lors d'une tâche en attente
jusqu'à ce que le chronomètre un cas d'interruption
s'est produite.

Drapeau de l'événement qui est un octet de sa valeur actuelle 255 différence événements.La tâche qui attend un événement d'État, on pourrait écrire:

_Task:
mov a, # _eventType
lcall _eventWait
/ * Traitement * /
ajmp _Task

_eventWait PSEU-faire dans le code:
void _eventWait ()
(
taskcounters [running_id] = 255;
SI (event == _eventType) THEN
Si = 0;
ELSE goto IDLE_MODE;
)

Le contenu de l'évènement variable a été fixée par une autre tâche.

 
pourquoi ne pas afficher l'organigramme au lieu de l'asm code?

 
thinkey a écrit:

pourquoi ne pas afficher l'organigramme au lieu de l'asm code?
 
Je pense que peu de corps seront attirés dans le code assembleur

 
J'aime asm, c, c .
et
je suis en train d'écrire un RTOS de 52,
un grand merci pour votre message.

 
Asm code mai être difficile à comprendre que le code C.Mais, par un noyau d'écriture de code assembleur,
du noyau pourrait retrouver la valeur du programme à la mission de contrôle.

Rédaction d'une demande en C,
en utilisant l'appel système du noyau dépend de compilateur.

 
vous pourriez avoir affiché tout le code dans un fichier unique.
whats la nécessité pour l'affichage dans de nombreux post?
jarret

 
Je veux faire un OS temps réel par le langage C.Sa précision est que le programme est écrit en langage assembleur?

 
elchula a écrit:

Je veux faire un OS temps réel par le langage C.
Sa précision est que le programme est écrit en langage assembleur?
 
Ce serait mieux pour comprendre, pour une personne comme moi qui
n'est pas si bon à l'Assemblée, seuls les C, il est d'autant ......

Bonne chance

 
Je
suis Tring la conception d'un RTOS
j'ai un problème avec l'interprétation du code assembleur dans le code de la tâche est décrite fissed dans un nombre précis?o peuvent être modifiées en second lieu les exigences?

 
Jack / / ani a écrit:

Ce serait mieux pour comprendre, pour une personne comme moi qui n'est pas si bon à l'Assemblée, seuls les C, il est d'autant ......Bonne chance
 
You must log in or register to reply here.

Welcome to EDABoard.com

Sponsor

Back
Top