[Projet] Horloge Qlocktwo faite maison

[invitea683cd67]

Il y a une petite chose que je ne comprend pas.
Pourquoi il y a un "x" entre midi et minuit?
-----

[invite68e98c84]

Non excuse, j'ai oublié le et quart, et demi ^^
Pour le dix heures

Désolé

[invitea683cd67]

Je pense que pour question d'esthétique.
Il serait mieux de mettre des lettres partout même s'ils ne sont pas éclairer.

[invite74e8de33]

Le « et », c'est pour « et quart » et « et demie ».

Le « X » après « MIDI », c'est pour faire le « DIX ».

Je pense que pour question d'esthétique.
Il serait mieux de mettre des lettres partout même s'ils ne sont pas éclairer.

Ce sera le cas ! Je n'ai pas mis toutes les lettres pour que ce soit plus lisible (déjà que vous avez du mal sans ^^).

[invite68e98c84]

C'est juste un plan des lettres utiles, bien sur qu'il faut mettre des lettres pour remplir les vides, espéce de guizmo ^^

[inviteea84cbe0]

Pourquoi ne pas conserver la disposition d'origine de l'horloge ?

[inviteb69b4ce8]

car il n'y as n'y midi n'y minuit !!!
on les rajoutent donc et on enlèvent le douze.
puis il faut tout réorganise !!!

[invited570aa25]

Voilà la nouvelle disposition des lettres.
Si un autiste ou un professionnel du boggle passait par ici pour nous confirmer qu'aucune insanité ne se cache là-dedans, ce serait bien aimable à lui :


D'ailleurs, stadros, pourquoi ne pas utiliser cette disposition, plutôt ?

A priori ça a l'air pas mal du tout effectivement !

[invite4ce2896a]

Bonjour,

Je sais pas si cette discutions continuera mais si oui, sachez qu'une nouvelle personne se joint à vous.

En effet, je viens de commencer à développer la mienne sur la base du tableau de monsieur moche.

Je compte gérer les lettres du tableau indépendamment afin de pouvoir par la suite m'en servir comme matrice (pour animation simple,...).

J'ai intégrer un RTC type PCF8583 pour la gestion de l'heure (pour le moment uniquement secondes/minutes/heures).

Par la suite je pense intégrer un système de mise à l'heure automatique sur la base du signe DCF77 et d'acquisition adéquate, une IHM pour pour gérer manuellement.monsieur moche

Je suis partie sur la base d'un PIC 18F4550 (mais changera certainement) pour la gestion, et je compte utilisé un registre à décalage(+latch) + un compteur johnson pour la gestion HARD des led.

Je tourne sous MikroC pour la compilation + ISIS7.4 et platine HARD pour la simu.

Voila mon bout de code qui je l'espère pourra un peu vous servir.

PS: Désolé pour le codage un peu hardcore ^^

#include "prepro.c"

#define debug   false
#define true            1
#define false           0




#define PORT_IN         0xFF
#define PORT_OUT        0x00
#define PIN_IN          1
#define PIN_OU          0
#define PCFaddrRd       0xA1
#define PCFaddrWr       0xA0
#define PCFaddrReg      0x00
#define PCFaddrParam    0x08
#define NOP asm{NOP}

#define FLAG_IDLE       0x00
#define FLAG_RTC_RD     0x01
#define FLAG_RTC_INIT   0x02
#define FLAG_RTC_WR     0x04
#define FLAG_RTC_INTR   0x08
#define FLAG_DISPLAY    0x10

#define ligne1 0
#define ligne2 1
#define ligne3 2
#define ligne4 3
#define ligne5 4
#define ligne6 5
#define ligne7 6
#define ligne8 7
#define ligne9 8

#define ledStateOn 1

const int il    = 0b11000000000;
const int est   = 0b00011100000;
const int onze  = 0b00000001111;

const int huit  = 0b11110000000;
const int trois = 0b00011111000;
const int sept  = 0b00000001111;

