Compte à rebours avec écran OLED en I2C

PieM · Oct 21, 2014

Les seules choses à gérer simultanément sont le codeur et son affichage clignotant ou pas.
Le temps d'appui sur Chgt est indépendant puisque par définition il va servir soit à un réglage , soit au lancement de décomptage.
La mise à l'heure n'est utile que pendant le décomptage.

Donc c'est la partie réglage (main) du programme qui est à optimiser. très confus actuellement ou on mélange test BP et test entrées codeur.

Le programme doit comporter
1 prog test du BP
un sous prog réglage très rapide
un sous prog décomptage

Mais si le programme n'a pas été modifié pour utiliser le timer normalement comme dit précédemment, c'est inutile d'aller plus loin!

dje8269 · Oct 21, 2014

Mais si le programme n'a pas été modifié pour utiliser le timer normalement comme dit précédemment, c'est inutile d'aller plus loin!

Si si j'ai modifié le programme de facon a utiliser le timer sans le remettre à zéro a chaque secondes . seulement au démarrage du chrono .

pour utiliser le timer normalement comme dit précédemment

Euh on parle du timer ou du timer3 ?

J'ai pas mis le programme modifié ?

PieM · Oct 21, 2014

dje8269 said:
Si si j'ai modifié le programme de facon a utiliser le timer sans le remettre à zéro a chaque secondes . seulement au démarrage du chrono .

Euh on parle du timer ou du timer3 ?

J'ai pas mis le programme modifié ?

je parle du timer pas du 3
pas vu de programme modifié .

dje8269 · Oct 21, 2014

Autant pour moi :

je sais pas si j'ai bien fais , mais j'ai quand même mis le timer à 0 au demarrage du CàR , pour avoir une "vrai" seconde quand on relache ! qu'en pensez vous est ce vraiment gênant ?
Le voici .

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 coord_A	= b2
Symbol coord_B	= b3
Symbol valeur	= b4

symbol seconde	= b10
symbol Dizsec 	= b11
symbol minute 	= b12
symbol Dizminu 	= b13

Symbol tempo1	= w9
symbol compteur	= w10		' Compteur général en seconde ///  minutes + secondes = x secondes
Symbol tempo	= w11		' Sert à comparer le timer
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_64,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
			' donc incrementation du timer totues les 0.2s . Il faut donc 5 impulsions secondaires pour faire une seconde ( 5x 0.2=

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


bit0 = InputA			'Initialisation des valeurs de l'encodeur 
bit1 = InputB			'Initialisation des valeurs de l'encodeur
Aprec=Aact 
compt_sec = 0
compt_min = 0


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

hi2cout 0x80,(0xAE,0x00,0x00,0x00,0x20,0x01,0x21,0,127,0x22,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
	  	
		  	tempo = timer		' On enregistre le timer en cours methode du lapin blanc	
	
	  		do loop while Chgt=0	' anti-rebond
	  		inc position		' change la position 0 ou 1
	  		
	  		tempo1 = timer - tempo	' On calcule le temps passé entre les deux evenements	
	  		
	  		if tempo1 >= 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
		
	loop while Aact=Aprec			'Attente d'un changement
           
if position = 1 then		' reglage du compteur des dizaine de secondes + secondes

	compt_sec= bit0 xor bit1 *2 + compt_sec-1  'formule magique de PieM
	Aprec=Aact 	  
	
	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,chiffre5,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,chiffre5
	
else		' reglage du compteur des dizaine de minutes + minutes

	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,chiffre5,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,chiffre5	
end if

loop

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


'#### Lancement du compte à rebours ####
Lancement:

tempo = timer

compteur = compt_min*60+compt_sec	' mise en seconde du compte a rebours
	
do
				
tempo1 = timer - tempo			' On calcule le temps passé entre les deux evenements

if tempo1 >=5 then

	dec compteur			' decrementation du compteur
	
	 if compteur = 0 then 		' Fin du compte à rebours
	 reset 
	 end if
	
	seconde = compteur//10		' Determination du chiffre des secondes
	coord_A= 98 :coord_B= 127:valeur= seconde
	gosub affichage			' MàJ du de l'affichage seconde
	
		if seconde = 9 then
			dizsec  = compteur//60/10
			coord_A= 67 :coord_B= 97:valeur = dizsec
			gosub affichage
			
				if dizsec = 5 then
					minute  = compteur/60//10
					coord_A= 30 :coord_B= 60 :valeur= minute
					gosub affichage
					
					if minute = 9 then
						dizminu = compteur/600
						coord_A= 0 :coord_B= 29 :valeur= dizminu
						gosub affichage
					
					endif
				end if
			
		end if

	tempo = timer

end if		

loop

'#### Affichage ####
Affichage:

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,coord_A,coord_B,0x22,0,3)	

	on valeur gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiffre5,chiffre6,chiffre7,chiffre8,chiffre9,chiffrevide
	 
return

PieM · Oct 21, 2014

C'est mieux, mais ça peut se simplifier.
La première partie main est à reprendre:
tester BP
soit on part sur du réglage, soit sur le décomptage.
la partie réglage comprends plusieurs fois les mêmes choses : il ne faut pas faire la discrimination if position au début, mais à la fin !
- tester Aact Aprec
- le compteur est incrémenté ou décrémenté, et ce n'est qu'à la fin pour l'affichage que l'on dit que ce sont des secondes ou des minutes en fonction de position.
et pour l'affichage, passer par le sous programme si ça ne fait pas perdre trop de temps.

Code:

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 inc

ça peut se faire avec : compt = compt//60

au lancement, on peut mettre timer à 0
donc il suffit de calculer consigne - timer pour avoir le temps restant.

de plus puisque dans cette phase, il n'y a aucune criticité de reactivité, pourquoi ne pas mettre tout l'affichage à jour chaque seconde ?

cela evite tous les tests if seconde, if dizsec, etc...

dje8269 · Oct 21, 2014

Je sais pas si j'ai tout saisi .

ça peut se faire avec : compt = compt//60

ca Ok ! J'ai une question , c'est l'expérience qui te fais dire ca, tu as deja vu ce probléme quelques part , ou alors ca t'est venu naturellement ? car c'est génial
et très astucieux

de plus puisque dans cette phase, il n'y a aucune criticité de reactivité, pourquoi ne pas mettre tout l'affichage à jour chaque seconde ?

