Compte à rebours avec écran OLED en I2C

MGU

Senior Member
vous avez pus remarquez que je détestai ça !!!
dje...là,c'est de la provocation.

J'ai commandé sur eBay un afficheur 128 x 64, avec le même contrôleur.
J'espère que lorsque je le recevrai, tous les problèmes seront réglés...

MM

.

MM
 

GM39

Senior Member
En prenant comme modèle une police 7 segments (ou 16) ou une police LCD la réduction doit être encore plus forte.
 

BESQUEUT

Senior Member
En prenant comme modèle une police 7 segments (ou 16) ou une police LCD la réduction doit être encore plus forte.
Le programme indiqué en #29 permet de charger une police existante, de choisir la taille de chaque cellule, d'ajuster si besoin et d'enregistrer le tout sous forme de commandes hexadécimales.
Et je confirme qu'avec une police dessinée pour ça, il y a moyen d'optimiser le code. Mais il semble que notre ami parte plutôt sur un processeur plus puissant. Donc...
 

BESQUEUT

Senior Member
J'ai commandé sur eBay un afficheur 128 x 64, avec le même contrôleur.
J'espère que lorsque je le recevrai, tous les problèmes seront réglés...
Avec un Picaxe rapide ça marche bien. Si vous souhaitez plusieurs tailles de police, et/ou faire des cadres et/ou des histogrammes, le code peut devenir assez gros. Comme indiqué par PieM l'option "slots" est à prendre en compte, mais ça implique une réflexion sur la structure du programme.
 

dje8269

Senior Member
Un lien sur cet encodeur SVP
@Michel :

Voici le lien de l'encodeur que je trouve de mauvaise facture . Car il n'est pas normal , que sans sauté de cran , les valeurs changent ? juste en forcant un tout petit peu un butée ca change aléatoirement .

Encodeur incremental

Bon j'ai oublié mon code sur l'ordi de la maison ?? pour tester un 20X2 !!! il faudrait que je modifie celui que j'ai publié
 

PieM

Senior Member
Voici le lien de l'encodeur que je trouve de mauvaise facture . Car il n'est pas normal , que sans sauté de cran , les valeurs changent ? juste en forcant un tout petit peu un butée ca change aléatoirement .
Mauvaise facture un Bourns ?? n'achète pas de chinois alors ...
le lien n'est pas suffisant. Il y a plusieurs crantages/résolutions. Donne la référence complète.
il n'est pas anormal que les valeurs changent. le crantage est mécanique et avant de l'avoir quitté, tu peux changer d'info sur une piste !
 

dje8269

Senior Member
Mauvaise facture un Bourns ??
Désolé, je ne connais pas cette marque

Donne la référence complète.
Ben , c'est celui du lien ? c'est exactement ce code commande que j'ai acheté . Référence fabricant PEC12R-4217F-S0024

il n'est pas anormal que les valeurs changent. le crantage est mécanique et avant de l'avoir quitté, tu peux changer d'info sur une piste !
D'accord, merci bien pour ces précisions . Du coup le sans crans me parait plus adéquat
 

PieM

Senior Member
Du coup le sans crans me parait plus adéquat
Pas compris pourquoi ! si tu as 24 crantages, tu vas compter 24 par tour. C'est au contraire beaucoup plus sûr.
Ou alors c'est ton programme qui est chinois...
 

dje8269

Senior Member
Ou alors c'est ton programme qui est chinois...
Lol ca c'est pas impossible , je te l'accorde .

Pas compris pourquoi ! si tu as 24 crantages, tu vas compter 24 par tour
Car quand tu écris ça :
il n'est pas anormal que les valeurs changent
Pour moi ce fonctionnement est anormal. tant que le cran n'as pas été dépassé, je ne veux pas que les valeurs changent . Car on forcant trés peux sans sauté le cran, les valerus changent, question pratique c'est pas top ! même si je ne le conçois je chipote un peu .
 

PieM

Senior Member
Car quand tu écris ça :

Pour moi ce fonctionnement est anormal. tant que le cran n'as pas été dépassé, je ne veux pas que les valeurs changent . Car on forcant trés peux sans sauté le cran, les valerus changent, question pratique c'est pas top ! même si je ne le conçois je chipote un peu .
Ben ça sera pire sans crantage alors! si tu t'amuses à rester en équilibre sur un front de piste...
En outre tu ne sais jamais de quelle position tu pars, ce qui complique le programme.
 

dje8269

Senior Member
si tu t'amuses à rester en équilibre sur un front de piste...
Non non , c'est pas comme ca ! .

je tourne mon encodeur , je le lache normalement . tout va bien . maintenant , je prends l'axe et force tout doucement d'un coté ou de l'autre et la valeur change, sans même avoir fais un cran . Quand je force , je devrait dire j'effleure plutot . Sans crantage o nse rend pas compte de ce probléme qui n'en ai pas vraiment un . Car comme y'a pas de cran on ne sait pas quand la valeur doit changer ; Avec les crans on s'attend a ce que la valeur change apres avoir sauté un cran et non avant ! .

C'est pour ca que je disais qu'il a du prendre un choc ou de mauvaise facture ! car le changement de valeur devrait se faire apres le cran . Désolé si je m'exprime mal .
 

PieM

Senior Member
Non non , c'est pas comme ca ! .

je tourne mon encodeur , je le lache normalement . tout va bien . maintenant , je prends l'axe et force tout doucement d'un coté ou de l'autre et la valeur change, sans même avoir fais un cran . Quand je force , je devrait dire j'effleure plutot . Sans crantage o nse rend pas compte de ce probléme qui n'en ai pas vraiment un . Car comme y'a pas de cran on ne sait pas quand la valeur doit changer ; Avec les crans on s'attend a ce que la valeur change apres avoir sauté un cran et non avant ! .

C'est pour ca que je disais qu'il a du prendre un choc ou de mauvaise facture ! car le changement de valeur devrait se faire apres le cran . Désolé si je m'exprime mal .
Je pense que tu n'as pas compris comment fonctionnait un codeur!
En quadrature tu as 4 changements d'états entre deux crans. C'est à dire 96 sur un tour si 24 crans. Alors il est tout a fait possible que tu en aies un alors que tu n'as pas sauté le cran qui est mécanique .
Encore une fois c'est le programme qui tient compte de ça.
on compare état passé avec état présent . En toute rigueur, il y a théoriquement 16 possibilités : 4 sont une incrémentation, 4, une décrémentation, 4 une erreur , et 4 impossibles.

Si ton programme se contente d'afficher les valeurs des deux entrées, c'est sûr qu'on est loin d'un décodeur....
 

dje8269

Senior Member
D'accord, effectivement, je pense aussi que je n'ai pas compris !

J'avais justement fais ce petit programme pour voir ce qui se passait ! bon apparemment je me suis gouré ! . Ça fais encore beaucoup de nouvelle chose a ingurgiter pour moi .
Alors il est tout a fait possible que tu en aies un alors que tu n'as pas sauté le cran qui est mécanique .
Ok donc l'encodeur n'est pas de mauvaise de facture et n'as pas de choc. c'estdoncnormal a moi de traiter ca par programme


Sinon avez vous déjà rencontrer cette erreur lors de l'upload du programme ?

Sans titre.JPG

J'ai l'impression que ça arrive de plus en plus souvent ! hier ça me l'as déjà fais , quand j'étais limite en place mémoire sur le µC . Ou alors mon câble et/ou mon connecteur commence à taper dans les gamelles .