const int six   = 0b11100000000;
const int deux  = 0b00011110000;
const int cinq  = 0b00000001111;

const int une   = 0b11100000000;
const int neuf  = 0b00111100000;
const int quatre= 0b00000111111;

const int midi  = 0b11110000000;
const int dix   = 0b00111000000;
const int minuit= 0b00000111111;

const int heure = 0b01111100000;
const int heures= 0b01111110000;
const int et    = 0b00000000110;

const int moins = 0b11111000000;
const int le    = 0b00000011000;
const int mdix   = 0b00000000111;

const int vingt = 0b11111000000;
const int mcinq = 0b00000011110;
const int tirret= 0b00000100000;
const int vingCinq = vingt | mcinq | tirret;

const int quart = 0b01111100000;
const int demie = 0b00000011111;
/* LIAISONS I2C */
sbit SCL at RB1_bit;            // Horloge @ 100Khz
sbit SDA at RB0_bit;            // Donnée séries
/* LIAISONS REGISTRE A DECALAGE */
sbit rDta at RD4_bit;           // Donnée séries
sbit rClk at RD5_bit;           // Horloge
sbit rStb at RD6_bit;           // Standby mode
sbit rOe  at RD7_bit;           // Output enable
/* LIAISONS COMPTEUR */
sbit cClk at RD2_bit;           // Horloge
sbit cOe  at RD1_bit;           // Output enable


char PB_IN at LATB;
unsigned unsigned char PB_OUT at PORTB;
unsigned int matrice[9];
unsigned char INTi = 0;
unsigned char timechange = false;

struct times{
        char sec;
        char mns;
        char hrs;
        char mnt;               //0 = AM / 1 = PM
}now,nowm;




unsigned char flag =  FLAG_RTC_INIT;
/* FUNCTIONS 4 PCF */
void PCF_READ_TIME();
void PCF_WR_CONFIG(char adress, char config);
void unsetRtcFlag();

/* FUNTIONS 4 MATRICE */
void iniMatrice();
void razMatrice();
void updateMatrice();
void updateLine(char ligne, int entry);


void main() 
{
        #if(debug)
	now.sec = 30;
	now.mns = 30;
	now.hrs = 12;
	now.mnt = 0;
	
        nowm.sec = 20;
	nowm.mns = 40;
	nowm.hrs = 11;
	nowm.mnt = 0;
	#endif



        PORTD = 0x00;
        TRISD = PORT_OUT;
        LATD = 0x00;
        PORTD = 0b01010101;

        ADCON0 = 0x00; //        A/D         desactivé
        ADCON1 = 0x0F; //        NO A/D entry, all in TOR
        CMCON = 0x07;  //      Comparateur désactivé
        PB_IN = 0x00;  //      INIT du portB à 0
        TRISB = PORT_IN; //      Port B en INPUT
        PORTB = 0x00;
        
        IPEN_bit = 0; //      Pas d'interruption prioritaire
        RBPU_bit = 1; //      PORTB PULL'UP diseable
        INTEDG2_bit = 0; //      Actif sur front descandant
        INT2IP_bit = 0;
        INT2E_bit = 1;
        PEIE_bit = 1;
        GIE_bit = 1;  //      Activation des interruptions non masqué

        
        

 	razMatrice();
  	iniMatrice();
        Delay_ms(1000);
        for(;;)
        {
                switch(flag)
                {
                        case FLAG_RTC_INIT :
                        {
                        	I2C1_Init(100000);
                        	#if debug == 0
                                PCF_WR_CONFIG(PCFaddrReg,0b10000100);
                                PCF_WR_CONFIG(PCFaddrParam,0b11001001);
                                PCF_WR_CONFIG(PCFaddrReg,0b00000100);
				#endif
                                flag = FLAG_IDLE;
                                break;
                        }
                        case FLAG_RTC_RD :
                        {
                                unsetRtcFlag();
                                PCF_READ_TIME();
                                flag = FLAG_IDLE;
                                break;
                        }
                        case FLAG_RTC_INTR :
                        {
                                unsetRtcFlag();
                                flag = FLAG_IDLE;
                                break;
                        }
                        case FLAG_IDLE :
                        {
                                NOP;
                                break;
                        }
                }
        }
}