Ben ma psychose , je voudrais pas trop le faire travaillé ce µC quand y as pas besoin . Plus sérieusement je sais pas, ça m'embête de faire quelques chose d'inutiles ; c'est gênant tu crois ?

Le reste j'a iaps trop compris .

Apres allumage , on attend, et donc on surveille deux choses :

1/ l'appui sur le BP : suivant la longueur de l'appui on fait tel ou tel action ( changement réglages ou lancement CàR )
2/ le mouvement de l'encodeur .

C'est bien ce que je fais ici, non ?

Code:

do
		bit0 = InputA			'sauvegarde inputA dans bit0
		bit1 = InputB			'sauvegarde inputB dans bit1 
	  
		  	If Chgt=0 then			' Appui sur le BP
		  	
			  	tempo = timer		' On enregistre le timer en cours methode du lapin blanc	
		
		  		do loop while Chgt=0	' anti-rebond
		  		inc position		' change la position 0 ou 1
		  		
		  		tempo1 = timer - tempo	' On calcule le temps passé entre les deux evenements	
		  		
		  		if tempo1 >= 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
		
	loop while Aact=Aprec			'Attente d'un changement

Bon je sais ce que je vais faire de ma soirée moi ..... Optimisation . merci encore pour tout ces conseils très précieux .

dje8269 · Oct 21, 2014

Code:
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

Click to expand...

ça peut se faire avec : compt = compt//60

Ben après réflexion et essai , j'y arrive pas !! tu es sur que ça peut fonctionner ? car on gère par deux chiffres le réglage avec l'encodeur ?
Donc quand on décrémente un 0 , la valeur devient 255 au lieu d'un 59 souhaité.

le compteur est incrémenté ou décrémenté, et ce n'est qu'à la fin pour l'affichage que l'on dit que ce sont des secondes ou des minutes en fonction de position.

Ben non en fait . car on doit déterminé si on s'occupe du couple sec/Dsec ou du couple min/Dmin , pour simplifié l'affichage et allez plus vite non ? .
Car en fait il y as deux compteur differents celui des secondes et celui des minutes

PieM · Oct 21, 2014

dje8269 said:
ca Ok ! J'ai une question , c'est l'expérience qui te fais dire ca, tu as deja vu ce probléme quelques part , ou alors ca t'est venu naturellement ? car c'est génial
et très astucieux

c'est ce que je fais quand j'utilise des codeurs. Dans tons cas pour eviter de passer de 15 à 0 quand tu arrive à 255, tu peux écrire: compteur = compteur max 240 //60 le résultat entre 240 et 255 restera à 0 avant de continuer sur 1...

Ben ma psychose , je voudrais pas trop le faire travaillé ce µC quand y as pas besoin . Plus sérieusement je sais pas, ça m'embête de faire quelques chose d'inutiles ; c'est gênant tu crois ?

C'est pour ça que tu le fais travailler à 64 MHz ?!! Oublie ta psychose...

Le reste j'a iaps trop compris .
Apres allumage , on attend, et donc on surveille deux choses :

1/ l'appui sur le BP : suivant la longueur de l'appui on fait tel ou tel action ( changement réglages ou lancement CàR )
2/ le mouvement de l'encodeur .

C'est bien ce que je fais ici, non ?

Ben non !

prg test BP:
selon appui,
on change position et on passe à un sprog réglage
ou on va dans un programme lancement du CaR

sp réglage:
c'est là que l'on teste InputA et InputB
on incrémente ou décrémente compteur
on affiche dans les minutes ou les secondes en fonction de position.

dje8269 · Oct 21, 2014

c'est ce que je fais quand j'utilise des codeurs. Dans tons cas pour eviter de passer de 15 à 0 quand tu arrive à 255, tu peux écrire: compteur = compteur max 240 //60 le résultat entre 240 et 255 restera à 0 avant de continuer sur 1...

Ok, je crois que la j'ai compris ; au final je me retrouve avec un trou de 15 crans ( si (y'en avait ) ; je préfère resté comme ça pour le coup . dans la pratique c'est plus facile d'utilisation je pense .

C'est pour ça que tu le fais travailler à 64 MHz

Non ca c'est pour la réactivité de l'encodeur .

Désolé d'insister mais c'est toujours pas bon

prg test BP:
selon appui,
on change position et on passe à un sprog réglage
ou on va dans un programme lancement du CaR

sp réglage:
c'est là que l'on teste InputA et InputB
on incrémente ou décrémente compteur
on affiche dans les minutes ou les secondes en fonction de position.

L'appui et le réglage doivent se trouver dans la même boucle obligatoirement . car on attend QUE ca . soit on appui sur le codeur soit on le tourne .
dans ton cas de figure quand on rentre dans le s/p réglage , comment on sort-on ? il faut bien surveiller le BP aussi ?

tu vois ou je veux en venir ? difficile à expliquer et je me doute encore plus a comprendre par forum !! déjà je trouve ton analyse des programmes remarquables

PieM · Oct 21, 2014

Ok, il y a une autre façon de voir la chose.
Mais dans ton cas je testerais les entrées A et B juste avant le test Aact=Aprec.

Et inutile de passer par une variable annexe pour le temps. Tu peux utiliser directement timer, et le mettre à 0 en début.

dje8269 · Oct 21, 2014

d'accord comme ca ?

main:
do

do
If Chgt=0 then ' Appui sur le BP

tempo = timer ' On enregistre le timer en cours methode du lapin blanc

do loop while Chgt=0 ' anti-rebond
inc position ' change la position 0 ou 1

tempo1 = timer - tempo ' On calcule le temps passé entre les deux evenements

if tempo1 >= 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

bit0 = InputA 'sauvegarde inputA dans bit0
bit1 = InputB 'sauvegarde inputB dans bit1

loop while Aact=Aprec 'Attente d'un changement

PieM · Oct 21, 2014

dje8269 said:
d'accord comme ca ?

Oui sauf :

Code:

do
 	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	' 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
			
bit0 = InputA			'sauvegarde inputA dans bit0
bit1 = InputB			'sauvegarde inputB dans bit1 
		
loop while Aact=Aprec			'Attente d'un changement

Puisque le timer n'est pas utilisé par ailleurs.

dje8269 · Oct 21, 2014

??!!??? tu me fais remettre timer = 0 ? alors que je devais l'enlever ? . c'est toi l'expert !

PieM · Oct 21, 2014