Bon sinon , a chaque fois que je veux faire un truc sympa , je me heurte à un mur . Je rentre à la maison et je vous en parle ! une histoire de clignotement de chiffre pour savoir les chiffres qu'on règle .......... avec une petite vidéo pour vous montrer de quoi il en retourne
 

dje8269

Senior Member
Bon alors j'en suis rendu la !

plein écran

[video=dailymotion;x28b1sm]http://www.dailymotion.com/video/x28b1sm_chrono-compte-a-rebours-avec-picaxe_tech[/video]

1ere partie du code ;

L'idée serait ,de sans trop détériorer la réactivité, de faire clignoter par exemple les deux premiers chiffres ( dizaine de minutes et minute) , puis avec un appui sur le BP ( de l'encodeur) de passer aux réglages des dizaines de seconde et des secondes, en les faisant aussi clignoter .

ca risque d'être très difficile je pense , sans dégrader, la réactivité, SI ce n'est pas faisable , je me rabattrai sur un soulignement des chiffres qu'on règle !

1er partie

Code:
#PICAXE 20X2

'########################  Configuration  I/O ########################


symbol Aact		= bit0	'Valeur de A actuelle
symbol Aprec	= bit2	'Valeur de A pecédente
Symbol Mem_time	= b3
Symbol minute 	= b4
Symbol seconde	= b5
symbol sec 		= b10
symbol Dizsec 	= b11
symbol minu 	= b12
symbol Dizminu 	= b13
symbol Compteur	= w13		'compteur

symbol InputA	= pinB.1	' Broche de l'encodeur
symbol InputB	= pinB.0
Symbol RST 		= B.3

'########################  Initialisation ########################

setfreq M64

hi2csetup i2cmaster,%01111000,i2cfast_32,i2cbyte	' Configuration du mode I2C

pullup %00011001	'pullup sur C.0, B.0 et B.1


low RST		' On reset l'ecran pour etre certain qu'on parte sur de bonne base
pause 100

high RST		' On désactive le reset

sec = 0
Dizsec = 0
minu = 0
Dizminu = 0

'########################  Initialisation de l'écran   ########################

hi2cout 0x80,(0xAE,0x00,0x00,0x00,0x20,0x01,0x21,0,127,0x2  2,0,3,0xD5,0x80,0xA8,0x1F,0xD3,0x00,0x8D, _
0x14,0xA1,0x00,0xC8,0xDA,0x02,0x81,0x7F,0xD9,0xF1,  0xDB,0x20,0xA4,0xA6,0xAF)

#rem
hi2cout 0x80,(0xAE)         ;turn off display(RESET=OFF) eteins l'écran
hi2cout 0x80,(0x00,0x00)    ;low column nibble(RESET=0),high column nibble(RESET=0)
hi2cout 0x80,(0x00)         ;start page address(RESET=0)
hi2cout 0x80,(0x20,0x01)    ;memory address mode(RESET=02 [page])			choix du mode de fonctionnement, pour moi vertical=01
hi2cout 0x80,(0x21,0,127)    ;Setup column start and end address			definie la colonne du début et de fin pour l'init. 0 à 127 tout l'écran
hi2cout 0x80,(0x22,0,3)     ;Setup page start and end address			definie les pages de début et de fin 4 pages sur cet ecran de 0~3
hi2cout 0x80,(0xD5,0x80)    ;oscillator frequency and divider(RESET=80)
hi2cout 0x80,(0xA8,0x1F)    ;mux ratio(RESET=3F [64 lines])
hi2cout 0x80,(0xD3,0x00)    ;display offset,COM vertical shift(RESET=0)
hi2cout 0x80,(0x8D,0x14)    ;enable charge pump(RESET=10 [OFF])
hi2cout 0x80,(0xA1,0x00)    ;segment remap(RESET=SEG0, COL0) 00 mirror image
hi2cout 0x80,(0xC8)         ;COM output scan(RESET=C0, C8 flips display) C8=Le premier pixel commence en haut a gauche / C0= la premier pixel commence a bas a gauche
hi2cout 0x80,(0xDA,0x02)    ;COM pins hardware config(RESET=12[alternate])
hi2cout 0x80,(0x81,0x7F)    ;contrast CF(RESET=7F)
hi2cout 0x80,(0xD9,0xF1)    ;pre-charge period F1(RESET=22)
hi2cout 0x80,(0xDB,0x20)    ;Vcom deselect(RESET=20)
hi2cout 0x80,(0xA4)         ;turn all on ignore RAM A5/RAM A4(RESET=A4)
hi2cout 0x80,(0xA6)         ;normal display A6/inverted A7(RESET=A6)
hi2cout 0x80,(0xAF)         ;turn on display
#endrem


hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,60,67,0x22,0,3) 'création des deux points du milieu
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)


hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,98,127,0x22,0,3)	' affichage de 4 zeros au depart
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,67,97,0x22,0,3)
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,30,60,0x22,0,3)
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,0,29,0x22,0,3)
gosub chiffre0

'########################  Programme principale   ########################
do

do
bit0 = InputA		'sauvegarde inputA dans bit0
bit1 = InputB		'sauvegarde inputB dans bit1 
  
loop while Aact=Aprec	'Attente d'un changement
           
compteur= bit0 xor bit1 *2 + compteur-1  'formule magique de PieM
Aprec=Aact   

If compteur >=200 then : compteur=59 : end if
If compteur>=60 then : compteur =0 : endif


bintoascii compteur,b4, Dizsec, seconde

Dizsec= Dizsec -48
seconde = seconde -48

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,97,127,0x22,0,3)	' Mise a jour des secondes

	on seconde gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9 ' On selectionne le chiffre à afficher
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,67,97,0x22,0,3)				' Affichage des dizaines de secondes
	on dizsec gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5	' Selection du chiffre à afficher	

loop

'########################  Programme secondaire   ########################

'#### MAJsec ####
MAJ_sec:

inc sec			' Augmente de 1 seconde

if sec=10 then 		' Si seconde = 10 alors Mise à zéro de la valeur seconde et incrementation 
	sec =0		' Mise à zéro de la valeur seconde
	gosub MAJ_dizsec	' Go Mise à jour de la valeur dizaine de seconde
endif

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,97,127,0x22,0,3)	' Mise a jour des secondes

	on sec gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9 ' On selectionne le chiffre à afficher
return

'#### MAJ dizaine de seconde ####
MAJ_dizsec:

inc dizsec			' Augmente les dizaines de secondes

If dizsec>=6 then			' Si apres incrementation>=6
	dizsec = 0			' On met les dizaines de secondes a zero pour l'affichage
	gosub MAJ_minu		' On va mettre à jour les minutes
end if

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,67,97,0x22,0,3)				' Affichage des dizaines de secondes
	on dizsec gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5	' Selection du chiffre à afficher	
return

'#### MAJ minute ####
MAJ_minu:

inc minu				' Augmente les minutes

If minu>=10 then			' Si apres incrementation>=10
	minu = 0			' On met les minutes a zero pour l'affichage
	gosub MAJ_dizminu		' On va mettre à jour les dizaines de minutes
end if

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,30,60,0x22,0,3)		' Affichage des minutes
	on minu gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9	' Selection du chiffre à afficher	
return

'#### MAJ dizaine de minute ####
MAJ_dizminu:

inc Dizminu				' Augmente les dizaines de minutes

If Dizminu>=6 then		' Si apres incrementation>=6
	Dizminu = 0			' On met les minutes a zero pour l'affichage
end if

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,0,29,0x22,0,3)			' Affichage des dizaines de minutes
	on Dizminu gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5	' Selection du chiffre à afficher	
return
 

dje8269

Senior Member
2ieme partie les chiffres ::

Code:
'######################################################
'############## chiffre N° 0 ##########################
'######################################################
chiffre0:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0xFC, 0x3F, 0x00,_
0x80, 0xFF, 0xFF, 0x01,_
0xE0, 0xFF, 0xFF, 0x07,_
_
0xF0, 0xFF, 0xFF, 0x0F,_
0xF8, 0xFF, 0xFF, 0x1F,_
0xFC, 0xFF, 0xFF, 0x3F,_
0xFE, 0x00, 0x00, 0x7F,_
0xFE, 0x00, 0x00, 0x7F,_
_
0x7E, 0x00, 0x00, 0x7E,_
0x3E, 0x00, 0x00, 0x7C,_
0x1E, 0x00, 0x00, 0x78,_
0x1E, 0x00, 0x00, 0x78,_
0x1E, 0x00, 0x00, 0x78,_
_
0x1E, 0x00, 0x00, 0x78,_
0x1E, 0x00, 0x00, 0x78,_
0x3E, 0x00, 0x00, 0x7C,_
0x7E, 0x00, 0x00, 0x7E,_
0xFE, 0x00, 0x00, 0x7F,_
_
0xFE, 0x00, 0x00, 0x7F,_
0xFC, 0xFF, 0xFF, 0x3F,_
0xF8, 0xFF, 0xFF, 0x1F,_
0xF0, 0xFF, 0xFF, 0x0F,_
0xE0, 0xFF, 0xFF, 0x07,_
_
0x80, 0xFF, 0xFF, 0x01,_
0x00, 0xFC, 0x3F, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 1 ##########################
'######################################################
chiffre1:
for b2 =0 to 4
   hi2cout 0x40,( 0x00, 0x00, 0x00, 0x00)
next

for b2 = 0 to 4
hi2cout 0x40,(0xE0, 0x01, 0x00, 0x78)
next

hi2cout 0x40,(_
0xF0, 0x01, 0x00, 0x78,_
0xF0, 0x01, 0x00, 0x78,_
0xF8, 0xFF, 0xFF, 0x7F)

for b2 = 0 to 5
hi2cout 0x40,(0xFE, 0xFF, 0xFF, 0x7F)
next

for b2 = 0 to 6
hi2cout 0x40,(0x00, 0x00, 0x00, 0x78)
next

for b2 = 0 to 3
hi2cout 0x40,(0x00, 0x00, 0x00, 0x00)
next

return

'######################################################
'############## chiffre N° 2 ##########################
'######################################################
chiffre2:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00, _
0x00, 0x00, 0x00, 0x00, _
0x00, 0x00, 0x00, 0x7C, _
0xF8, 0x00, 0x00, 0x7E, _
0xFC, 0x00, 0x00, 0x7F, _
0xFC, 0x00, 0x00, 0x7F, _
0x7C, 0x00, 0x80, 0x7F, _
0x7C, 0x00, 0xC0, 0x7F, _
0x3E, 0x00, 0xE0, 0x7F, _
0x3E, 0x00, 0xE0, 0x7F, _
0x3E, 0x00, 0xF0, 0x7F, _
0x1E, 0x00, 0xF8, 0x7B, _
0x1E, 0x00, 0xFC, 0x79, _
0x1E, 0x00, 0xFE, 0x78, _
0x1E, 0x00, 0xFF, 0x78, _
0x1E, 0x00, 0x7F, 0x78, _
0x3E, 0x80, 0x3F, 0x78, _
0x3E, 0xE0, 0x1F, 0x78, _
0xFE, 0xF8, 0x0F, 0x78, _
0xFC, 0xFF, 0x07, 0x78, _
0xFC, 0xFF, 0x07, 0x78, _
0xF8, 0xFF, 0x03, 0x78, _
0xF8, 0xFF, 0x00, 0x78, _
0xF0, 0x7F, 0x00, 0x78, _
0xC0, 0x1F, 0x00, 0x78)

for b2 = 0 to 4
hi2cout 0x40,(0x00, 0x00, 0x00, 0x00)
next

return

