Montages

Voici une série de montages proposés pour découvrir la programmation du microcontroleur SX.

LUMI & Co Tod le robot Revue LED Termix Usibix

LUMI & Co
Il s'agit d'une suite de programmes (sources fournis) qui utilisent un cercle de 12 diodes led.

Le montage avec dessin du circuit et PCB

Les programmes utilisant ce montage :

Lumi Simple chenillard utilisant la rotation des bits, et liste d'instructions manipulant les bits

Lumimemo Chenillard utilisant un tableau en mémoire programme, des temps d'affichage différents et une liste d'instructions manipulant la mémoire.

Lumifolies Allumage d'une ou plusieurs led au choix avec 32 motifs différents et programme en Delphi pour générer vos motifs.

Lumicom Interface RS232 et modification de l'allumage des leds depuis un PC. Liste d'instructions de branchement dans un programme.

LumiMemo Gestion d'une mémoire EEPROM de 16 Koctets performante, La CAT24WC128.

Voici la fin des programmes autour de Lumi. Il nous aura permi de nous intéresser à de nombreuses routines permettant le transfert d'octets, la gestion du port RS232 et le stockage de données dans une mémoire au protocole I2C.

Tod le robot

Un robot marcheur. Il s'agit d'une petite maquette à réaliser qui marche comme un pingouin et qui n'utilise que deux servos de modélisme et un SX18. Sa trajectoire est programmable, succès assuré ! (photos).

Revue LED

Mini-kit
, un montage publié dans la revue LED.

Termix, la platine de développement

Termix. Cette platine offre de multiples fonctions : liaison RS232, afficheur 2 lignes, mémoire 16 K eeprom et port d'entrées/sorties sur 8 bits. Un source est fourni pour tester la platine. 

Calendrier. C'est un programme pour la platine Termix qui donne la date et l'heure et qui enregistre le moment où un évènement apparaît sur son port E/S. La mémoire peut être relue depuis un PC.

Usibix, une liaison USB pour le Sx28

Lumi
6/12/2001

Lumi est un chenillard circulaire. Cela nous permettra d'utiliser plusieurs techniques de programmation pour allumer les leds selon des séquences différentes.