dje8269 said:
??!!??? tu me fais remettre timer = 0 ? alors que je devais l'enlever ? . c'est toi l'expert !

Tu melanges tout.

Dans cette phase, timer n'est pas utilisé. tu peux donc l'utiliser comme tu veux.
Ce qu'il ne faut pas faire c'est remettre timer à 0 quand on l'utilise en chrono, par cumul en ajoutant des secondes comme tu le faisais.
ta raz de timer se fait à n'importe quel moment sans lien avec la fin d'une seconde. Donc tu cumules n'importe quoi.

BESQUEUT · Oct 21, 2014

dje8269 said:
??!!??? tu me fais remettre timer = 0 ? alors que je devais l'enlever ? . c'est toi l'expert !

Voir #36 "si on souhaite ..."

Or là on ne souhaite pas puisqu'on est en train de faire la mise à jour
donc on peut...

dje8269 · Oct 21, 2014

D'accord , ce coup ci, c'est clair dans mon esprit . Si je vous l'ai pas encore dit, j'apprends vite , mais faut m'expliquer longtemps

Donc je vais faire comme ca !

ton logiciel que tu m'as proposé Besqueut serait tout simplement génial, si je savais l'utilisé . la tu deja testé ? j'arrive un sortir un code avec des chiffres au format 0x00 , mais en les affichant ca ne donne rien . malgré plein d'essai avec plein de config ;

C'est dommage car c'etait vraiment parfait .

dje8269 · Oct 22, 2014

Bonjour à tous ,

Ce matin je fais un grand ouf de soulagement . Hier soir jusqu'à 1h du mat a cherché comment faire un code avec le logiciel de Besqueut . Et ce matin oh miracle j'ai réussis !
Tout simplement génial ce logiciel . A conseillé a tous ceux qui veulent travaillé avec des oled . Ca vous fais gagné énormément de temps . Plus besoin de ce taper les caractères bit par bit .

J'ai mis une journée pour faire les chiffres de 0 à 9 . alors imaginez si je devais faire l'alphabet minuscule et majuscule, c'était une semaine qu'il me fallait .

Lien vers le téléchargement

dje8269 · Oct 22, 2014

Bonsoir à tous ,

Alors voila la dernière mouture du projet. Je pense qu'ont approchent du BUT , voir même on y est , sauf si j'ai fais des erreurs monumentales . Tous mes tests ont été positif .

Donc les dernières modifs :

- Ajout de la lumière , en hard , qui fais un effet plutôt sympa .
- Changement du style de caractère ( grâce au logiciel qui est super !)
- Ajout de petites flèches en haut et en bas, pour visualiser sur quel réglages on si situe ( soulignement trop compliqué, lourd et long a faire, tout comme le cadre j'expliquerai a la fin)
- Incrustation du compteur dans l'appui du bouton, pour lancer le chrono ; ainsi quand on laisse le doigt sur le BP , le chrono se lance automatiquement , pas besoin de relâcher , beaucoup plus pratique .
- mise d'un minimum pour le compteur < 10s ( correction d'un bug , en declenchant le CàR quand le compteur était à 0 , il passait à 65535 sans passé par le RESET.)
- Amélioration et simplification de l'affichage, plus correction et réduction légère de la taille de la police.

Mémoire utilisée = 1935 bytes out of 4096

1er partie du code :

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 coord_A	= b2
Symbol coord_B	= b3
Symbol valeur	= b4

symbol seconde	= b10
symbol Dizsec 	= b11
symbol minute 	= b12
symbol Dizminu 	= b13

Symbol tempo1	= w9
symbol compteur	= w10		' Compteur général en seconde ///  minutes + secondes = x secondes
Symbol tempo	= w11		' Sert à comparer le timer
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_64,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
			' donc incrementation du timer totues les 0.2s . Il faut donc 5 impulsions secondaires pour faire une seconde ( 5x 0.2=

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


bit0 = InputA			'Initialisation des valeurs de l'encodeur 
bit1 = InputB			'Initialisation des valeurs de l'encodeur
Aprec=Aact 
compt_sec = 0
compt_min = 0


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

hi2cout 0x80,(0xAE,0x00,0x00,0x00,0x20,0x01,0x21,0,127,0x22,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


for b5 = 0 to 25								' Effacement de l'écran
hi2cout 0x40,( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
next



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


hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,98,117,0x22,0,3)	' Affichage de 4 zeros au depart
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,72,91,0x22,0,3)
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,35,54,0x22,0,3)
gosub chiffre0
hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,9,28,0x22,0,3)
gosub chiffre0

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,29,34,0x22,0,3)	' Affichage des curseurs
hi2cout 0x40,(0x01, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xC0, _
0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80)

[video=dailymotion;x28fp0f]http://www.dailymotion.com/video/x28fp0f_compte-a-rebours-avec-picaxe_tech[/video]

lien vidéo plein écran

Pourquoi il est difficile de souligné ou d'entourré les chiffres ;

L'écran fonctionne sur 4 lignes ( appelez page ) , chacune d'elles fais 8 pixel de haut . un byte correspond donc à une colonne dans une page . chaque bit d'un byte allume un pixel ;
Les chiffres sans vouloir trop les reduires , prennent les 4 pages . donc si on voulais soulignés , il aurait fallu faire une série de chiffre , avec une barre en dessous , et une serie sans barre en dessous. très lourd .
J'aurais pus réduire encore les chiffres pour les affichés sur 3 pages seulement donc ( 3x8) 24 pixel de haut . Ainsi dans la page du bas ( 8 pixel de haut) j'aurais rajouté le soulignement . Vous l'aurez compris pour encadré c'est encore plus dur . car il faut faire une barre en haut et en bas .

J'avais pensé a une solution mais , je n'ai pas réussi a savoir si c'était faisable ou envisagé par les constructeur . Pour bien faire il aurait fallu , pouvoir ignorer certaine Bit . Ainsi on aurais pus ecrire sur le chiffre sans l'effacé ! .

PS : pour ceux qui utilise ce genre d'écran, le logiciel de Besqueut et plus que nécessaire, vraiment indispensable . si vous avez des quesstion sur l'utilisation de ce logiciel , n'hesitez pas a me demander , je me ferais un plaisir d'essayer de vous répondre ;

Voila , Comme d'hab , si vous avez des modifications , améliorations , suggestions etc .... n'hésitez surtout pas ;