void PCF_READ_TIME()
{

	#if debug == 0
        I2C1_Start();
        I2C1_Wr(PCFaddrWr);             //Addresse du PCF8586
        I2C1_Wr(2);                     //Adresse de départ de lecture (seconde)
        I2C1_Repeated_Start();
        I2C1_Wr(PCFaddrRd);
        now.sec = Bcd2Dec(I2C1_Rd(1));
        now.mns = Bcd2Dec(I2C1_Rd(1));
        now.hrs = Bcd2Dec(I2C1_Rd(1));
        I2C1_Stop();
        #endif
	if(now.hrs > 12)
	{
	        now.hrs = now.hrs - 12;
	        now.mnt = 1;
	}else now.mnt = 0;
        if(now.sec != nowm.sec) {nowm.sec = now.sec; timeChange = true;}
        if(now.mns != nowm.mns) {nowm.mns = now.mns; timeChange = true;}
        if(now.hrs != nowm.hrs) {nowm.hrs = now.hrs; timeChange = true;}
        if(now.mnt != nowm.mnt) {nowm.mnt = now.mnt; timeChange = true;}
        if(timeChange)
        {
    		updateMatrice();
    		timeChange = 0;
        }
        flag = FLAG_IDLE;

}
void PCF_WR_CONFIG(char adress, char config)
{
        I2C1_Start();
        I2C1_Wr(PCFaddrWr);
        I2C1_Wr(adress);
        I2C1_Repeated_Start();
        I2C1_Wr(PCFaddrWr);
        I2C1_Wr(config);
        I2C1_Stop();
}

void unsetRtcFlag()
{
	#if debug == 0
        PCF_WR_CONFIG(PCFaddrReg,0b00000100);
        #endif
}

void iniMatrice()
{
   #if ledStateOn == 1
   matrice[ligne1] = il | est;
   #elif ledStateOn == 0
   matrice[ligne1] = ~(il | est);
   #endif
}
void razMatrice()
{
      unsigned char i;
      for(i=0;i<9;i++)
      {
         #if ledStateOn == 0
         matrice[i] = 0xFFFF;
         #elif ledStateOn == 1
         matrice[i] = 0x0000;
         #endif
      }
}