Dimensions 6 cm * 6 cm
12 leds rouges (la patte la plus longue est à l'extérieur du cercle).
12 résistances 1 K. On peux descendre à 470 ohms sans risque.
2 connecteurs 6 contacts ou supports tulipes sécables.

Le PCB est au format Layo1E. Télécharger lumi

Raccorder le port B du SX 28 (1 à 8) sur les broches 1 à 8 de la platine Led et le port C (1 à 4) du SX 28 sur les broches 9 à 12 de la platine Led. Raccorder la masse sur la ligne de masse de la platine SX. Puis placer la SX-Key et programmez le avec le programme suivant. Le programme utilise l'oscillateur interne du SX, il n'y a donc pas besoin d'oscillateur externe.

Programme lumi

; Auteur: Jean Brunet
; jean.brunet17@wanadoo.fr
; Revision: 1.0
; Date: 06/12/2001
; Part: SX28AC
; Freq: 32 Khz

;*************************

device SX28, OSC32KHZ ; chip SX28 et fréquence oscillateur interne.
DEVICE TURBO,CARRYX ; une instruction par coup d'horloges et retenue utilisée
ID 'Lumi' ; Nom du programme

reset reset_entry

;***********************
; variables
;***********************

org 8
wait1 ds 1 ; variable de boucle
sortie ds 1 ; variable pour affichage led

;*********************************
; Début du code. Effaçage de la mémoire
;*********************************
reset_entry

mov m,#$0f
clr rb
;buffer de sortie B à 0
mov !rb,#%00000000
; port B en ecriture
clr rc
; buffer de sortie C à 0
mov !rc,#%00000000 ; port C en ecriture
; Note : Si rb et rc ne sont pas mis à 0 avant l'initialisation des ports en écriture, les diodes sont allumées à la mise en route
clr fsr ; reset all ram starting at 08h

:zero_ram
sb fsr.4 ; are we on low half of bank?
setb fsr.3 ; If so, don't touch regs 0-7
clr ind ; clear using indirect addressing
ijnz fsr,:zero_ram
; repeat until done

; *********************
; boucle du programme
; *********************

debut

mov sortie,#0 ; toutes les leds sont éteintes
stc ; retenue placée.
; Note : on utilise la retenue que l'on charge dans la variable sortie par rotation. Ce bit correspond à l'affichage de la led
:repete
rl sortie ; rotation à gauche, nouvelle led à allumer
mov rb,sortie ; validation sur le port de sortie B. La led s'allume
call tempo ; on temporise
snc ; teste si la retenue n'est pas mise et saute l'instruction suivante. Attention ! Cette instruction placée ici ne se justifie que parce que le sous programme tempo ne modifie pas la retenue.
jmp
:suite ; sinon la retenue = 1 et on va écrire sortie sur le port C
jmp :repete ; pas de retenue, on boucle
:suite
rl sortie ; rotation à gauche, nouvelle led à allumer
mov rc,sortie ; validation sur le port de sortie C. La led s'allume
call tempo ; on temporise
sb sortie.3 ; teste si bit 3 = 1 (led n° 4 ). Dans ce cas on saute le JMP et on éteind la led en mettant le port C à 0
jmp :suite ; non, on boucle
mov rc,#0 ; port de sortie C = 0
jmp debut ; oui retour au début

; *********************
; Timers : boucle de temporisation
; *********************

tempo

mov wait1,#$FF ; on charge la boucle de comptage à $FF
:tempo1
nop ; pour ajouter 1 cycle d'horloge
nop
decsz wait1 ; wait1 = wait1 - 1. Si wait = 0 alors on saute le jmp ce qui entraine la fin du sous programme tempo
jmp :tempo1 ; sinon, on boucle
ret

;*********************
end ; fin de listing

Voila, ce premier programme vous a montré comment utiliser des instructions manipulant les bits. Il en existe d'autres.

Résumé des instructions manipulant les bits

SETB octet.n Place un bit n à 1
CLRB octet.n Place un bit n à 0
SB octet.n Teste si un bit est à 1 et saute l'instruction suivante si c'est le cas
SNB octet.n Teste si un bit est à 0 et saute l'instruction suivante si c'est le cas
RL octet Fait faire une rotation à gauche d'un bit à l'octet
RR octet Fait faire une rotation à droite d'un bit à l'octet

Les rotations d'octets
Si le bit 7 est à 1, l'instruction RL (rotation à gauche) va placer le bit dans la retenue, une nouvelle rotation va ensuite entraîner le bit de la retenue vers le bit 0.
Si le bit 0 est à 1, l'instruction RR
(rotation à droite) va placer le bit dans la retenue, une nouvelle rotation va ensuite entraîner le bit de la retenue vers le bit 7.

Résumé des instructions manipulant la retenue

STC Place la retenue à 1
CLC Place la retenue à 0
SC Teste si la retenue est placée et saute l'instruction suivante si c'est le cas
SNC Teste si la retenue est à 0 et saute l'instruction suivante si c'est le cas

Lumi Mémo

Voici un nouveau programme qui montre comment lire un tableau en mémoire programme, et le recopier par adressage indirect en mémoire vive. On verra également comment lire les octets d'allumage des leds et modifier les temps d'allumage par adressage indirect.

Ici on utilise deux banques mémoires, une à l'adresse $30 pour placer les valeurs d'allumage des leds et l'autre à l'adresse $50 pour placer les valeurs de temporisation. Le résultat est plutôt joli, avec un effet d'accélération de l'affichage, comme une balle qui tombe et qui rebondit.

; Auteur: Jean Brunet
; jean.brunet17@wanadoo.fr
; Revision: 1.0
; Date: 10/12/2001
; Part: SX28AC
; Freq: 32 Khz

device SX28, OSC32KHZ ; chip SX28 et fréquence oscillateur interne.
device TURBO,CARRYX
; une instruction par coup d'horloges et retenue utilisée
ID 'Lumimemo'
; Nom du programme
reset reset_entry

org 8

wait1 ds 1 ; variable de boucle
indice ds 1
; variable indice de tableau
temp ds 1
; divers
valeur ds 1
; variable échange de tableaux
bk ds 1
; variable adresse en mémoire

org 0

reset_entry

mov m,#$0f
clr rb
; buffer de sortie B à 0
mov !rb,#%00000000
; port B en ecriture
clr rc
; buffer de sortie C à 0
mov !rc,#%00000000 ; port C en ecriture
; Note : Si rb et rc ne sont pas mis à 0 avant l'initialisation des ports en écriture, les diodes sont allumées à la mise en route
clr fsr ; reset all ram starting at 08h

:zero_ram
sb fsr.4 ; are we on low half of bank?
setb fsr.3 ; If so, don't touch regs 0-7
clr ind ; clear using indirect addressing
ijnz fsr, :zero_ram
; repeat until done

; ---------------------------------------

; note : l'utilisation du registre fsr modifie l'adresse de la banque mémoire courante. Il faut donc penser qu'en se plaçant sur la banque $30, on perd l'accès aux autres banques. Si votre variable est dans une autre banque (par ex. à l'adresse $10 + $5 ) vous pointerez sur $30 + $5 ! Bug...

mov indice,#0
mov bk,#$30 ; adresse banque mémoire allumage led
; ---------------------------------------
; lecture du tableau en mémoire programme
; ---------------------------------------
:Initbcle
mov temp,M ; sauvegarde du registre M
mov m,#table1>>8 ; on place dans M la partie haute de l'adresse de table (poids fort)
mov w,#table1 & $FF ; on place dans w la partie basse de l'adresse de table (poids faible)
clc ; pas de retenue
add w,indice
; on ajoute l'indice du tableau pour trouver la valeur
iread ; lecture du tableau
mov valeur,w ; récupération de la valeur lue dans le tableau
mov M,temp ; restauration du registre M
; ---------------------------------------
; adressage mémoire indirect
; ---------------------------------------
mov fsr,bk ; on se place sur l'adresse mémoire présente dans bk
mov ind,valeur ; et on recopie la valeur du tableau dans cette banque mémoire (adressage indirect)
inc bk ; prochaine adresse dans banque mémoire
inc indice ; prochain indice du tableau
cje indice,#23,allumage ; fin de tableau
cjne indice,#11, :Initbcle ; si différent de 12, boucle, sinon change de banque.
mov bk,#$50 ; adresse banque temporisation
jmp :Initbcle ; boucle

; ******************
; boucle du programme
; ******************

allumage
; note : on utilise fsr pour charger l'allumage des led et la valeur de la temporisation

mov bk,#$30 ; adresse banque d'allumage de led
mov indice,#0
; indice du tableau
mov temp,#$20
; décalage d'une banque pour trouver temporisation
mov rc,#0
:bcl
clc ; ne pas oublier de placer la retenue à 0 avant une addition
mov w,bk ; adresse de base
add w,indice ; ajout de l'indice
mov fsr,w ; on se place sur l'adresse mémoire
mov valeur,ind ; on récupère la valeur
cja indice,#7, :portc ; changement de port si indice > 7
mov rb,valeur ; écrit sur le port B
jmp :suite ; et continue
:portc
mov rb,#0 ; port B éteint
mov rc,valeur ; écrit sur le port C
:suite
clc ; retenue à 0
mov w,bk ; adresse de base
add w,indice ; ajout de l'indice
add w,temp ; et ajoute décalage pour pointer sur valeurs de temporisation
mov fsr,w ; nouvelle adresse mémoire
mov wait1,ind ; on récupère la valeur
call tempoled ; vers sous programme de temporisation
inc indice ; indice suivant
cse indice,#11 ; si fin du tableau, saute l'instruction suivante
jmp :bcl
jmp allumage

tempoled
; on utilise deux boucles imbriquées pour allonger le temps

:tempo1
mov valeur,#7

:r
decsz valeur
jmp :r
decsz wait1
jmp :tempo1
ret

table1

dw 1,2,4,8,16,32,64,128,1,2,4,8
dw 255,185,165,145,120,70,35,70,120,148,185,225

end

Résumé des instructions manipulant la mémoire

MOV FSR,adr Le registre FSR permet d'adresser la mémoire vive sur 8 bits, de la banque 1 à la
banque F. Associé à IND, il permet un adressage indirect.
MOV w,IND Retourne la valeur dont l'adresse est stipulée dans FSR, et la place dans w
MOV IND,w Place la valeur présente dans w à l'adresse stipulée dans FSR
MOV M,adrH
MOV w,adrL
Permet d'adresser la mémoire sur 12 bits, donc sur tout l'espace mémoire progamme. Les 4 bits (partie haute de l'adresse) sont placés dans M et les 8 bits restant sont placés dans w. Attention le registre M doit être sauvegardé.
MOV IREAD
MOV adr,w
IREAD place le pointeur de donnée sur l'adresse mémoire 12 bits donnée ci-dessus et retourne la valeur dans w, que l'on peut placer à une adresse en mémoire vive.

Ne ratez pas Lumifolies, un source qui vous permettra toutes les folies ! (touche droite).