'######################################################
'############## chiffre N° 3 ##########################
'######################################################
chiffre3:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x1F,_
0xf8, 0x00, 0x00, 0x3F,_
0xFC, 0x00, 0x00, 0x3F,_
_
0xFC, 0x00, 0x00, 0x3E,_
0x7C, 0x00, 0x00, 0x3E,_
0x7C, 0x00, 0x00, 0x7C,_
0x3E, 0x00, 0x00, 0x7C,_
0x3E, 0x00, 0x00, 0x7C,_
_
0x3E, 0xE0, 0x01, 0x78,_
0x1E, 0xE0, 0x01, 0x78,_
0x1E, 0xE0, 0x01, 0x78,_
0x1E, 0xE0, 0x01, 0x78,_
0x1E, 0xE0, 0x01, 0x78,_
_
0x1E, 0xF0, 0x01, 0x78,_
0x3E, 0xF0, 0x01, 0x7C,_
0x3E, 0xF8, 0x03, 0x7C,_
0x7E, 0xFC, 0x03, 0x3E,_
0xFC, 0xFF, 0x0f, 0x3F,_
_
0xFC, 0xFF, 0xFF, 0x3F,_
0xFC, 0xBF, 0xFF, 0x1F,_
0xF8, 0x1F, 0xFF, 0x1F,_
0xF0, 0x1F, 0xFF, 0x0F,_
0xE0, 0x07, 0xFE, 0x07,_
_
0x00, 0x00, 0xF8, 0x01,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 4 ##########################
'######################################################
chiffre4:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x7C, 0x00,_
0x00, 0x00, 0x7E, 0x00,_
0x00, 0x00, 0x7F, 0x00,_
0x00, 0x80, 0x7F, 0x00,_
_
0x00, 0xC0, 0x7F, 0x00,_
0x00, 0xE0, 0x7F, 0x00,_
0x00, 0xF0, 0x7F, 0x00,_
0x00, 0xF8, 0x7F, 0x00,_
0x00, 0xFC, 0x7B, 0x00,_
_
0x00, 0xFE, 0x79, 0x00,_
0x00, 0xFF, 0x78, 0x00,_
0x80, 0x7F, 0x78, 0x00,_
0xC0, 0x3F, 0x78, 0x00,_
0xE0, 0x1F, 0x78, 0x00,_
_
0xF0, 0x0F, 0x78, 0x00,_
0xF8, 0x07, 0x78, 0x00,_
0xFC, 0x03, 0x78, 0x00,_
0xFE, 0xFF, 0xFF, 0x7F,_
0xFE, 0xFF, 0xFF, 0x7F,_
_
0xFE, 0xFF, 0xFF, 0x7F,_
0xFE, 0xFF, 0xFF, 0x7F,_
0xFE, 0xFF, 0xFF, 0x7F,_
0xFE, 0xFF, 0xFF, 0x7F,_
0x00, 0x00, 0x78, 0x00,_
_
0x00, 0x00, 0x78, 0x00,_
0x00, 0x00, 0x78, 0x00,_
0x00, 0x00, 0x78, 0x00,_
0x00, 0x00, 0x78, 0x00,_
0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 5 ##########################
'######################################################
chiffre5:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x1F,_
0x00, 0x00, 0x00, 0x3F,_
_
0xFE, 0xFF, 0x00, 0x3F,_
0xFE, 0xFF, 0x00, 0x3E,_
0xFE, 0xFF, 0x00, 0x7E,_
0xFE, 0xFF, 0x00, 0x7C,_
0xFE, 0xFF, 0x00, 0x7C,_
_
0x1E, 0xF0, 0x00, 0x7C,_
0x1E, 0xF0, 0x00, 0x78,_
0x1E, 0xF0, 0x00, 0x78,_
0x1E, 0xF0, 0x00, 0x78,_
0x1E, 0xF0, 0x00, 0x78,_
_
0x1E, 0xF0, 0x00, 0x78,_
0x1E, 0xF0, 0x01, 0x78,_
0x1E, 0xF0, 0x01, 0x7c,_
0x1E, 0xF0, 0x01, 0x7C,_
0x1E, 0xF0, 0x03, 0x3E,_
_
0x1E, 0xE0, 0x87, 0x3F,_
0x1E, 0xE0, 0xFF, 0x3F,_
0x1E, 0xE0, 0xFF, 0x1F,_
0x1E, 0xC0, 0xFF, 0x0F,_
0x1E, 0x80, 0xFF, 0x0F,_
_
0x1E, 0x00, 0xFF, 0x03,_
0x1E, 0x00, 0xFC, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 6 ##########################
'######################################################
chiffre6:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0X00, 0xF0, 0x7F, 0x00,_
0x00, 0xFE, 0xFF, 0x01,_
0x80, 0xFF, 0xFF, 0x07,_
_
0xC0, 0xFF, 0xFF, 0x0F,_
0xE0, 0xFF, 0xFF, 0x1F,_
0xF0, 0xFF, 0xFF, 0x3F,_
0xF8, 0xFF, 0xC1, 0x3F,_
0xF8, 0xE3, 0x01, 0x3F,_
_
0xFC, 0xF1, 0x01, 0x7E,_
0xFC, 0xF0, 0x00, 0x7C,_
0xFC, 0xF0, 0x00, 0x7C,_
0x3E, 0xF0, 0x00, 0x78,_
0x3E, 0xF0, 0x00, 0x78,_
_
0x1E, 0xF0, 0x00, 0x78,_
0x1E, 0xF0, 0x00, 0x78,_
0x1E, 0xF0, 0x01, 0x7C,_
0x1E, 0xF0, 0x01, 0x7C,_
0x1E, 0xF0, 0x03, 0x7E,_
_
0x1E, 0xF0, 0x87, 0x3F,_
0x3E, 0xE0, 0xFF, 0x3F,_
0x3E, 0xE0, 0xFF, 0x1F,_
0x3E, 0xC0, 0xFF, 0x1F,_
0x00, 0x80, 0xFF, 0x0F,_
_
0x00, 0x00, 0xFF, 0x07,_
0x00, 0x00, 0xFE, 0x01,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 7 ##########################
'######################################################
chiffre7:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x3C, 0x00, 0x00, 0x00,_
0x3C, 0x00, 0x00, 0x00,_
0x3C, 0x00, 0x00, 0x00,_
_
0x3C, 0x00, 0x00, 0x60,_
0x3C, 0x00, 0x00, 0x70,_
0x3C, 0x00, 0x00, 0x7C,_
0x3C, 0x00, 0x00, 0x7E,_
0x3C, 0x00, 0x80, 0x7F,_
_
0x3C, 0x00, 0xC0, 0x7F,_
0x3C, 0x00, 0xF0, 0x7F,_
0x3C, 0x00, 0xFC, 0x3F,_
0x3C, 0x00, 0xFE, 0x0F,_
0x3C, 0x80, 0xFF, 0x07,_
_
0x3C, 0xC0, 0xFF, 0x01,_
0x3C, 0xF0, 0xFF, 0x00,_
0x3C, 0xF8, 0x3F, 0x00,_
0x3C, 0xFE, 0x0F, 0x00,_
0x3C, 0xFF, 0x07, 0x00,_
_
0xFC, 0xFF, 0x01, 0x00,_
0xFC, 0xFF, 0x00, 0x00,_
0xFC, 0x3F, 0x00, 0x00,_
0xFC, 0x1F, 0x00, 0x00,_
0xFC, 0x07, 0x00, 0x00,_
_
0xFC, 0x01, 0x00, 0x00,_
0xFC, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 8 ##########################
'######################################################
chiffre8:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0xF8, 0x01,_
0xC0, 0x0F, 0xFC, 0x07,_
0xF0, 0x1F, 0xFE, 0x0F,_
_
0xF8, 0x3F, 0xFF, 0x1F,_
0xF8, 0xFF, 0xFF, 0x3F,_
0xFC, 0xFF, 0xFF, 0x3F,_
0xFC, 0xFF, 0x8F, 0x3F,_
0x7E, 0xFC, 0x07, 0x7E,_
_
0x3E, 0xF8, 0x03, 0x7C,_
0x3E, 0xF8, 0x01, 0x7C,_
0x1E, 0xF0, 0x01, 0x78,_
0x1E, 0xF0, 0x01, 0x78,_
0x1E, 0xE0, 0x01, 0x78,_
_
0x1E, 0xE0, 0x03, 0x78,_
0x1E, 0xE0, 0x03, 0x78,_
0x3E, 0xE0, 0x07, 0x7C,_
0x3E, 0xF0, 0x07, 0x7C,_
0x7E, 0xF8, 0x0F, 0x7E,_
_
0xFC, 0xFF, 0x1F, 0x3F,_
0xFC, 0xFF, 0xFF, 0x3F,_
0xF8, 0xFF, 0xFF, 0x1F,_
0xF8, 0x3F, 0xFF, 0x1F,_
0xF0, 0x1F, 0xFE, 0x0F,_
_
0xC0, 0x07, 0xFC, 0x07,_
0x00, 0x00, 0xF8, 0x01,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 9 ##########################
'######################################################
chiffre9:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x80, 0x3F, 0x00, 0x00,_
0xE0, 0xFF, 0x00, 0x00,_
0xF0, 0xFF, 0x01, 0x00,_
_
0xF8, 0xFF, 0x03, 0x7C,_
0xF8, 0xFF, 0x07, 0x7C,_
0xFC, 0xFF, 0x07, 0x7C,_
0xFC, 0xE1, 0x07, 0x78,_
0x7E, 0xC0, 0x0F, 0x78,_
_
0x3E, 0x80, 0x0F, 0x78,_
0x3E, 0x80, 0x0F, 0x78,_
0x1E, 0x00, 0x0F, 0x78,_
0x1E, 0x00, 0x0F, 0x78,_
0x1E, 0x00, 0x0F, 0x7C,_
_
0x1E, 0x00, 0x0F, 0x7C,_
0x3E, 0x00, 0x0F, 0x3E,_
0x3E, 0x00, 0x0F, 0x3F,_
0x7E, 0x80, 0x8F, 0x3F,_
0xFC, 0x80, 0xC7, 0x1F,_
_
0xFC, 0x83, 0xFF, 0x1F,_
0xFC, 0xFF, 0xFF, 0x0F,_
0xF8, 0xFF, 0xFF, 0x07,_
0xF0, 0xFF, 0xFF, 0x03,_
0xE0, 0xFF, 0xFF, 0x01,_
_
0xC0, 0xFF, 0x7F, 0x00,_
0x00, 0xFE, 0x0F, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)