void updateLine(char ligne, int entry)
{
     #if ledStateOn == 1
     matrice[ligne] |= entry;
     #elif ledStateOn == 0
     matrice[ligne] &= ~(entry);
     #endif
}
/******************************************************************************/
void updateMatrice()
{
  if(nowm.mns<=32)
  {
      //Verif pour affichage de "heure" "heures" ou rien
      if(nowm.hrs == 1) updateLine(ligne6,heure);
      else if(nowm.hrs >1 && nowm.hrs != 12) updateLine(ligne6,heures);
      switch(nowm.hrs)
      {
           case 1 : updateLine(ligne4,une); break;
           case 2 : updateLine(ligne3,deux); break;
           case 3 : updateLine(ligne2,trois); break;
           case 4 : updateLine(ligne4,quatre); break;
           case 5 : updateLine(ligne3,cinq); break;
           case 6 : updateLine(ligne3,six); break;
           case 7 : updateLine(ligne2,sept); break;
           case 8 : updateLine(ligne2,huit); break;
           case 9 : updateLine(ligne4,neuf); break;
           case 10: updateLine(ligne5,dix); break;
           case 11: updateLine(ligne1,onze); break;
           case 12:
           {
                if(nowm.mnt == 0) updateLine(ligne5,midi);
                else updateLine(ligne5,minuit);
           }
      }
      if(nowm.mns > 2 && nowm.mns <= 7)        updateLine(ligne8,mcinq);
      else if(nowm.mns > 7 && nowm.mns <= 12)    updateLine(ligne7,mdix);
      else if(nowm.mns >12 && nowm.mns <= 17)    {updateLine(ligne9,quart);updateLine(ligne6,et);}
      else if(nowm.mns >17 && nowm.mns <= 22)    updateLine(ligne8,vingt);
      else if(nowm.mns >22 && nowm.mns <= 27)    {updateLine(ligne8,vingt);updateLine(ligne8,tirret);updateLine(ligne8,mcinq);}
      else {updateLine(ligne6,et); updateLine(ligne9,demie);}
  }else
  {
      //Verif pour affichage de "heure" "heures" ou rien
      if(nowm.hrs == 12) updateline(ligne6,heure);
      else if(nowm.hrs <12 && nowm.hrs != 11) updateLine(ligne6,heures);
      switch(nowm.hrs)
      {
           case 12 : updateLine(ligne4,une); break;
           case 1 : updateLine(ligne3,deux); break;
           case 2 : updateLine(ligne2,trois); break;
           case 3 : updateLine(ligne4,quatre); break;
           case 4 : updateLine(ligne3,cinq); break;
           case 5 : updateLine(ligne3,six); break;
           case 6 : updateLine(ligne2,sept); break;
           case 7 : updateLine(ligne2,huit); break;
           case 8 : updateLine(ligne4,neuf); break;
           case 9 : updateLine(ligne5,dix); break;
           case 10: updateLine(ligne1,onze); break;
           case 11:
           {
                if(nowm.mnt == 0) updateLine(ligne5,midi);
                else updateLine(ligne5,minuit);
           }
      }
      updateLine(ligne7,moins);
      if(nowm.mns > 32 && nowm.mns <= 37) {updateLine(ligne8,vingt);updateLine(ligne8,tirret);updateLine(ligne8,mcinq);}
      else if(nowm.mns > 37 && nowm.mns <= 42) {updateLine(ligne8,vingt);}
      else if(nowm.mns > 42 && nowm.mns <= 47) {updateLine(ligne7,le); updateLine(ligne9,quart);}
      else if(nowm.mns > 47 && nowm.mns <= 52) {updateLine(ligne7,mdix);}
      else if(nowm.mns > 52 && nowm.mns <= 57) {updateLine(ligne8,mcinq);}
  }
}
/******************************************************************************/







/*INTERRUPTIONS*/
void interrupt()
{
        if(INT2F_bit == 1)
        {
        INT2F_bit = 0;
                INTi++;
                if(INTi >= 5)
                {                        
                        flag = FLAG_RTC_RD;
                        INTi=0;

                }else flag = FLAG_RTC_INTR;

        }
}

Alors comment ça tourne actuellement?
Et bien le RTC et programmé pour générer une interruption tout les secondes.
Le programme principale initialise le tout, compte le nombre d'interruption, et arrivé à 5(pour le moment mais 60*5 plus tard) li les données du RTC et compare à celle en mémoire plus si besoin MAJ la matrice 9*11 .

[invite74e8de33]

Finalement, je n'aurai probablement pas le temps nécessaire pour m'investir dans ce projet.
Mais je suis ravi que les réflexions de départs aient pu servir à quelqu'un .
N'hésite pas à nous poster des photos une fois que ça commencera à avoir de la gueule !

[invite4ce2896a]

Finalement, je n'aurai probablement pas le temps nécessaire pour m'investir dans ce projet.
Mais je suis ravi que les réflexions de départs aient pu servir à quelqu'un .
N'hésite pas à nous poster des photos une fois que ça commencera à avoir de la gueule !

héhé merci

je viens de rajouter la gestion de 2 boutons en interruption, un pour min +=5 et l'autre pour heure +=1 (l'affichage ayant un pas de 5 min, inutile d'up les minutes de 1).