dje8269 · Oct 22, 2014

2 iéme partie du code :

Code:

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

	do
		  	If Chgt=0 then		' Appui sur le BP
		  	
			  	timer = 0		' On enregistre le timer en cours methode du lapin blanc	
		
		  		do
		  		 
		  			if timer >= 10 then	' Si le temps est superieur a 10 on lance le chrono ( 10 correspond à 2 secondes)
		  			
			  			hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,29,34,0x22,0,3)	' On eteint les curseurs
						hi2cout 0x40,(_
							0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, _
					        	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
			  			hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,92,96,0x22,0,3)
						hi2cout 0x40,(_
							0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, _
					        	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
					        	
		  				gosub Lancement	' lance le compte à rebours
		  			
		  			end if
		  		
		  			
		  		loop while Chgt=0	' anti-rebond
		  		
		  		inc position		' change la position 0 ou 1
		  		
			  		if position = 1 then	' 	affichage des curseurs
			  		
			  			hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,92,96,0x22,0,3)
						hi2cout 0x40,(_
						0x01, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xC0, _
						0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80)
		        	
				        	hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,29,34,0x22,0,3)
						hi2cout 0x40,(_
						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, _
				        	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
	        	
	        			else
						hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,29,34,0x22,0,3)
						hi2cout 0x40,(_
						0x01, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xC0, _
				        	0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80)
						
						hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,92,96,0x22,0,3)
						hi2cout 0x40,(_
						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, _
				        	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
	        	
	        			end if
        			        			 		
		  				
		  	end if
		
			
		bit0 = InputA			'sauvegarde inputA dans bit0
		bit1 = InputB			'sauvegarde inputB dans bit1 
	  		
	loop while Aact=Aprec			'Attente d'un changement

 	       
if position = 1 then		' reglage du compteur des dizaine de secondes + secondes

	compt_sec= bit0 xor bit1 *2 + compt_sec-1  'formule magique de PieM
	Aprec=Aact 	  
	
	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,98,117,0x22,0,3)	' Mise a jour des secondes
			on seconde gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiffre5,chiffre6,chiffre7,chiffre8,chiffre9 
	
		hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,72,91,0x22,0,3)				' Affichage des dizaines de secondes
			on dizsec gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiffre5
			
		
		
	
else		' reglage du compteur des dizaine de minutes + minutes

	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,35,54,0x22,0,3)		' Affichage des minutes
			on minute gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiffre5,chiffre6,chiffre7,chiffre8,chiffre9
		
		hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,9,28,0x22,0,3)			' Affichage des dizaines de minutes
			on Dizminu gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiffre5
			
			
			
end if

loop

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


'#### Lancement du compte à rebours ####
Lancement:

tempo = timer

compteur = compt_min*60+compt_sec min 10	' mise en seconde du compte a rebours minumum 10 secondes
	
do
				
tempo1 = timer - tempo			' On calcule le temps passé entre les deux evenements

if tempo1 >=5 then			' Si 1 seconde est passée
	
	if compteur = 0 then 		' Fin du compte à rebours
	 	reset 
	end if
	 	
	dec compteur			' decrementation du compteur
		
	seconde = compteur//10		' Determination du chiffre des secondes
	coord_A= 98 :coord_B= 117:valeur= seconde
	gosub affichage			' MàJ du de l'affichage seconde
	
		if seconde = 9 then
			dizsec  = compteur//60/10
			coord_A= 72 :coord_B= 91:valeur = dizsec
			gosub affichage
			
				if dizsec = 5 then
					minute  = compteur/60//10
					coord_A= 35 :coord_B= 54 :valeur= minute
					gosub affichage
					
					if minute = 9 then
						dizminu = compteur/600
						coord_A= 9 :coord_B= 28 :valeur= dizminu
						gosub affichage
					
					endif
				end if
			
		end if

	tempo = timer

end if		

loop

'#### Affichage ####
Affichage:

hi2cout 0x80,(0x00,0x00,0x20,0x01,0x21,coord_A,coord_B,0x22,0,3)	

	on valeur gosub chiffre0,chiffre1,chiffre2,chiffre3,chiffre4,chiffre5,chiffre6,chiffre7,chiffre8,chiffre9
	 
return

dje8269 · Oct 22, 2014

3 iéme partie du code : ( j'ai peut être mis trop de commentaires

)

Code:

'######################################################
'############## chiffre N° 0 ##########################
'######################################################
chiffre0:
hi2cout 0x40,(_
0x00, 0xFE, 0x0F, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x03, _
0xFC, 0xFF, 0xFF, 0x07, 0xFE, 0x00, 0xE0, 0x0F, 0x1E, 0x00, 0x00, 0x0F, _
0x0F, 0x00, 0x00, 0x1E, 0x07, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x1C, _
0x07, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x1C, _
0x0F, 0x00, 0x00, 0x1E, 0x1E, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0xE0, 0x0F, _
0xFC, 0xFF, 0xFF, 0x07, 0xF8, 0xFF, 0xFF, 0x03, 0xE0, 0xFF, 0xFF, 0x00, _
0x00, 0xFE, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 1 ##########################
'######################################################
chiffre1:

hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, _
0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, _
0xF0, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, _
0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0x0F, _
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, _
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, _
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 2 ##########################
'######################################################
chiffre2:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x0E, 0xC0, 0x03, 0x80, 0x0F, 0xF0, 0x03, 0xE0, 0x0F, _
0xF8, 0x03, 0xF0, 0x0F, 0xFC, 0x03, 0xF8, 0x0F, 0x3E, 0x00, 0x7C, 0x0E, _
0x1E, 0x00, 0x3E, 0x0E, 0x0F, 0x00, 0x1E, 0x0E, 0x07, 0x00, 0x0F, 0x0E, _
0x07, 0x80, 0x07, 0x0E, 0x07, 0x80, 0x07, 0x0E, 0x07, 0xC0, 0x03, 0x0E, _
0x0F, 0xE0, 0x03, 0x0E, 0x0E, 0xF0, 0x01, 0x0E, 0x3E, 0xF8, 0x00, 0x0E, _
0xFC, 0x7F, 0x00, 0x0E, 0xFC, 0x3F, 0x00, 0x0E, 0xF8, 0x1F, 0x00, 0x0E, _
0xE0, 0x07, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 3 ##########################
'######################################################
chiffre3:
hi2cout 0x40,(_
0x00, 0x00, 0xF0, 0x00, 0xC0, 0x03, 0xF0, 0x03, 0xF0, 0x03, 0xF0, 0x07, _
0xF8, 0x03, 0xF0, 0x0F, 0xFC, 0x01, 0x80, 0x1F, 0x3C, 0x00, 0x00, 0x1E, _
0x1E, 0x00, 0x00, 0x3C, 0x0E, 0x00, 0x00, 0x38, 0x0E, 0xE0, 0x00, 0x38, _
0x0E, 0xE0, 0x00, 0x38, 0x0E, 0xE0, 0x00, 0x38, 0x0E, 0xE0, 0x00, 0x38, _
0x1E, 0xF0, 0x01, 0x3C, 0x3C, 0xF8, 0x01, 0x1E, 0xFC, 0xFF, 0x03, 0x1F, _
0xF8, 0x9F, 0xFF, 0x0F, 0xF0, 0x8F, 0xFF, 0x07, 0xC0, 0x07, 0xFF, 0x03, _
0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 4 ##########################
'######################################################
chiffre4:
hi2cout 0x40,(_
0x00, 0x00, 0x1E, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x1F, 0x00, _
0x00, 0xF0, 0x1F, 0x00, 0x00, 0xF8, 0x1C, 0x00, 0x00, 0x7C, 0x1C, 0x00, _
0x00, 0x1F, 0x1C, 0x00, 0x80, 0x0F, 0x1C, 0x00, 0xE0, 0x03, 0x1C, 0x00, _
0xF0, 0x01, 0x1C, 0x00, 0x7C, 0x00, 0x1C, 0x00, 0x3E, 0x00, 0x1C, 0x00, _
0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0x0F, _
0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x1C, 0x00, _
0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x1C, 0x00)

return

'######################################################
'############## chiffre N° 5 ##########################
'######################################################
chiffre5:
hi2cout 0x40,(_
0x00, 0x00, 0xE0, 0x00, 0x00, 0xFC, 0xE0, 0x03, 0xF8, 0xFF, 0xE0, 0x07, _
0xFF, 0xFF, 0xE0, 0x07, 0xFF, 0x7F, 0x80, 0x0F, 0x1F, 0x38, 0x00, 0x0E, _
0x0F, 0x38, 0x00, 0x1E, 0x0F, 0x1C, 0x00, 0x1C, 0x0F, 0x1C, 0x00, 0x1C, _
0x0F, 0x1C, 0x00, 0x1C, 0x0F, 0x1C, 0x00, 0x1C, 0x0F, 0x1C, 0x00, 0x1C, _
0x0F, 0x3C, 0x00, 0x1E, 0x0F, 0x78, 0x00, 0x0F, 0x0F, 0xF8, 0xC1, 0x0F, _
0x0F, 0xF0, 0xFF, 0x07, 0x0F, 0xE0, 0xFF, 0x03, 0x00, 0xC0, 0xFF, 0x01, _
0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 6 ##########################
'######################################################
chiffre6:
hi2cout 0x40,(_
0x00, 0xF8, 0x3F, 0x00, 0x80, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x07, _
0xF0, 0xFF, 0xFF, 0x0F, 0xF8, 0xE3, 0xC7, 0x0F, 0x7C, 0xF0, 0x00, 0x1E, _
0x3C, 0x70, 0x00, 0x1C, 0x1E, 0x70, 0x00, 0x3C, 0x0E, 0x38, 0x00, 0x38, _
0x0E, 0x38, 0x00, 0x38, 0x0E, 0x38, 0x00, 0x38, 0x0E, 0x38, 0x00, 0x38, _
0x0E, 0x38, 0x00, 0x38, 0x1E, 0x78, 0x00, 0x3C, 0x1C, 0xF0, 0x00, 0x1E, _
0x7C, 0xF0, 0x81, 0x1F, 0xF8, 0xE0, 0xFF, 0x0F, 0xF0, 0xE0, 0xFF, 0x07, _
0xE0, 0x80, 0xFF, 0x03, 0x00, 0x00, 0xFE, 0x00)
return

'######################################################
'############## chiffre N° 7 ##########################
'######################################################
chiffre7:
hi2cout 0x40,(_
0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, _
0x0F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x0E, 0x0F, 0x00, 0xE0, 0x0F, _
0x0F, 0x00, 0xFC, 0x0F, 0x0F, 0x80, 0xFF, 0x0F, 0x0F, 0xE0, 0xFF, 0x01, _
0x0F, 0xF0, 0x0F, 0x00, 0x0F, 0xFC, 0x01, 0x00, 0x0F, 0x7E, 0x00, 0x00, _
0x8F, 0x1F, 0x00, 0x00, 0xCF, 0x07, 0x00, 0x00, 0xEF, 0x03, 0x00, 0x00, _
0xFF, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, _
0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 8 ##########################
'######################################################
chiffre8:
hi2cout 0x40,(_
0x00, 0x00, 0xFC, 0x01, 0xE0, 0x07, 0xFE, 0x07, 0xF0, 0x0F, 0xFF, 0x0F, _
0xF8, 0x9F, 0xFF, 0x0F, 0xFC, 0xFF, 0x07, 0x1F, 0x3C, 0xF8, 0x03, 0x1E, _
0x1E, 0xF0, 0x01, 0x3C, 0x0E, 0xE0, 0x00, 0x38, 0x0E, 0xE0, 0x00, 0x38, _
0x0E, 0xE0, 0x00, 0x38, 0x0E, 0xE0, 0x00, 0x38, 0x0E, 0xE0, 0x00, 0x38, _
0x1E, 0xF0, 0x01, 0x3C, 0x3C, 0xF8, 0x03, 0x1E, 0xFC, 0xFF, 0x07, 0x1F, _
0xF8, 0x9F, 0xFF, 0x0F, 0xF0, 0x0F, 0xFF, 0x0F, 0xE0, 0x07, 0xFE, 0x07, _
0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00)

return

'######################################################
'############## chiffre N° 9 ##########################
'######################################################
chiffre9:
hi2cout 0x40,(_
0xC0, 0x1F, 0xC0, 0x00, 0xF0, 0x7F, 0xC0, 0x03, 0xF8, 0xFF, 0xC1, 0x07, _
0xFC, 0xFF, 0xC1, 0x0F, 0x7E, 0xE0, 0x03, 0x0F, 0x1E, 0xC0, 0x03, 0x1E, _
0x0F, 0x80, 0x07, 0x1E, 0x07, 0x00, 0x07, 0x1C, 0x07, 0x00, 0x07, 0x1C, _
0x07, 0x00, 0x07, 0x1C, 0x07, 0x00, 0x07, 0x1C, 0x07, 0x00, 0x07, 0x1C, _
0x0F, 0x80, 0x03, 0x1E, 0x0E, 0x80, 0x03, 0x0F, 0x1E, 0xC0, 0x83, 0x0F, _
0xFC, 0xF8, 0xF1, 0x07, 0xFC, 0xFF, 0xFF, 0x03, 0xF8, 0xFF, 0xFF, 0x01, _
0xE0, 0xFF, 0x7F, 0x00, 0x00, 0xFF, 0x07, 0x00)

return

BESQUEUT · Oct 22, 2014

Je n'aurais qu'un mot "BRAVO !"
Superbe réalisation. Le bouton qui s'éclaire quand on clique c'est classe (et pratique)
Réglage très fluide.
Et la solution des 2 petites flèches : excellente idée !

Pour info, sur mon OLED je peux faire des zones de 1 pixel de haut, donc je n'ai pas le problème. En prime, il y a des nuances de gris.

BESQUEUT · Oct 22, 2014

dje8269 said:
( j'ai peut être mis trop de commentaires )

Ça il n'y en a jamais trop, surtout s'ils sont pertinents.

dje8269 · Oct 22, 2014

Je n'aurais qu'un mot "BRAVO !"

Merci !

Et la solution des 2 petites flèches : excellente idée !

Oui les deux petites fléches sont intercalées entre les deux chiffres , j'ai hésité avec une barre completement a gauche et à droite , mais ca faisait moins sympa .

Pour info, sur mon OLED je peux faire des zones de 1 pixel de haut, donc je n'ai pas le problème. En prime, il y a des nuances de gris.

Tu aurais un lien sur ton afficheur ?

PieM · Oct 22, 2014

belle réalisation.
mais le principe de décomptage est bien compliqué !

inutile ici d'utiliser un lapin quelconque ...
en début tu mets timer à 0
ensuite
si timer //5 = 0 (une seconde est passée) alors
tu calcules compteur - timer / 5 ; c'est le temps à afficher en secondes. c'est aussi simple.

dje8269 · Oct 22, 2014

Merci pour tous encore une fois !

Avec toi PieM , tout parait tellement simple ! et pourtant je comprends pas tout ? ca me fais peur .

Bon pour la partie compte a rebours :

je met le timer à 0 , OK !

je vais modulo 5 sur la valeur du timer , a chaque fois que le modulo vaudrat 0 , c'est q'une seconde est passée , Ok !

Ca par contre je comprends pas ?

compteur - timer / 5

EDIT : PE ne veut pas prendre cette commande :

if timer//5 = 0 then

Re EDIT :
Du coup avec ta soluce je me retrouve avec quasiment la même chose ? y'a-t-il un reel avantage ou c'est juste une facon de faire plus academique ?

moi :

tempo = timer
do
tempo1 = timer - tempo
'if tempo1 >=5 then

toi:

timer = 0
do
tempo1 = timer//5
if tempo1 = 0 then

BESQUEUT · Oct 22, 2014

dje8269 said:
Tu aurais un lien sur ton afficheur ?

http://www.picaxeforum.co.uk/showthread.php?25814-Oled-96x96-Grove-OLE42178P
Mais au final, je pense que le votre ou celui là sont plus commodes si on n'a pas besoin des nuances de gris.

MGU · Oct 22, 2014

Bonjour,

C'est vraiment très beau...bravo!!!

Pour cette histoire de timer, il me semble que le problème est de faire un timer de 1 s à 64 MHz.
Il est plus facile de faire des 1/10 de secondes et 99 x 60 + 59 = 5999 s = 59990 dixièmes de s. En dessous de 65536, pas de problème...

Ou une fréquence de 64MHz pour les réglages et 16 MHz avec un timer de 1s pour le décompte.

Pour info, j'attends celui ci, avec le même driver:
http://www.ebay.fr/itm/0-96-I2C-IIC-Serie-128X64-OLED-LCD-LED-Daffichage-Display-Module-Pour-Arduino-/331346805199?pt=FR_YO_MaisonJardin_Bricolage_ElectroniqueComposants&hash=item4d25cf01cf

J'ai chargé ton programme dje, mais j'ai une erreur sur le hI2cout (le premier), je sais pas encore pourquoi...
Et encore BRAVO!

MM

dje8269 · Oct 23, 2014

Bonjour,

Merci Michel,
Pour le probléme hi2c_out le voici :
Un espace c'est glissé entre le chiffre , il faut écrire 0x22 au lieu de 0x02 2 , ce paramètre correspond au page qu'on utilise ici , de 0 à 3 . Si je veux écrire que sur la seulement sur la dernière page , on marquera 0x22,3,3 .

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)

Attention avec les "_" , un espace apres ce symbol provoque une erreur , je me suis fais avoir plusieur fois

Tu verras ces écrans sont magnifiques ; Et c'est vrai qu'une fois la configuration réussis , ca roule . Grâce au logiciel , les caractères ne sont plus un problèmes , même pour la création .

PieM · Oct 23, 2014

Pour cette histoire de timer, il me semble que le problème est de faire un timer de 1 s à 64 MHz.

Ce n'est pas possible de faire un timer d'une seconde avec une fréquence de plus de 16 MHz.

@ dje

la logique veut que le calcul du temps restant soit égal à une valeur de consigne - temps écoulé.
a tout instant le résultat est vrai.
Il faut éviter ton système de décomptage d'un compteur lorsque tu passe une seconde. Suppose que tu aies un programme un peu compliqué avec des interruptions par ex. Il suffit que tu aies une inter au moment du passage d'une seconde pour fiche ton calcul en l'air. Ta méthode qui consiste à décrémenter un compteur est dangereuse.

c'est pour cela qu'à partir du moment où ta base de temps est de 1/5 de seconde, il était plus judicieux de faire tous tes calculs avec cette unité, et ne transformer en secondes au dernier moment lors de l'affichage en utilisant un coef. Il n'y a qu'au moment de l'affichage qu'on a besoin de valeurs en secondes. C'est que je t'expliquais dans un post précédent.

et en utilisant une routine d'affichage type macro, la lecture programme s'aère beaucoup. (faudra t'y mettre à PE6 !!)

et pour moi timer modulo x ne sert qu'à définir simplement la fréquence de rafraichissement de l'affichage

compteur - (timer/5) parce que ton compteur est en secondes et ton timer en 1/5 s !
if timer//5 = 0 then : pas possible en picaxe! il faut faire le calcul avant

Mais tout ceci n'est que ma façon de voir. L'essentiel est que ton programme fonctionne selon ton besoin.
encore bravo.

dje8269 · Oct 23, 2014

Mais tout ceci n'est que ma façon de voir.

Certes , mais c'est la BONNE facon de voir .

Je viens de poser ton explication sur papier ! et je pense avoir bien compris ou tu voulais en venir .

Le fait de calculer le temps réel ecoulé est effectivement plus "pro" si je puis dire !

Dans mon programme effectivement c'est impossible ( car il n'y as rien entre le do-loop, a part la MàJ de l'affichage qui remet le timer a jour à la fin, et je n'ai pas d'intterruption) . MAis admettons qu'un programme plus complexe il se passe des choses , et/ou y'as des interruption .

il pourrait se passer disons 20 secondes . mon programme comprends qu'une seconde est passée ( certes c'est vrai) et decrementera d'une seconde, puis se mettra a jour ! .
Dans ta facon de voir les choses ; le compteur prendras en compte les 20 secondes passées et mettra le " vrai" temps a jour . donc il s'auteras des secondes!

Moi j'appelle ca de 'lexperience et la BONNE facon de faire . Un grand merci pour ce commentaire .
je vais de ce pas modifier mon programme pour faire a ta facon .

ps : peut tu me confirmer que mareflexion est la bonne, et est en correlation avec la tienne ?

MGU · Oct 23, 2014

dje8269 said:
il pourrait se passer disons 20 secondes . mon programme comprends qu'une seconde est passée ( certes c'est vrai) et decrementera d'une seconde, puis se mettra a jour ! .
Dans ta facon de voir les choses ; le compteur prendras en compte les 20 secondes passées et mettra le " vrai" temps a jour . donc il s'auteras des secondes!

Je pense que c'est ça.

Je suggérais une fréquence de 64MHz pour le réglage (cause réactivité) et un changement de fréquence à 16MHz (cause timer),pour l'affichage, avec un timer réglé à 1 s

Perso, je procède comme suit:

Code:

Do
..boucle attente, surveillance poussoir, etc...
If memotime <>timer then gosub affichage
.....
loop 


affichage:

procédure mise à jour

memotime= timer

return

Mais on peut faire autrement

MM

dje8269 · Oct 23, 2014

re moi ,

Bon je pense que j'ai saisi , et donc je pense aussi que ca ne peut pas bien fonctionner ( surtout d'apres mes essais lol ) . le résultat des essais m'indiquent une piste ;
Ou alors j'ai mal fais le code facon PieM :

Voila de quoi il en retourne ;

Code:

'#### Lancement du compte à rebours ####
Lancement:

compteur = compt_min*60+compt_sec min 10	' mise en seconde du compte a rebours minimum 10 secondes

timer = 0	' Reset du timer 0 pour partir sur une vrai seconde . RAPPEL le timer s'incremente toutes les 200ms

	
do	' boucle d'attente de MAJ
				
	T_ecoule = timer//5			' On calcule le temps passé depuis la derniere MaJ
	
		if T_ecoule =0 then			' Si 1 seconde est passée
			
			T_d'après = timer/5
			compteur = compteur - T_ecoule
			
			if compteur = 0 then 		' Fin du compte à rebours
			 	reset 
			end if
			 	
						
			seconde = compteur//10		' Determination du chiffre des secondes
			coord_A= 98 :coord_B= 117:valeur= seconde
			gosub affichage			' MàJ du de l'affichage seconde
			
				if seconde = 9 then
					dizsec  = compteur//60/10
					coord_A= 72 :coord_B= 91:valeur = dizsec
					gosub affichage
					
						if dizsec = 5 then
							minute  = compteur/60//10
							coord_A= 35 :coord_B= 54 :valeur= minute
							gosub affichage
							
								if minute = 9 then
									dizminu = compteur/600
									coord_A= 9 :coord_B= 28 :valeur= dizminu
									gosub affichage
								
								endif
						end if
					
				end if		
					
		end if		

loop

Le résultat fais des mises a jour n'importe quand et affiche n'importe quoi .

Je pense que le problème se situe avec la ligne

T_ecoule = timer//5
if T_ecoule =0 then

Car en fait , à la vitesse ou ça va , il est rare de tomber sur un résultat pile poil = 0 non ?

De plus au tout début je met le timer a 0, donc déjà au tout premier test , la condition est remplie .

timer = 0
do
T_ecoule = timer//5
if T_ecoule =0 then

?? qu'en pense tu ?

PieM · Oct 23, 2014

MGU said:
Je pense que c'est ça.

Je suggérais une fréquence de 64MHz pour le réglage (cause réactivité) et un changement de fréquence à 16MHz (cause timer),pour l'affichage, avec un timer réglé à 1 s

ce serait dans le cas présent, la meilleure solution je pense aussi.
En plus, inutile de faire cavaler le µC quand il n'y en a pas besoin. La seule restriction de ces changement de fréquence d'horloge réside dans les tâches de fond dépendante de la fréquence (genre pmw ou autres...). Mais ce n'est pas le cas ici. En outre il y a deux phases bien distinctes : le réglage et le décomptage.

@dje

ne change pas ton programme ! tu en fais un autre en // pour t'exercer si tu veux ...
éventuellement je te proposerai ma vision sous forme d'un programme (sous PE6

).

dje8269 · Oct 23, 2014

ne change pas ton programme ! tu en fais un autre en // pour t'exercer si tu veux ...

pas de problème j'ai toujours une sauvegarde . bon je vais rester sur ma facon , car la tienne me parait plus compliqué , mais plus " pro" . C'est vrai que cafonctionne tres bien, l'optimisation a tout prix , c'est pas encore de mon niveau ! Mais c'est vrai que j'aime bien partir sur de bonne base et surtout comprendre ce que je fais . Si c'est jsute pour recopié ce que vous me dites ca ne sert a rien .

Encore un fois un grand merci .

éventuellement je te proposerai ma vision sous forme d'un programme (sous PE6 ).

Volontiers si ça t"embête pas trop bien sur .

PieM · Oct 23, 2014

dje8269 said:
Le résultat fais des mises a jour n'importe quand et affiche n'importe quoi .

Normal, ton programme lui dit de faire n'importe quoi ...

dje8269 · Oct 23, 2014

Normal, ton programme lui dit de faire n'importe quoi ...

Lol , oui mais je n'arrive pas a comprendre pourquoi .

PieM · Oct 23, 2014

dje8269 said:
Lol , oui mais je n'arrive pas a comprendre pourquoi .

regarde: (mais pas testé hein!)

Code:

'#### Lancement du compte à rebours ####
Lancement:

compteur = compt_min*60+compt_sec min 10	' [COLOR="#FF0000"]ça , ça devrait être dans le s-prog reglage[/COLOR]
consigne = compteur * 5  ' pour être cohérents avec les unités du timer

timer = 0	' Reset du timer 0 pour partir sur une vrai seconde . RAPPEL le timer s'incremente toutes les 200ms
t_maj = 0	'pas nécessaire normalement
	
do	' boucle d'attente de MAJ
				
	T_restant = consigne - timer	' On calcule le temps restant
		if T_restant = 0 then 		' Fin du compte à rebours
			 reset 
		end if	
		
		if timer > t_maj  then
	'calcul mm:ss	*******************		
			seconde = T_restant//10		
			dizsec  = T_restant//60/10
			minute  = T_restant/60//10
			dizminu = T_restant/600
			
	'mise à jour affichage ****************		
			coord_A= 98 :coord_B= 117:valeur= seconde
			gosub affichage			
			
			coord_A= 72 :coord_B= 91:valeur = dizsec
			gosub affichage
								
			coord_A= 35 :coord_B= 54 :valeur= minute
			gosub affichage			
								
			coord_A= 9 :coord_B= 28 :valeur= dizminu
			gosub affichage
								
			t_maj = timer + 5
		endif	

loop

dje8269 · Oct 23, 2014

Alors un truc me rassure , c'est que ce n'est pas si simple que ca , en fait .

Donc en l'etat le programme fonctionnait bizarremnt une decremenation des fois de 5 des fois de 6 et des fois de 7 secondes ???? bizarre ; apres etude d eton code ; j'ai rajouter ceci ;

Code:

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


'#### Lancement du compte à rebours ####
Lancement:

compteur = compt_min*60+compt_sec min 10	' ça , ça devrait être dans le s-prog reglage
consigne = compteur * 5  ' pour être cohérents avec les unités du timer

timer = 0	' Reset du timer 0 pour partir sur une vrai seconde . RAPPEL le timer s'incremente toutes les 200ms
t_maj = 0	'pas nécessaire normalement
	
do	' boucle d'attente de MAJ
				
	T_restant = consigne - timer	' On calcule le temps restant
		if T_restant = 0 then 		' Fin du compte à rebours
			 reset 
		end if	
		
		if timer > t_maj  then
	'calcul mm:ss	*******************
			[COLOR="#FF0000"]T_restant = T_restant / 5	[/COLOR]	
			seconde = T_restant//10		
			dizsec  = T_restant//60/10
			minute  = T_restant/60//10
			dizminu = T_restant/600
			
	'mise à jour affichage ****************		
			coord_A= 98 :coord_B= 117:valeur= seconde
			gosub affichage			
			
			coord_A= 72 :coord_B= 91:valeur = dizsec
			gosub affichage
								
			coord_A= 35 :coord_B= 54 :valeur= minute
			gosub affichage			
								
			coord_A= 9 :coord_B= 28 :valeur= dizminu
			gosub affichage
								
			t_maj = timer +5
		endif	

loop

effectivement le temps restant était calculé avec la consigne qui a été multiplié par 5 . Il faut donc divisé par 5 avant la conversion pour l'affichage . Ce n'est rien de grave ;

Par contre après cette correction , le CàR décompte anormalement ou alors disons bizarrement ; Je pense que ton programme est trop précis lol . des fois il décompte deux secondes , des fois une . mais le temps reste toujours a peu prêt exact . J'ai mis un autre CàR a coté ( téléphone) . je pense que ton temps est juste mais les mAj ne se font pas au bon moment .

PieM · Oct 23, 2014

effectivement le temps restant était calculé avec la consigne qui a été multiplié par 5

effectivement. pas fait attention.

mets t_maj = timer +5 juste après le test if timer > t_maj

et tu peux essayer de compter directement en secondes (16MHz) comme le préconisait Michel...

dje8269 · Oct 23, 2014

Toujours pas ! L e resultat est identique , des fois il saute des secondes à l'affichage , Mais le temps est bon ! si je met une minute il arrivera en même temps qu'un autre CàR, sauf qu'il n'affiche pas les mêmes secondes .

Code:

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


'#### Lancement du compte à rebours ####
Lancement:

compteur = compt_min*60+compt_sec min 10	' ça , ça devrait être dans le s-prog reglage
consigne = compteur * 5  ' pour être cohérents avec les unités du timer

timer = 0	' Reset du timer 0 pour partir sur une vrai seconde . RAPPEL le timer s'incremente toutes les 200ms
t_maj = 0	'pas nécessaire normalement
	
do	' boucle d'attente de MAJ
				
	T_restant = consigne - timer	' On calcule le temps restant
		if T_restant = 0 then 		' Fin du compte à rebours
			 reset 
		end if	
		
		if timer > t_maj  then
		t_maj = timer +5
	'calcul mm:ss	*******************
			T_restant = T_restant / 5		
			seconde = T_restant//10		
			dizsec  = T_restant//60/10
			minute  = T_restant/60//10
			dizminu = T_restant/600
			
	'mise à jour affichage ****************		
			coord_A= 98 :coord_B= 117:valeur= seconde
			gosub affichage			
			
			coord_A= 72 :coord_B= 91:valeur = dizsec
			gosub affichage
								
			coord_A= 35 :coord_B= 54 :valeur= minute
			gosub affichage			
								
			coord_A= 9 :coord_B= 28 :valeur= dizminu
			gosub affichage
								
			endif	

loop

tu peux essayer de compter directement en secondes (16MHz) comme le préconisait Michel...

Oui je ferais ca ce soir .

Compte à rebours avec écran OLED en I2C

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member