return
 

MGU

Senior Member
C'est pas mal du tout ça.
Pour découper un nombre de deux chiffres, pas besoin de passer par bintoascii, surtout si on a pas besoin de l'ascii.

dizsec= compteur/10
seconde=compteur//10

Ce qui doit pas être trop compliqué pour le réglage, c'est de n'afficher que les minutes pour le réglage des minutes et le total pour ajouter les secondes (comme l'exemple donné pour le TM1637)

MM
 
Last edited:

dje8269

Senior Member
Pour découper un nombre de deux chiffres, pas besoin de passer par bintoascii, surtout si on a pas besoin de l'ascii.
dizsec= compteur/10
seconde=compteur//10
Effectivement c'est bien plus simple. Merci Michel pour ce coup de pouce

Edit : je viens d'essayer le changement, et j'ai l'impression d'avoir gagné beaucoup en réactivité ; c'est peut etre qu'une impression, mais merci
 
Last edited:

dje8269

Senior Member
Comment compter le temps d'appui d'un BP sur 20X2. La fonction "time" n'est pas disponible , utilisation de la fonction "timer" ? Le but lancé le compte à rebours quand on appui sur le BP pendant 2 ou 3 secondes ( à déterminé avec des tests) .
 

PieM

Senior Member
Comment compter le temps d'appui d'un BP sur 20X2. La fonction "time" n'est pas disponible , utilisation de la fonction "timer" ? Le but lancé le compte à rebours quand on appui sur le BP pendant 2 ou 3 secondes ( à déterminé avec des tests) .
Voir settimer et la variable timer.
 

dje8269

Senior Member
Je viens de finir mon usine a gaz !

Je suppose qu'il y as beaucoup d'amélioration a apporter . Voici un premier jet .

On voit quelques bug sur la vidéo , notamment des points parasites au tout début .
J'ai loupé un appui sur le BP pour changer de réglages .

j'ai un doute sur mes calculs pour le timer ( voir commentaires ).

J'ai fais des truc bizarre je trouve pour que ca arrête de décrémenter quand les chiffres du dessus sont a zéro .

Je pense peut etre passer par un interruption pour détecter l'appui sur le BP .

j'ai accélérer le compte à rebours pour la vidéo ; a la fin , quand tout est a 0 on reset et on peut repartir .

Bien évidemment j'attends vos commentaires, suggestions, qui sont toujours productives . Je suis quand même plutôt satisfait du résultat ;
Il me reste a faire s'allumer le BP quand on appui dessus , ce fera un effet sympa je pense . le BP s'allume ne rouge et vert .

Voici le programme ( la deuxieme partie en #55 les chiffres) :

Code:
#PICAXE 20X2

'########################  Configuration  I/O ########################


symbol Aact		= bit0	' Valeur de A actuelle
symbol Aprec	= bit2	' Valeur de A pecédente
Symbol position	= bit8	' Position du réglage ( les secondes ou les minutes) La variable b0 est utilisé par la foormule de Piem, don't touch !

symbol seconde	= b10
symbol Dizsec 	= b11
symbol minute 	= b12
symbol Dizminu 	= b13
Symbol Compt_min	= w12		' compteur des minutes
symbol Compt_sec	= w13		' compteur des secondes

symbol InputA	= pinB.1	' Broche de l'encodeur
symbol InputB	= pinB.0
Symbol Chgt		= PinC.0	' Broche du BP
Symbol RST 		= B.3		' Broche du RESET ecran

'########################  Initialisation ########################

setfreq M64

hi2csetup i2cmaster,%01111000,i2cfast_32,i2cbyte	' Configuration du mode I2C

pullup %00011001	'pullup sur C.0, B.0 et B.1

settimer 15536	 'A 64Mhz une impulsion primaire dur 4µs.une impulsion secondaire toute les 50000 impulsions primaires donc toutes les 200000µs
			' Il faut donc 5 impulsions secondaires pour faire une seconde

low RST		' On reset l'ecran pour etre certain qu'on parte sur de bonne base
pause 100

high RST		' On désactive le reset

seconde = 0
Dizsec = 0
minute = 0
Dizminu = 0
position = 0

'########################  Initialisation de l'écran   ########################

hi2cout 0x80,(0xAE,0x00,0x00,0x00,0x20,0x01,0x21,0,127,0x2  2,0,3,0xD5,0x80,0xA8,0x1F,0xD3,0x00,0x8D, _
0x14,0xA1,0x00,0xC8,0xDA,0x02,0x81,0x7F,0xD9,0xF1,  0xDB,0x20,0xA4,0xA6,0xAF)

#rem
hi2cout 0x80,(0xAE)         ;turn off display(RESET=OFF) eteins l'écran
hi2cout 0x80,(0x00,0x00)    ;low column nibble(RESET=0),high column nibble(RESET=0)
hi2cout 0x80,(0x00)         ;start page address(RESET=0)
hi2cout 0x80,(0x20,0x01)    ;memory address mode(RESET=02 [page])			choix du mode de fonctionnement, pour moi vertical=01
hi2cout 0x80,(0x21,0,127)    ;Setup column start and end address			definie la colonne du début et de fin pour l'init. 0 à 127 tout l'écran
hi2cout 0x80,(0x22,0,3)     ;Setup page start and end address			definie les pages de début et de fin 4 pages sur cet ecran de 0~3
hi2cout 0x80,(0xD5,0x80)    ;oscillator frequency and divider(RESET=80)
hi2cout 0x80,(0xA8,0x1F)    ;mux ratio(RESET=3F [64 lines])
hi2cout 0x80,(0xD3,0x00)    ;display offset,COM vertical shift(RESET=0)
hi2cout 0x80,(0x8D,0x14)    ;enable charge pump(RESET=10 [OFF])
hi2cout 0x80,(0xA1,0x00)    ;segment remap(RESET=SEG0, COL0) 00 mirror image
hi2cout 0x80,(0xC8)         ;COM output scan(RESET=C0, C8 flips display) C8=Le premier pixel commence en haut a gauche / C0= la premier pixel commence a bas a gauche
hi2cout 0x80,(0xDA,0x02)    ;COM pins hardware config(RESET=12[alternate])
hi2cout 0x80,(0x81,0x7F)    ;contrast CF(RESET=7F)
hi2cout 0x80,(0xD9,0xF1)    ;pre-charge period F1(RESET=22)
hi2cout 0x80,(0xDB,0x20)    ;Vcom deselect(RESET=20)
hi2cout 0x80,(0xA4)         ;turn all on ignore RAM A5/RAM A4(RESET=A4)
hi2cout 0x80,(0xA6)         ;normal display A6/inverted A7(RESET=A6)
hi2cout 0x80,(0xAF)         ;turn on display
#endrem


hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,60,67,0x22,0,3) 'création des deux points du milieu
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x0F, 0xF0, 0x00,_
0x00, 0x00, 0x00, 0x00,_
0x00, 0x00, 0x00, 0x00)


hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,98,127,0x22,0,3)	' affichage de 4 zeros au depart
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,67,97,0x22,0,3)
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,30,60,0x22,0,3)
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,0,29,0x22,0,3)
gosub chiffre0