Me reste juste 2 3 trucs à peaufiner pour éviter de dépasser les 23H et les 59 minutes ^^ rien de méchant quoi.

Sinon pour des photos, oki pas de PB, en voila déjà une en pleine action ^^

@ bientot.

[invite74e8de33]

Ah ben ça va, t'es équipé !

(l'affichage ayant un pas de 5 min, inutile d'up les minutes de 1)

Ah non attention. Le Qlocktwo de base est équipé de 4 leds à chaque coin. Ces leds servent à préciser le nombre de minutes à ajouter à l'heure affichée en toutes lettres.
Par exemple, s'il est écrit « huit heures dix » et que 3 leds de coin sont allumées, il sera alors 8h13. Ainsi, on a bien une horloge précise à la minute.

Une horloge avec une précision de 5 minutes ne serait pas toujours très pratique au quotidien !

[invite74e8de33]

Autre chose :
Un moment dans le topic, j'avais posté un schéma d'implantation des leds (à l'échelle) un peu bancal. Je l'avais corrigé entre-temps sans le reposter.
Le voici : http://img15.imageshack.us/img15/178...tationleds.png

[invite4ce2896a]

Pas faut...

Je vais peut être revoir le système alors car pour le moment j'incrémente par impulsion, mais si je passe en pas de 1, avec le sytème actuelle, 60 impulsions c'est un peu long, je vais donc passer en temps de pression sur un algo logarithmique je pense et en +/- sur la pleine échelle de temps plutôt qu'en ++min / ++hrs.

Merci M.M

[invite4ce2896a]

J'ai commencé quelques tests "pratiques", notamment sur la gestion ligne et colonne et l'affichage.

Ci joint une photo du montage, simulant la gestion des lignes une à une (une seul led par ligne pour le test ^^) à la fréquence de 450Hz soit une image complètes généré en 20ms (50FPS).
La gestion des colonne et notamment la possibilité que les 11 leds soit allumé simultanément est sur l'autre plaque de test et est opérationnel.

Je pense mettre ma femme à la soudure ce soir pour faire un ptit PCB de 99 leds pour les tests avec pics ^^

Par contre j'ai tout de même encore l'impression de clignotement à 50Hz, surtout si je ne regarde pas directement les LEDS. A partir de 65Hz c'est parfait par contre.

[invite74e8de33]

J'aurais pas fait de balayage, personnellement.
J'aurais plutôt utilisé un CI de pilotage de LEDs (LED/display driver).

[invite4ce2896a]

Tu peux être plus explicite?
gérer les 99 leds directement depuis le µC et si nécessaire aciver les 99 leds simultanément?

[invite74e8de33]

Il existe des CI combinant registre à décalage et bascules D (j'en ai parlé un moment dans le topic) conçues pour piloter des LEDs.

Tu remplis ton registre (ça occupe une pinoche de ton µC), un petit coup d'horloge sur les bascules, et pouf, chaque LED reliée à une sortie mise à 0 s'éteignent et les autres s'allument. Et c'est fixe, pas de balayage, pas de scintillement.

Tu dois bien connaitre, non ?

[invite4ce2896a]

C'est bien ce que j'utilise.
2 registres à décalage+latch (74HC4094) pour envoyer en série les 11 bits pour 1 ligne combiné avec un compteur johnson pour l'activation des 9 lignes les unes après les autres!
Concernant la gestion de puissance, les lignes sont bufferisé par des BC338 et les colones par des ULN2803.

Il est clair que j'aurai pu utiliser des MIC5891 (ou équivalent) pour gérer la sérialisation et la puissance, mais cela ne change rien au fait qui faille gérer les ligne par balayage, ou alors je comprend vraiment pas ton système ^^

Je poste le schéma actuelle demain pour mieux comprendre

[Hearty]

Bonsoir,

Je suis avec grande attention ce projet très interessant.
O3K, te serait il possible de partager ton code actualisé
ainsi que la simulation ISIS?

Merci

[invite4ce2896a]

Bonsoir,

Je suis avec grande attention ce projet très intéressant.
O3K, te serait il possible de partager ton code actualisé
ainsi que la simulation ISIS?

Merci

Oui, aucun PB, j'envoie ça demain, là il ce fait tard ^^

[invite4ce2896a]

Comme convenu, voici le schéma ainsi que le programme (destiné pour PIC18F4550 mais le PIC changera très bientôt car sur dimensionné).

PS: désolé pour le prog mais il est un peut "barbare" ^^

[invited570aa25]

Je me réveille un peu et je vois que ça a bien avancé.

Après réflexion je pense que je vais rester sur l'idée de base de Qlocktwo pour la disposition des lettres (sauf que je rajoute toujours midi et minuit) comme celle ci :

http://www.zimagez.com/zimage/clock0.php#

J'ai une préférence pour avoir bien tous les mots bien séparés (donc pas de lettre commune).

Faut juste que je me motive à faire le schéma, mais ayant pas mal de boulot ça ne va pas être aisé.

[Hearty]

Bonjour,

J'avais complètement zappé ce fil,
Merci o3k!
Je vais étudier ce que tu as fait.

[invited570aa25]

Tiens je vais être chiant mais est-ce qu'une personne pourrait m'aider pour la partie "matrice LED" :

http://www.zimagez.com/zimage/horloge19.php

(le carré bleu à droite)

Je ne sais plus/pas comment calculer les LED et les résistance pour que tout tienne la route !!

Sachant que je pensais utiliser celles-ci : http://www.selectronic.fr/article.as...tier=10.6297-4

[invite4ce2896a]

Comment comptes tu gérer la partie puissance tout d'abord?

Utilises plutôt des registre à décalages avec latch (4049) car 30 pins du PIC pour ça... c'est un peu beacoup de pense ^^

Regarde le schéma 4 post au dessus (abclock.pdf) pour te donné des idées.

[invited570aa25]

Comment comptes tu gérer la partie puissance tout d'abord?

Utilises plutôt des registre à décalages avec latch (4049) car 30 pins du PIC pour ça... c'est un peu beacoup de pense ^^

Regarde le schéma 4 post au dessus (abclock.pdf) pour te donné des idées.

Oui ce n'est pas faux. J'aime bien l'idée de tout gérer à partir du µP perso, sans rien avoir d'autre à gérer derrière.

Qu'est-ce que tu appelles "puissance" ? L'éclairage ?

Pour moi ce serai l'alim 5v qui allumerai les leds, et le µP qui ne ferait que permettre cette alimentation ou non.
Je ne sais pas si je parle français là !

[invite4ce2896a]

Fais un petit compte rapide,

Multiplies le nombre de led max allumé par le courant nominale devant en traversé une (20ma pour celle que tu proposes).
Ensuite compares cette valeur à celle que ton PIC peu débiter au MAX pour chaque entrée / au total (section Electrical Characteristics vers la fin de la datasheet).

alors?

[invite4ce2896a]

Voici un lien vers un revendeur de plexiglas avec notamment la gamme TruLED, translucide uniquement sous la lumière donc idéale pour ce projet : LINK
Je pense commandé ce lot d'échantillon + les GS(AllAround) dans l'après midi.

Ces plaques combinées à un autocollant type "pochoirs" devrait être du meilleur effet ^^

[invited570aa25]

Fais un petit compte rapide,

Multiplies le nombre de led max allumé par le courant nominale devant en traversé une (20ma pour celle que tu proposes).
Ensuite compares cette valeur à celle que ton PIC peu débiter au MAX pour chaque entrée / au total (section Electrical Characteristics vers la fin de la datasheet).

alors?

C'est l'alimentation qui donnera des mA aux Led pour moi ? Le µP ne sert juste que d'interrupteur ?!


___________________+5V
____________________|
µP -> "Interrupteur" > LED
____________________|
__________________ MASSE