'########################  Programme principal   ########################
main:
do

	do
		bit0 = InputA			'sauvegarde inputA dans bit0
		bit1 = InputB			'sauvegarde inputB dans bit1 
	  
	  	If Chgt=0 then			' Appui sur le BP
	  	
	  	timer =0	
	  		do loop while Chgt=0	' anti-rebond
	  		inc position		' change la position 0 ou 1
	  		
	  	if timer >= 10 then			' voir calcul a l'initialsation au début 10 = 2 secondes
	  	gosub Lancement	' lance le compte à rebours
	  	end if	
	  		
	  	end if
	  
	loop while Aact=Aprec			'Attente d'un changement
           
if position = 1 then

	compt_sec= bit0 xor bit1 *2 + compt_sec-1  'formule magique de PieM
	Aprec=Aact 	' Actualisation de A  
	
	If compt_sec >=200 then : compt_sec=59 : end if	' si compteur = 255 (quand on decremente 0) on le met a 59 .
	If compt_sec >=60 then : compt_sec =0 : endif	' si le compteur est = 60 ( quand on incremente 59) on le met à 0
	
	dizsec= compt_sec/10		' On divise par 10 pour recuperer les dizaines
	seconde=compt_sec//10		' on fait modulo 10 , le reste de la division par 10 pour recuperer les unités
	
		hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,97,127,0x22,0,3)	' Mise a jour des secondes
			on seconde gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9 
	
		hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,67,97,0x22,0,3)				' Affichage des dizaines de secondes
			on dizsec gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5
	
else

	compt_min= bit0 xor bit1 *2 + compt_min-1  'formule magique de PieM
	Aprec=Aact 	' Actualisation de A  
	
	If compt_min >=200 then : compt_min=59 : end if	' si compteur = 255 (quand on decremente 0) on le met a 59 .
	If compt_min >=60 then : compt_min =0 : endif	' si le compteur est = 60 ( quand on incremente 59) on le met à 0
	
	dizminu= compt_min/10		' On divise par 10 pour recuperer les dizaines
	minute=compt_min//10		' on fait modulo 10 , le reste de la division par 10 pour recuperer les unités
	hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,30,60,0x22,0,3)		' Affichage des minutes
		on minute gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9
	
	hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,0,29,0x22,0,3)			' Affichage des dizaines de minutes
		on Dizminu gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5	
end if

loop

'########################  Programme secondaire   ########################

Lancement:

timer = 0		' RAZ du compteur

do			' Il faut donc 5 impulsions secondaires pour faire une seconde

if timer>=5 then : gosub MAJ_sec : end if	' timer = 5 = 1seconde

loop


'#### MAJsec ####
MAJ_sec:

dec seconde			' diminue de 1 seconde

if seconde=255 then 		' Si seconde = 255 alors Mise à 9 de la valeur seconde et decrementation des dizaines de seconde 
	
	if dizsec > 0 or minute<>0 or dizminu<>0 then
		seconde =9		' Mise à zéro de la valeur seconde
		gosub MAJ_dizsec	' Go Mise à jour de la valeur dizaine de seconde
	else
		pause 8000	' fin cu compte a rebours
		reset		' on recommence
	endif
endif

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,97,127,0x22,0,3)	' Mise a jour des secondes

	on seconde gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9 ' On selectionne le chiffre à afficher
timer = 0
return

'#### MAJ dizaine de seconde ####
MAJ_dizsec:

dec dizsec			' Augmente les dizaines de secondes

If dizsec=255 then			' Si apres decrementation = 255
	
	if minute > 0 or dizminu<>0 then
		dizsec = 5			' On met les dizaines de secondes a 9 pour l'affichage
		gosub MAJ_minu		' On va mettre à jour les minutes
	end if
end if

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,67,97,0x22,0,3)				' Affichage des dizaines de secondes
	on dizsec gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5	' Selection du chiffre à afficher	
timer = 0
return

'#### MAJ minute ####
MAJ_minu:

dec minute				' decremente les minutes

If minute=255 then			' Si apres decrementation=255
	
	if dizminu >0 then	' si les dizaines de minutes sont a zero pas besoin de mettre a jour
		minute = 9			' On met les minutes a zero pour l'affichage
		gosub MAJ_dizminu		' On va mettre à jour les dizaines de minutes
	end if
end if

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,30,60,0x22,0,3)		' Affichage des minutes
	on minute gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9	' Selection du chiffre à afficher	
timer = 0
return

'#### MAJ dizaine de minute ####
MAJ_dizminu:

dec Dizminu				' Augmente les dizaines de minutes

If Dizminu=255 then		' Si apres incrementation>=6
	Dizminu = 5			' On met les minutes a zero pour l'affichage
end if

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,0,29,0x22,0,3)			' Affichage des dizaines de minutes
	on Dizminu gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5	' Selection du chiffre à afficher	

timer = 0
return
Et voici la vidéo

[video=dailymotion;x28biei]http://www.dailymotion.com/video/x28biei_picaxe-compte-a-rebour_tech[/video]

lien plein ecran
 

PieM

Senior Member
Déjà dit mais c'est bon de le répéter : il est impossible de faire un chrono avec cette méthode qui consiste à mettre à 0 le timer chaque seconde !

Je ne comprends pas pourquoi tu n'utilises pas la variable timer . Si tu dois compter jusqu'à 60min, c'est 3600 secondes donc un timer à 18000 vu tes 64 MHz.

tu fais tous tes calculs en secondes, à partir de ce compteur qui lui s'incrémente avec précision.
Ce n'est que pour l'affichage que tu extrais minutes et secondes:
Code:
nb_secondes = timer /5

dminut= nb_secondes/600
minut = nb_secondes/60//10
dsecond = nb_secondes//60/10
second = nb_secondes//10
Idem pour ta préselection: tu incrémentes par 5 pour les secondes et par 300 pour les minutes.
et tu affiches avec le même principe en remplaçant nb_secondes par consigne par exemple.

ensuite, il serait plus judicieux d'utiliser une fonctionnalité intéressante de PE6, à savoir les macros avec passage de paramètres.

dans ton programme, tu affiches à chaque fois un chiffre en fonction d'un résultat:

si tu définis une macro:
Code:
#MACRO affiche(N)
on N gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9
#ENDMACRO
pour mettre à jour l'affichage, il suffit d'écrire

Code:
affiche(dminut)
affiche(minut)
affiche(dsecond)
affiche(second)
on peut même faire plus compact en définissant une macro indiquant non seulement le nombre , mais la position dans l'affichage:

Code:
#MACRO affiche(N,A,B)
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,A,B,0x22,0,3)
on N gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiff  re5,chiffre6,chiffre7,chiffre8,chiffre9
#ENDMACRO
la commande affiche (second, 97,127) va écrire le chiffre des secondes en position 97,127

Remarque aussi:
setfreq M64
hi2csetup i2cmaster,%01111000,i2cfast_32,i2cbyte

Et pourquoi cette poursuite à tout prix de la réactivité pour un truc qui se met à jour qu'une fois par seconde !!
tu passes ton temps à cavaler dans tes programmes pour finalement attendre ...

En tout cas, bravo à toi et Besqueut pour ce décorticage de l'afficheur !
 

dje8269

Senior Member
Oulala , que de très bonne remarques ! Pffffiouuu

Je ne comprends pas pourquoi tu n'utilises pas la variable timer . Si tu dois compter jusqu'à 60min, c'est 3600 secondes donc un timer à 18000 vu tes 64 MHz.
Benn moi non plus ! . Maintenant que tu le dis, ca parait tellement évident. J'avais certainement le nez trop dans le guidon !

ensuite, il serait plus judicieux d'utiliser une fonctionnalité intéressante de PE6, à savoir les macros avec passage de paramètres.
Je n'ai pas encore installé PE6... .

Les améliorations en valent telle le coup ! car je commençais a bien m'habituer avec mon PE5.5.5

on peut même faire plus compact en définissant une macro indiquant non seulement le nombre , mais la position dans l'affichage:
Ah oui effectivement pour compacter , ca compacte

Et pourquoi cette poursuite à tout prix de la réactivité pour un truc qui se met à jour qu'une fois par seconde !!
tu passes ton temps à cavaler dans tes programmes pour finalement attendre ...
La réactivité n'est la QUE pour l'encodeur incrémental, quand on le tourne .

En tout cas, bravo à toi et Besqueut pour ce décorticage de l'afficheur !
Merci . Besqueut ma bien maché le travail quand même .

PS : pas d'idée pour faire clignoter mes chiffres qui sont sélectionnés pour le réglages ? sans idée je pense que je vais réduire leurs tailles et les entourer par exemple ou les soulignés un truc du genre .
 

BESQUEUT

Senior Member
Comment compter le temps d'appui d'un BP sur 20X2. La fonction "time" n'est pas disponible , utilisation de la fonction "timer" ? Le but lancé le compte à rebours quand on appui sur le BP pendant 2 ou 3 secondes ( à déterminé avec des tests) .
Ben si justement. C'est une autre raison pour laquelle il ne faut pas remettre à zéro la variable Time :
Il suffit de noter à quelle heure vous avez appuyé sur le BP. Par différence avec le moment du relâché, vous savez combien de temps ça a duré...
Décidément, le lapin blanc, toujours le lapin blanc...
 

BESQUEUT

Senior Member
on peut même faire plus compact en définissant une macro indiquant non seulement le nombre , mais la position dans l'affichage:!
Je n'ai pas testé ces macros, mais (vu le nom) il s'agit de macro-compilation, donc de génération de code supplémentaire...
Ca reste à confirmer, mais à priori, si ce code est plus compact à l'édition, il devrait être au moins aussi volumineux sinon pire en encombrement mémoire.
Pour moi, ce genre de technique est utile pour rendre le code plus lisible, mais ne permet pas de réduire la taille du code. Ce n'est pas un véritable appel de sous-programme avec passage de paramètres...
 

BESQUEUT

Senior Member
PS : pas d'idée pour faire clignoter mes chiffres qui sont sélectionnés pour le réglages ? sans idée je pense que je vais réduire leurs tailles et les entourer par exemple ou les soulignés un truc du genre .
Vous pourriez aussi les dessiner en noir sur fond blanc : il y a un réglage de l'afficheur pour faire ça il me semble.
 

dje8269

Senior Member
C'est une bonne idée , mais j'ai peur qu'on ne sache plus , si c'est le noir sur blanc ou le blanc sur noir qui change !! je me suis déjà fais la remarque sur certains objet du quotidien . C'est le probléme quand on as que deux reglages . y'en aurait 3 ou 4 c'etait bon .
Pour les macros , j'ai pas trop compris le fonctionnement . Il m'arrive d'utiliser des macros par exemple sous excel . elle répète donc les taches que je lui ai rentré pendant l'enregistrement . C'est bien ce que fais le programme ?! c'est un peu comme le quadrature , j'ai une idée vague et flou mais pas assez pour m'étendre dessus ! lol

Je vais deja commencé par simplifier mon programme avec cette histoire de timer .
 

BESQUEUT

Senior Member
C'est une bonne idée , mais j'ai peur qu'on ne sache plus , si c'est le noir sur blanc ou le blanc sur noir qui change !!
Le doute sera vite levé dès que vous toucherez le bouton...
Ce qui est important, c'est de mettre en évidence que l'on est en mode mise à l'heure.
Le plus simple, c'est un soulignement ou un cadre. Peut-être est-il possible d'obtenir un clignotement en passant du mode normal au mode inverse vidéo sans effacer la zone. A tester.
Sinon, le simple fait de rafraîchir continuellement les deux chiffres en cours de mise à jour est sans doute suffisant pour obtenir un effet de clignotement,

Le retour visuel immédiat permet de voir ce qui change avec une bonne ergonomie. De ce point de vue, c'est la même chose avec l'encodeur : pas besoin de crantage puisqu'on voit immédiatement les chiffres changer.
 

dje8269

Senior Member
Le doute sera vite levé dès que vous toucherez le bouton...
Lol ; Non car cela s'inversera aussi; Tant qu'il n'y as que deux critères a mon avis , ce sera pas très clair pour l'utilisateur ( des enfants au demeurant) .

Sinon, le simple fait de rafraîchir continuellement les deux chiffres en cours de mise à jour est sans doute suffisant pour obtenir un effet de clignotement,
A essayer effectivement mais je doute , car la réactivité est tout simplement géniale, Quasi immédiate . Franchement je m'attendais pas a ça. J'étais resté sur l'impression du LCD de mon projet projet ( le chenillard paint-ball) rien a voir .
 

PieM

Senior Member
Je n'ai pas testé ces macros, mais (vu le nom) il s'agit de macro-compilation, donc de génération de code supplémentaire...
Ca reste à confirmer, mais à priori, si ce code est plus compact à l'édition, il devrait être au moins aussi volumineux sinon pire en encombrement mémoire.
Pour moi, ce genre de technique est utile pour rendre le code plus lisible, mais ne permet pas de réduire la taille du code. Ce n'est pas un véritable appel de sous-programme avec passage de paramètres...
Ce n'est pas dans le but de réduire le code. Ces macros sont traitées par le pré-processeur de PE6 et engendre le même volume de code.
Le gros intérêt est dans la lisibilité des programmes.
Sinon pour réduire le code il est possible de faire des sous-programmes avec affectation des variables avant l'appel, classique avec de la gestion d'afficheur LCD par exemple.

Code:
symbol A = ....
symbol B = ....
symbol C = ....

A= 98 :B= 127:C= second
gosub affichage
A=67 : B= 97: C= dsecond
gosub affichage
etc ....

Affichage:
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,A,B,0x22,0,3)	
on C gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiffre5,chiffre6,chiffre7,chiffre8,chiffre9 
return
dje said:
Je n'ai pas encore installé PE6... .
Les améliorations en valent telle le coup ! car je commençais a bien m'habituer avec mon PE5.5.5
Ben oui! surtout que la 5.5.5 n'est plus d'actualité!
 
Last edited:

BESQUEUT

Senior Member
A essayer effectivement mais je doute , car la réactivité est tout simplement géniale, Quasi immédiate . .
Si vraiment le clignotement n'est pas visible, vous pouvez intercaler un effaçage des 2 chiffres en cours de réglage.
On peut même attendre un peu au noir avant de dessiner les 2 chiffres, puis attendre un peu plus (clignotement au noir : le chiffre est éclairé et s'éteint brièvement toutes les secondes).
Attention à la façon d'obtenir ce résultat puisque simultanément il faut prendre en compte ce qui vient de l'encodeur rotatif...
Il y a plusieurs façons d'aborder ce double problème, le premier point étant de savoir quel est le Picaxe concerné :
- interruptions,
- multitâche,
- technique du lapin blanc.

Le choix se fait dans cet ordre :
- si la première est possible : OK,
- sinon, si la deuxième est possible : OK (mais attention multitâche incompatible avec setfreq...)
- sinon : ben pas le choix : lapin blanc...
 
Last edited:

BESQUEUT

Senior Member
tempo = timer ' On enregistre le timer en cours methode du lapin blanc
...
tempo = timer - tempo ' On calcule le temps passé entre les deux evenements

if tempo >= 10 then ' Si le temps est superieur a 10 on lance le chrono ( 10 correspond à 2 secondes)
gosub Lancement ' lance le compte à rebours
end if

end if
A ben là tempo est perdu...
Faudrait une autre variable genre :
Appui= timer ' On enregistre l'heure à laquelle on a appuyé sur le bouton
...
tempo= timer - Appui ' On calcule le temps passé entre les deux evenements

??? L'animal aurai-t-il trouvé le problème et retiré son post ??? Je ne l'ai pas rêvé quand même ???
 

dje8269

Senior Member
??? L'animal aurai-t-il trouvé le problème et retiré son post ??? Je ne l'ai pas rêvé quand même ???
Lol exact . Mias j'ai marqué " désolé j'ai finis par trouvé" dans les causes de la suppression . je pensais que cela allait être visible .

Effectivement, il me faut encore une autre variable .

Grgrgrgr des fois je me trouve vraiment nul !! . Sinon ça fonctionne impeccable .

Ca a effectivement bien simplifié le programme. J'ai opté pour la solution de MAJ des valeurs seulement quand y as un changemetn de valeurs ; Sinon je pense que j'aurais pus mettre à jour les 4 chiffres , a chaque secondes , mais bon ....
 

PieM

Senior Member
C'est quand même plus simple d'utiliser timer3 pour ces fonctions annexes, puisque c'est un 20X2 !
 

BESQUEUT

Senior Member
Puisque vous semblez assez à l'aide avec la technique du lapin blanc, vous pouvez gérer le clignotement de la même façon.
Je n'ai plus le code (...) mais il me semble que votre horloge est en secondes.
Ce serait mieux en 1/10 de secondes (suffit de tester 30 dixième au lieu de 3 secondes)

Donc, en plus, vous notez "a quelle heure vous avez changé l'état des chiffres"

- tempo est le temps écoulé depuis cette heure,
- si tempo > 9/10 seconde, effacer les deux chiffres en cours de mise à jour (rectangle noir)
- prendre rendez-vous dans 1/10 seconde,
- ça y est : c'est l'heure : redessiner les chiffres,
- prendre rendez-vous dans 9/10 seconde
- etc...

En parallèle vous ne changez rien à vos tests pour savoir si on a appuyé sur le bouton plus de 30/10 seconde

Et vous pouvez "à la volée" détecter les changements d'état sur l'encodeur,
ou alors utiliser des interruptions...
 

BESQUEUT

Senior Member
C'est quand même plus simple d'utiliser timer3 pour ces fonctions annexes, puisque c'est un 20X2 !
Même avis : voir post #70
3 techniques possibles
C'est néanmoins intéressant d'expérimenter chacune pour voir les avantages et les inconvénients.
 

PieM

Senior Member
Même avis : voir post #70
3 techniques possibles
C'est néanmoins intéressant d'expérimenter chacune pour voir les avantages et les inconvénients.
Pas certain que le lapin simplifie le code ....
Et pas de multitâche avec les X2.
 

dje8269

Senior Member
Vous allez trop vite pour moi !!

@ PieM : je viens de relire la fonction tmr3 . apparemment c'est une très bonne façon, mais a la limite plus pour faire mon clignotement . Le timer 3 ne gène absolument en rien dans la vitesse de lecture des incrementation de l'encodeur si j'ai bien compris , car en tache de fond .

@ Besqueut : Après étude du code de mon point de vue, il faudrait éviter de rajouter des lignes quand le µc attend un changement de la part de l'encodeur . Au risque de voir s'effondre la réactivité non ? Je me suis juste permis de mettre un test pour savoir si on appui sur le bouton ou non

je vais d'abord essayé avec le timer 3, car votre solution m'oblige a tout revoir
 

PieM

Senior Member
@ PieM : je viens de relire la fonction tmr3 . apparemment c'est une très bonne façon, mais a la limite plus pour faire mon clignotement . Le timer 3 ne gène absolument en rien dans la vitesse de lecture des incrementation de l'encodeur si j'ai bien compris , car en tache de fond .

je vais d'abord essayé avec le timer 3, car votre solution m'oblige a tout revoir
C'est un timer interne indépendant
Tu peux aussi t'en servir pour ton test d'appui, puisque ce n'est pas simultané au clignotement.

sa config pour toi:
TMRSETUP 10110001 prescale à 1/8 donc incrémentation de timer3 toutes les 33.8 ms si tu es à 64MHz

donc pour 1s, timer3 = environ 30
et là tu peux mettre ton timer3 à 0 quand tu veux....
 

BESQUEUT

Senior Member
Pas certain que le lapin simplifie le code ....
Et pas de multitâche avec les X2.
Oui, c'est ce que j'ai écrit en #70 :
- si possible utiliser des interruptions, sinon etc... (le lapin étant le dernier recours parce qu'il peut traiter autant de séries d&#8217;événements que nécessaire, mais effectivement, il faut avoir l'état d'esprit... En terme de réactivité, ça reste excellent si c'est bien fait)

A mon sens, il y a 4 séries d&#8217;événements à gérer simultanément :
- la mise à jour de l'heure toutes les secondes,
- l'appui sur un bouton pendant plus de 3s,
- le clignotement de 2 chiffres si on est en mode de mise à jour (période environ 1s, avec un duty cycle genre 80/20 ou 90/10)
- la prise en compte de l'encodeur (à priori aussi souvent que possible)
 

dje8269

Senior Member
Pfffiou ca devient une véritable usine a gaz même avec timer3 . Mon tout premier test , pas au point du tout , a fracassé la réactivité du l'encodeur . il faut tester si on est place sur les minutes ou sur les secondes , ensuite on l'éteint un moment ( pour éteindre j'ai créer des chiffres vide) donc il faut affiché des chiffres vide . puis revenir regarder l'heure et rallumer . Tout ca en même je tourne l'encodeur .......
Ca me parait trés compliqué d'effectuer tout ca !

A la limite il faudrait schinté le clignotement tout pendant qu'on tourne l'encodeur . le fait de tourner l'encodeur nous ferais rentrer dans une autre boucle, et on en sortirais quand il n'y a plus de changement sur l'encodeur . Mais ça feras aussi une usine a gaz je pense .

La solution la plus fiable a mon avis c'est de souligné les chiffres . facile et rapide ( quoi que je dois refaire tout les chiffres en plus petit).

A mon sens, il y a 4 séries d&#8217;événements à gérer simultanément :
- la mise à jour de l'heure toutes les secondes,
- l'appui sur un bouton pendant plus de 3s,
- le clignotement de 2 chiffres si on est en mode de mise à jour (période environ 1s, avec un duty cycle genre 80/20 ou 90/10)
- la prise en compte de l'encodeur (à priori aussi souvent que possible)
La mise a l'heure toutes les secondes n'est pas à gérer avec le reste, car seulement quand le CàR est en route .
 
Top