Journal lumineux à matrice de LED

[Hearty]

Bonsoir,

J'ai réalisé un journal lumineux à matrice de LED,
ayant pour coeur un PIC 16F876 le transfert vers les matrices
s'effectuant via 74hc595, actuellement 3, et pour le multiplexage des colonnes un 4017.
Codé sous MikroC, l'ensemble fonctionne parfaitement,
hormis le fait que pour le moment la gestion du courant sur les LEDs ne soit pas optimisé,
j'en suis à finaliser le code.

Par finaliser, j'entend que je souhaiterai, saisir mon texte de manière plus conviviale.
Actuellement je peux afficher le contenu d'un tableau,
celui-ci contient l'ensemble de mes caractères (ex: tableau nommé ASCII),
je pourrai n'afficher que les caractères de la phrase désirée,
mais je préfèrerai, utiliser une variable du genre:
MonTxt="Hello World";

Et que celle-ci extrait les caractères équivalents dans le tableau "ASCII",
puis par la suite eventuellement effectuer la saisie via RS232,
mais déjà la mettre sous forme de variable plus conviviale serait très bien .

Et c'est là que je bloque, et que votre aide me serait utile.

J'ai essayé de retourner le problème dans tous les sens,
mais je n'arrive pas à obtenir ce que je désire, voilà quelques semaines
que je tourne en rond sans voir poindre la moindre lumière.

J'ai mis sur mon blog le schéma et le code correspondant à ma situation actuelle
je vous invite à y jeter un coup d'oeil afin de voir comment j'ai procédé.



NB:Je précise que je suis débutant sur les PIC et leur programmation.
Il y a peu de temps encore, la réalisation d'un tel montage me semblait être une prouesse impossible pour moi...
-----

[invite4ce2896a]

Un truc du genre peut être, sachant qu'une "phrase" n'est qu'un tableau de plusieurs caractères.
Pour le +0x20 par contre je suis pas sur mais il me semble qu'il faille ajouter ceci pour avoir la correspondance ASCII, a vérifier, et désolé mais là gododo ^^

char phrase[] = "Hello Word";
char ASCIIlettre[];
char i;

for(i=0;i<strlen(phrase);i++)
{
     ASCIIlettre = phrase[i] + 0x20;
}

PS: la fonction strlen() se trouve dans la library STRING il me semble. et retourne le nombre d'entrée d'un tableau.

[Hearty]

Bonsoir,

Actuellement je tournais avec quelques essais
de ce type, sans résultat encore,
mais effectivement le strlen en fait parti

char txt[]="Bonjour";
chrmax=strlen(txt);
// je passe quelques lignes intermédiaires
for(n=0;n<=chrmax+8;n++){

BufferTxt[chrmax*8]= &font[(txt[n-32])*i];
}

j'ai essayé mille et une combinaisons à tel point que
cela tournait au grand n'importe quoi avec la fatigue.

Je vais essayer ta proposition.

Merci de ton intervention,

PS: je regardais justement ton intervention dans le projet d'horloge design

[Hearty]

Bonjour,

Hélas cela ne donne rien,
j'ai encore une fois passé la nuit à tester mille et une combinaison
et j'ai toujours comme affichage des écritures de goa'uld...

Je suis persuadé que réponse est toute bête et que je tourne
à coté depuis des semaines, mais pour le moment
je reste aveugle à sa lumière.

[A voir en vidéo sur Futura]

[vincent66]

Bonjour,
Je ne suis pas très versé dans le C, je préfère l'assembleur, mais si j'ai bien compris tu as des difficultés à définir quelles leds doivent être allumées ou éteintes dans la matrice en fonction du code de caractère à afficher..?
Dans les premiers affichages crt on utilisait une eeprom adressée à partir du code ascii du caractère.
Courage !
Vincent

[Hearty]

Vincent, merci

à moins de faire erreur, c'est ce que je tente de faire,
sauf que la table n'est pour le moment pas en eeprom.

La table crée, reprend l'ordre du code standart ASCII,
et je tente par le biais d'une variable contenant ma chaine
à afficher, d'y faire appel.

Mais je n'y arrive pas, ce qui me semblait relativement
simple, m'apparait comme insurmontable sur le coup.

Pourtant j'arrive très bien à afficher les caractères
de la table.

j'en perd mon latin...

[invite29971eb1]

Attention, sur une table ASCII, les caractères imprimables ne commencent qu'à partir de 32 donc si tu veux lire dans ton tableau la séquence correspondant à la lettre "A", il faut soustraire 32 à la valeur de ton caractère.

Par exemple, si ta chaine est "ABCDEF",
chaine[1] va renvoyer le caractère 'A' soit 65 en décimal et tu iras chercher la mauvaise valeur dans le tableau. Pour avoir le caractère correspondant, il faudra que tu ailles le chercher à (chaine[1]-32).

D'ailleurs, il y a 3 espaces dans ton tableau ASCII, tu peux supprimer les 2 premiers, sinon tu auras encore une erreur

[Hearty]

Ftorama, merci d'intervenir

Effectivement, la table doit être soustraite de 32,
comme tu peux le constater plus haut, où je parle de quelques tests effectués, je soustrait bien 32 pour faire correspondre les caractères de ma variable texte à celle du tableau ASCII.

Quant au tableau que tu vois sur le code du blog, il est légèrement modifié pour l'affichage du tableau en direct, celui que j'utilise pour afficher la variable texte, correspond parfaitement à celui du standard ASCII.

Cela dit, si le problème se situait a ce niveau, je n'aurais qu'un décallage de caractère, et non du "goa'uld" à l'affichage.
Je veux dire qu'il resterait une cohérence dans l'affichage des caractères.

[invite29971eb1]

Bon,

je suppose que tu parles de ça:

char txt[]="Bonjour";
chrmax=strlen(txt);
// je passe quelques lignes intermédiaires
for(n=0;n<=chrmax+8;n++){

BufferTxt[chrmax*8]= &font[(txt[n-32])*i];

}

Déja il faudrait savoir ce que sont BufferTxt et i. Ton bout de programme n'est pas clair....

Rien qu'avec txt[n-32], tu es en dehors de la taille de ton tableau....erreur
Ensuite, BufferTxt[chrmax*8], chrmax est uns constante, donc tu écris toutes les données au même endroit et finalement il ne reste que la drnière...seconde erreur.

Respire un grand coup, réfléchis tranquillement à ce que tu veux faire, écris-le en français et ensuite, traduis-le en C.....

[Hearty]

Bonsoir,

Tu as parfaitement raison, je vais faire un break,
deux semaines en continu nuit et jour dessus, je sature et fatigue,
et cela n'aide pas à raisonner convenablement.

Le bout de code que tu vois, est juste l'aboutissement
de plusieurs jours de traque intensive, à tel point
que j'en étais arrivé a testé tout et n'importe quoi.

En premier ce qui me semblait logique,
puis à force la manière empirique, par élimination, combinaison

+i, +n, *, &, bref, n'importe quoi...

Actuellement, j'en suis là, j'ai un défilement de n'importe quoi

void MonTxt()
{

  char txt[]="Bonjour le monde";
 portc=0;

  chrmax=strlen(txt);
if(rafraichir>=10){
if (vitesse>=7000){  // vitesse de défilement
              dat++; // scrolling caractères
              vitesse=0;

            }

                    rafraichir=0;
                    RB0_bit=1;       // d'impulsion de l'entrée clock
                    RB0_bit=0;       // du 4017

             if(i>=8)           // compteur sur la totalité des octets du tableau
              {
                i=0;
                 RB1_bit=1;     // RAZ clock 4017
                 RB1_bit=0;
                 }  // fin de If
                     i++;  
              for(n=0;n<chrmax;n++){

              BufferTxt[n]=txt[(n-32)+i];
               }

              HC595_0=BufferTxt[i+dat];    // données sur le premier 595
              HC595_1=BufferTxt[(i+8)+dat];   // données sur le second 595
              HC595_2=BufferTxt[(i+16)+dat];   // données sur le troisième 595
              send_data(HC595_0,HC595_1,HC595_2);   // envoie les données à afficher
              Delay_ms(1);

                          } // fin de If

}

Je vais proposer au colonel O'neil un afficheur en Goa'uld

[invite7a49d0d5]

Salut Hearty ;O]

et sympa ton site ;O]

pour le défilement, un truc que tu dis pas (où que j'ai pas vu),
c'est si tu veux un défilement colonnes/colonnes (pas = 1)
ou caractère/caractère (pas = 8)... ou variable ;O]

pour MikroC, si tu déclares MonTxt en tableau
tu peux ensuite accéder à chaque caractères via
ci-celui (MonTxt[0]="H"...)... donc son code ASCII...

je continue à regarder...
vede
;O]
_____________
...

ps :
je confirme, après s'être acharné,
il faut parfois laisser tomber quelques
jours pour que cela (re)devienne plus clair...
;O]

.

[Hearty]

Vede content de te voir
merci,

Le défilement se fait au pas de 1 colonne.
Actuellement, le code qui est affiché sur le site,
fonctionne correctement et comme je le désirais,

Afin d'apporter plus de convivialité à la saisie,
je veux passer le texte par une variable,
je pensais, pour être honnête, que j'allais faire cela
dans la minute, le plus dur étant accompli...

Mais que nenni!

j'ai également pensé que faire appel à une chaine de texte
qui n'était finalement qu'un tableau pour lire le contenu d'un autre
tableau allait de soi, mais je m'aperçois que non, en tout cas je ne sais pas faire.

[invite7a49d0d5]

re ;O]

(...)
j'ai également pensé que faire appel à une chaine de texte
qui n'était finalement qu'un tableau pour lire le contenu d'un autre
tableau allait de soi, mais je m'aperçois que non, en tout cas je ne sais pas faire.

ben moi aussi je verrais ça comme ça...
je cogite un peu et vous tiens au jus...
d'ici demain soir...

[invite7a49d0d5]

Salut Hearty,

bon ben j'ai pas vraiment eu le temps de me pencher sur le code...
j'ai commencé à y rèfléchir sans trop avancer...
car j'ai la tête assez prise en ce moment...

faut commencer par un tableau, contenant les caractères de la phrase...
ça c'est sur ;O]

bon je continue à y cogiter...
et on se tiens au jus (moi sous 48h max)...
vede
;O]
_________
...

[Hearty]

Bonsoir,

Ok Vede, merci de ton attention,
je continu de mon coté à tenter d'avancer
sur le problème, je compulse sur le net
tout ce qui peut m'aider à comprendre ce qui m'echappe.

Et comme dit plus haut, j'ai repris mon papier et mon crayon
pour reposer à plat le tout.

Déjà, je me suis aperçu que je partais tellement vers
un grand n'importe quoi que j'en avais oublié
de faire appel à mon tableau ASCII, donc evidemment
j'aurais pu finir mes jours sur le problème vu sous cet angle..

On se tient au courant

[invite7a49d0d5]

re ;O]

oué c'est quand même "complexe"...
faut un papier, un crayon, et pas la tête prise...
mais ça va s'arranger ;O]

on se tiens au jus...
;O]

[invite7a49d0d5]

Salut Hearty ;O]

bon ben j'ai galéré à vouloir partir de ton début de code...
donc je suis reparti de "zéro"... cad 3 lettres fixes...
ce qui m'a fait apparaître que la solution la plus simple
sera de stocker le message dans l'EEprom du PIC...
peut-être même la meilleur solution...

si tu peux tester le code ci-dessous qui doit afficher "EFG"...
voir si je suis sur la bonne voie, cad réussit à mettre les lettres
dans un tableau (lettres qu'il faudra stocker/récupérer dans l'EEprom)...

tiens nous au jus,
vede
;O]
___________
...

#define Latch PORTC.F6

// Tableau de caractères sur 8 bits installés en ROM

const unsigned short ASCII[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00,  // Code pour char !
        0x00, 0x24, 0x7E, 0x24, 0x24, 0x7E, 0x24, 0x00,  // Code pour char #
        0x00, 0x26, 0x49, 0x49, 0xFF, 0x49, 0x32, 0x00,  // Code pour char $
        0x00, 0x46, 0x26, 0x10, 0x08, 0x64, 0x62, 0x00,  // Code pour char %
        0x00, 0x70, 0x8E, 0x89, 0x99, 0x76, 0xC0, 0x00,  // Code pour char &
        0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char '
        0x00, 0x7E, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char (
        0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x7E, 0x00,  // Code pour char )
        0x00, 0x00, 0x0A, 0x04, 0x0A, 0x00, 0x00, 0x00,  // Code pour char *
        0x00, 0x10, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x00,  // Code pour char +
        0x00, 0x00, 0x00, 0x80, 0x60, 0x00, 0x00, 0x00,  // Code pour char ,
        0x00, 0x00, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00,  // Code pour char -
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char .
        0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00,  // Code pour char /
        0x00, 0x7E, 0xC1, 0xB1, 0x8D, 0x83, 0x7E, 0x00,  // Code pour char 0
        0x00, 0x04, 0x02, 0x01, 0xFF, 0x00, 0x00, 0x00,  // Code pour char 1
        0x00, 0xE6, 0x91, 0x91, 0x89, 0x89, 0x86, 0x00,  // Code pour char 2
        0x00, 0x42, 0x81, 0x89, 0x89, 0x89, 0x76, 0x00,  // Code pour char 3
        0x00, 0x30, 0x28, 0x24, 0x22, 0xFF, 0x20, 0x00,  // Code pour char 4
        0x00, 0x4F, 0x89, 0x89, 0x89, 0x89, 0x71, 0x00,  // Code pour char 5
        0x00, 0x7E, 0x89, 0x89, 0x89, 0x89, 0x72, 0x00,  // Code pour char 6
        0x00, 0x01, 0x01, 0xF1, 0x09, 0x05, 0x03, 0x00,  // Code pour char 7
        0x00, 0x76, 0x89, 0x89, 0x89, 0x89, 0x76, 0x00,  // Code pour char 8
        0x00, 0x4E, 0x91, 0x91, 0x91, 0x91, 0x7E, 0x00,  // Code pour char 9
        0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00,  // Code pour char :
        0x00, 0x00, 0x80, 0x68, 0x00, 0x00, 0x00, 0x00,  // Code pour char ;
        0x00, 0x00, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00,  // Code pour char <
        0x00, 0x00, 0x28, 0x28, 0x28, 0x28, 0x00, 0x00,  // Code pour char =
        0x00, 0x00, 0x00, 0x44, 0x28, 0x10, 0x00, 0x00,  // Code pour char >
        0x00, 0x06, 0x01, 0xB1, 0x09, 0x09, 0x06, 0x00,  // Code pour char ?
        0x00, 0x7E, 0x99, 0xA5, 0xA5, 0xB9, 0x5E, 0x00,  // Code pour char @
        0x00, 0xE0, 0x1C, 0x13, 0x13, 0x1C, 0xE0, 0x00,  // Code pour char A
        0x00, 0xFF, 0x89, 0x89, 0x89, 0x8E, 0x70, 0x00,  // Code pour char B
        0x00, 0x7E, 0x81, 0x81, 0x81, 0x81, 0x42, 0x00,  // Code pour char C
        0x00, 0xFF, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00,  // Code pour char D
        0x00, 0xFF, 0x89, 0x89, 0x89, 0x81, 0x81, 0x00,  // Code pour char E
        0x00, 0xFF, 0x09, 0x09, 0x09, 0x01, 0x01, 0x00,  // Code pour char F
        0x00, 0x7E, 0x81, 0x91, 0x91, 0x51, 0xF2, 0x00,  // Code pour char G
        0x00, 0xFF, 0x08, 0x08, 0x08, 0x08, 0xFF, 0x00,  // Code pour char H
        0x00, 0x00, 0x81, 0xFF, 0x81, 0x00, 0x00, 0x00,  // Code pour char I
        0x00, 0x60, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x00,  // Code pour char J
        0x00, 0xFF, 0x08, 0x18, 0x24, 0x42, 0x81, 0x00,  // Code pour char K
        0x00, 0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00,  // Code pour char L
        0x00, 0xFF, 0x02, 0x0C, 0x0C, 0x02, 0xFF, 0x00,  // Code pour char M
        0x00, 0xFF, 0x03, 0x0C, 0x30, 0xC0, 0xFF, 0x00,  // Code pour char N
        0x00, 0x7E, 0x81, 0x81, 0x81, 0x81, 0x7E, 0x00,  // Code pour char O
        0x00, 0xFF, 0x11, 0x11, 0x11, 0x11, 0x0E, 0x00,  // Code pour char P
        0x00, 0x7E, 0x81, 0x81, 0xA1, 0x41, 0xBE, 0x00,  // Code pour char Q
        0x00, 0xFF, 0x09, 0x09, 0x09, 0x39, 0xC6, 0x00,  // Code pour char R
        0x00, 0x46, 0x89, 0x89, 0x89, 0x89, 0x72, 0x00,  // Code pour char S
        0x00, 0x00, 0x01, 0x01, 0xFF, 0x01, 0x01, 0x00,  // Code pour char T
        0x00, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x00,  // Code pour char U
        0x00, 0x0F, 0x30, 0xC0, 0xC0, 0x30, 0x0F, 0x00,  // Code pour char V
        0x00, 0x7F, 0x80, 0x70, 0x70, 0x80, 0x7F, 0x00,  // Code pour char W
        0x00, 0x07, 0x08, 0xF0, 0xF0, 0x08, 0x07, 0x00,  // Code pour char Y
        0x00, 0xC1, 0xA1, 0x91, 0x89, 0x85, 0x83, 0x00,  // Code pour char Z
        0x00, 0xFF, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char [
        0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00,  // Code pour char BackSlash
        0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0xFF, 0x00,  // Code pour char ]
        0x00, 0x00, 0x04, 0x02, 0x02, 0x04, 0x00, 0x00,  // Code pour char ^
        0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00,  // Code pour char _
        0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,  // Code pour char `
        0x00, 0x00, 0x20, 0x54, 0x54, 0x78, 0x00, 0x00,  // Code pour char a
        0x00, 0x00, 0x7E, 0x48, 0x48, 0x30, 0x00, 0x00,  // Code pour char b
        0x00, 0x00, 0x38, 0x44, 0x44, 0x28, 0x00, 0x00,  // Code pour char c
        0x00, 0x00, 0x30, 0x48, 0x48, 0x7E, 0x00, 0x00,  // Code pour char d
        0x00, 0x00, 0x38, 0x54, 0x54, 0x58, 0x00, 0x00,  // Code pour char e
        0x00, 0x00, 0x7C, 0x0A, 0x0A, 0x02, 0x00, 0x00,  // Code pour char f
        0x00, 0x00, 0x18, 0xA4, 0xA8, 0x7C, 0x00, 0x00,  // Code pour char g
        0x00, 0x00, 0x7E, 0x08, 0x08, 0x70, 0x00, 0x00,  // Code pour char h
        0x00, 0x00, 0x00, 0x7A, 0x00, 0x00, 0x00, 0x00,  // Code pour char i
        0x00, 0x00, 0x80, 0x80, 0x7A, 0x00, 0x00, 0x00,  // Code pour char j
        0x00, 0x00, 0x7E, 0x10, 0x28, 0x40, 0x00, 0x00,  // Code pour char k
        0x00, 0x00, 0x00, 0x7E, 0x40, 0x00, 0x00, 0x00,  // Code pour char l
        0x00, 0x7C, 0x08, 0x04, 0x78, 0x04, 0x78, 0x00,  // Code pour char m
        0x00, 0x00, 0x7C, 0x08, 0x04, 0x78, 0x00, 0x00,  // Code pour char n
        0x00, 0x00, 0x38, 0x44, 0x44, 0x38, 0x00, 0x00,  // Code pour char o
        0x00, 0x00, 0xFC, 0x28, 0x24, 0x18, 0x00, 0x00,  // Code pour char p
        0x00, 0x00, 0x18, 0x24, 0x28, 0xFC, 0x00, 0x00,  // Code pour char q
        0x00, 0x00, 0x7C, 0x08, 0x04, 0x08, 0x00, 0x00,  // Code pour char r
        0x00, 0x00, 0x08, 0x54, 0x54, 0x20, 0x00, 0x00,  // Code pour char s
        0x00, 0x00, 0x3E, 0x48, 0x40, 0x00, 0x00, 0x00,  // Code pour char t
        0x00, 0x00, 0x3C, 0x40, 0x40, 0x3C, 0x00, 0x00,  // Code pour char u
        0x00, 0x00, 0x1C, 0x60, 0x60, 0x1C, 0x00, 0x00,  // Code pour char v
        0x00, 0x3C, 0x40, 0x70, 0x70, 0x40, 0x3C, 0x00,  // Code pour char w
        0x00, 0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00, 0x00,  // Code pour char x
        0x00, 0x00, 0x0C, 0x90, 0x90, 0x7C, 0x00, 0x00,  // Code pour char y
        0x00, 0x00, 0x64, 0x54, 0x54, 0x4C, 0x00, 0x00,  // Code pour char z
        0x00, 0x00, 0x08, 0x76, 0x81, 0x00, 0x00, 0x00,  // Code pour char {
        0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00,  // Code pour char |
        0x00, 0x00, 0x00, 0x81, 0x76, 0x08, 0x00, 0x00,  // Code pour char }
        0x00, 0x00, 0x10, 0x08, 0x10, 0x08, 0x00, 0x00,  // Code pour char ~    94 lignes
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0xFF, 0x08, 0x08, 0x08, 0x08, 0xFF, 0x00,  // Code pour char H
        0x00, 0xFF, 0x89, 0x89, 0x89, 0x81, 0x81, 0x00,  // Code pour char E
        0x00, 0xE0, 0x1C, 0x13, 0x13, 0x1C, 0xE0, 0x00,  // Code pour char A
        0x00, 0xFF, 0x09, 0x09, 0x09, 0x39, 0xC6, 0x00,  // Code pour char R
        0x00, 0x00, 0x01, 0x01, 0xFF, 0x01, 0x01, 0x00,  // Code pour char T
        0x00, 0x07, 0x08, 0xF0, 0xF0, 0x08, 0x07, 0x00,  // Code pour char Y
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char .
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char .
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char . 832
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  // Code pour char .
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x0E, 0x1F, 0x3E, 0xFC, 0xFC, 0x3E, 0x1F, 0x0E,  // Code for char  ----
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x08, 0x1C, 0x8A, 0xFF, 0xFF, 0x8A, 0x1C, 0x08,  // Code for char !
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x3C, 0x6E, 0xDB, 0xDF, 0xDF, 0xDB, 0x6E, 0x3C,  // Code for char "
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA,  // Code for char #
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x32, 0x62, 0x60, 0x60, 0x62, 0x32, 0x00,  // Code for char $
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x80, 0x60, 0x7E, 0xFF, 0xFF, 0x7E, 0x60, 0x80,  // Code for char %
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0xFF, 0x81, 0xBD, 0xA5, 0xA5, 0xBD, 0x81, 0xFF,  // Code for char &
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x7E, 0x42, 0x5A, 0x5A, 0x42, 0x7E, 0x00,  // Code for char '
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
         };

//*****************
//Déclaration des variables
char HC595_0,HC595_1,HC595_2,colonne;
char montexte[32];

//******************************************************************************
void send_data(char HC595_0, char HC595_1, char HC595_2)
{
  Spi1_Write(HC595_0);     // données premier circuit
  Spi1_Write(HC595_1);     // données deuxième circuit
  Spi1_Write(HC595_2);     // données troisième circuit
  Latch=1;                // impulsion de validation sur LATCH
  Latch=0;

}
//******************************************************************************
// Programme principal
void main()
{
  ADCON0=0;                         // ADC désactivé
  ADCON1=7;                         // ADC désactivé
  TRISA=1;                          // PORTA.0 configuré en Entrée
  TRISB=0;                          // PORTB configuré en sortie
  TRISC=0;                          // PORTC configuré en sortie
  PORTA=0;                          // mise à zéro des ports A
  PORTB=0;                          // mise à zéro des ports B
  PORTC=0;                          // mise à zéro des ports C
  
//Paramètre de configuration des ports pour la gestion du 74HC595
  Spi1_Init_Advanced(_SPI_MASTER_OSC_DIV4,_SPI_DATA_SAMPLE_MIDDLE,_SPI_CLK_IDLE_HIGH,_SPI_LOW_2_HIGH);

// init."string"
  montexte[0] = "E"; // code ascii réél du E;
  montexte[1] = "F"; // code ascii réél du F;
  montexte[2] = "G"; // code ascii réél du G;
  
// start
  RB1_bit=1;     // impulsion sur entrée RAZ
  RB1_bit=0;     // du 4017
  colonne=1;

//******************************************************************************
//boucle infinie
      while(1)
      {
              send_data(0,0,0);   // BLANKING (atténue la rémanence...)...
              RB0_bit=1;          // impulsion sur entrée clock
              RB0_bit=0;          // du 4017
              HC595_0=ASCII[((montexte[0]-30)*8)+colonne];    // données sur le premier 595
              HC595_1=ASCII[((montexte[1]-30)*8)+colonne];    // données sur le second 595
              HC595_2=ASCII[((montexte[2]-30)*8)+colonne];    // données sur le troisième 595
              send_data(HC595_0,HC595_1,HC595_2);      // envoie les données à afficher
              Delay_ms(3);
              colonne++;
              if(colonne>7) colonne=0;
      }  // fin de While
}  // fin de main

//***************************************************************************

[invite7a49d0d5]

Edit:

comme ça c'est mieux (boucle infinie à remplacer):

//******************************************************************************
//boucle infinie
      while(1)
      {
              HC595_0=ASCII[((montexte[0]-30)*8)+colonne];    // données sur le premier 595
              HC595_1=ASCII[((montexte[1]-30)*8)+colonne];    // données sur le second 595
              HC595_2=ASCII[((montexte[2]-30)*8)+colonne];    // données sur le troisième 595
              send_data(0,0,0);   // BLANKING (atténue la rémanence...)...
              RB0_bit=1;          // impulsion sur entrée clock
              RB0_bit=0;          // du 4017
              send_data(HC595_0,HC595_1,HC595_2);      // envoie les données à afficher
              colonne++;
              if(colonne>7) colonne=0;
              Delay_ms(3);
      }  // fin de While
}  // fin de main

//***************************************************************************

[Hearty]

Bonjour/soir...

Vede, vant d'aller plus loin merci de te pencher sur mon problème.

Le code tel quel, ne donne rien.
aucun affichage n'en sort.

L'as-tu testé de ton coté?

Edit: oup's je n'avais pas vu la suite je vérifie..

Edit 2 : il m'affiche seulement, une colonne sur l'afficheur central,

[invite7a49d0d5]

Salut Hearty,

pas de souci...
et non je peux pas tester...
car je n'ai pas 3 matrices, ni de HC595...

bon je te renvoies un code à tester...
dis moi ce que t'en penses (surtout la boucle infinie)...
et qu'est ce que ça affiche...
car ça devrait fonctionner...
à mon idée...

et assures toi que dans les fusibles le WatchDog soit bien désactivé...
tiens nous au jus,

vede
;O]
__________
...

/*************************************************************************/
#define Latch PORTC.F6

// Tableau de caractères sur 8 bits installés en ROM
const unsigned short ASCII[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00,  // Code pour char !
        0x00, 0x24, 0x7E, 0x24, 0x24, 0x7E, 0x24, 0x00,  // Code pour char #
        0x00, 0x26, 0x49, 0x49, 0xFF, 0x49, 0x32, 0x00,  // Code pour char $
        0x00, 0x46, 0x26, 0x10, 0x08, 0x64, 0x62, 0x00,  // Code pour char %
        0x00, 0x70, 0x8E, 0x89, 0x99, 0x76, 0xC0, 0x00,  // Code pour char &
        0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char '
        0x00, 0x7E, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char (
        0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x7E, 0x00,  // Code pour char )
        0x00, 0x00, 0x0A, 0x04, 0x0A, 0x00, 0x00, 0x00,  // Code pour char *
        0x00, 0x10, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x00,  // Code pour char +
        0x00, 0x00, 0x00, 0x80, 0x60, 0x00, 0x00, 0x00,  // Code pour char ,
        0x00, 0x00, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00,  // Code pour char -
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char .
        0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00,  // Code pour char /
        0x00, 0x7E, 0xC1, 0xB1, 0x8D, 0x83, 0x7E, 0x00,  // Code pour char 0
        0x00, 0x04, 0x02, 0x01, 0xFF, 0x00, 0x00, 0x00,  // Code pour char 1
        0x00, 0xE6, 0x91, 0x91, 0x89, 0x89, 0x86, 0x00,  // Code pour char 2
        0x00, 0x42, 0x81, 0x89, 0x89, 0x89, 0x76, 0x00,  // Code pour char 3
        0x00, 0x30, 0x28, 0x24, 0x22, 0xFF, 0x20, 0x00,  // Code pour char 4
        0x00, 0x4F, 0x89, 0x89, 0x89, 0x89, 0x71, 0x00,  // Code pour char 5
        0x00, 0x7E, 0x89, 0x89, 0x89, 0x89, 0x72, 0x00,  // Code pour char 6
        0x00, 0x01, 0x01, 0xF1, 0x09, 0x05, 0x03, 0x00,  // Code pour char 7
        0x00, 0x76, 0x89, 0x89, 0x89, 0x89, 0x76, 0x00,  // Code pour char 8
        0x00, 0x4E, 0x91, 0x91, 0x91, 0x91, 0x7E, 0x00,  // Code pour char 9
        0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00,  // Code pour char :
        0x00, 0x00, 0x80, 0x68, 0x00, 0x00, 0x00, 0x00,  // Code pour char ;
        0x00, 0x00, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00,  // Code pour char <
        0x00, 0x00, 0x28, 0x28, 0x28, 0x28, 0x00, 0x00,  // Code pour char =
        0x00, 0x00, 0x00, 0x44, 0x28, 0x10, 0x00, 0x00,  // Code pour char >
        0x00, 0x06, 0x01, 0xB1, 0x09, 0x09, 0x06, 0x00,  // Code pour char ?
        0x00, 0x7E, 0x99, 0xA5, 0xA5, 0xB9, 0x5E, 0x00,  // Code pour char @
        0x00, 0xE0, 0x1C, 0x13, 0x13, 0x1C, 0xE0, 0x00,  // Code pour char A
        0x00, 0xFF, 0x89, 0x89, 0x89, 0x8E, 0x70, 0x00,  // Code pour char B
        0x00, 0x7E, 0x81, 0x81, 0x81, 0x81, 0x42, 0x00,  // Code pour char C
        0x00, 0xFF, 0x81, 0x81, 0x81, 0x42, 0x3C, 0x00,  // Code pour char D
        0x00, 0xFF, 0x89, 0x89, 0x89, 0x81, 0x81, 0x00,  // Code pour char E
        0x00, 0xFF, 0x09, 0x09, 0x09, 0x01, 0x01, 0x00,  // Code pour char F
        0x00, 0x7E, 0x81, 0x91, 0x91, 0x51, 0xF2, 0x00,  // Code pour char G
        0x00, 0xFF, 0x08, 0x08, 0x08, 0x08, 0xFF, 0x00,  // Code pour char H
        0x00, 0x00, 0x81, 0xFF, 0x81, 0x00, 0x00, 0x00,  // Code pour char I
        0x00, 0x60, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x00,  // Code pour char J
        0x00, 0xFF, 0x08, 0x18, 0x24, 0x42, 0x81, 0x00,  // Code pour char K
        0x00, 0xFF, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00,  // Code pour char L
        0x00, 0xFF, 0x02, 0x0C, 0x0C, 0x02, 0xFF, 0x00,  // Code pour char M
        0x00, 0xFF, 0x03, 0x0C, 0x30, 0xC0, 0xFF, 0x00,  // Code pour char N
        0x00, 0x7E, 0x81, 0x81, 0x81, 0x81, 0x7E, 0x00,  // Code pour char O
        0x00, 0xFF, 0x11, 0x11, 0x11, 0x11, 0x0E, 0x00,  // Code pour char P
        0x00, 0x7E, 0x81, 0x81, 0xA1, 0x41, 0xBE, 0x00,  // Code pour char Q
        0x00, 0xFF, 0x09, 0x09, 0x09, 0x39, 0xC6, 0x00,  // Code pour char R
        0x00, 0x46, 0x89, 0x89, 0x89, 0x89, 0x72, 0x00,  // Code pour char S
        0x00, 0x00, 0x01, 0x01, 0xFF, 0x01, 0x01, 0x00,  // Code pour char T
        0x00, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x00,  // Code pour char U
        0x00, 0x0F, 0x30, 0xC0, 0xC0, 0x30, 0x0F, 0x00,  // Code pour char V
        0x00, 0x7F, 0x80, 0x70, 0x70, 0x80, 0x7F, 0x00,  // Code pour char W
        0x00, 0x07, 0x08, 0xF0, 0xF0, 0x08, 0x07, 0x00,  // Code pour char Y
        0x00, 0xC1, 0xA1, 0x91, 0x89, 0x85, 0x83, 0x00,  // Code pour char Z
        0x00, 0xFF, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char [
        0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00,  // Code pour char BackSlash
        0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0xFF, 0x00,  // Code pour char ]
        0x00, 0x00, 0x04, 0x02, 0x02, 0x04, 0x00, 0x00,  // Code pour char ^
        0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00,  // Code pour char _
        0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,  // Code pour char `
        0x00, 0x00, 0x20, 0x54, 0x54, 0x78, 0x00, 0x00,  // Code pour char a
        0x00, 0x00, 0x7E, 0x48, 0x48, 0x30, 0x00, 0x00,  // Code pour char b
        0x00, 0x00, 0x38, 0x44, 0x44, 0x28, 0x00, 0x00,  // Code pour char c
        0x00, 0x00, 0x30, 0x48, 0x48, 0x7E, 0x00, 0x00,  // Code pour char d
        0x00, 0x00, 0x38, 0x54, 0x54, 0x58, 0x00, 0x00,  // Code pour char e
        0x00, 0x00, 0x7C, 0x0A, 0x0A, 0x02, 0x00, 0x00,  // Code pour char f
        0x00, 0x00, 0x18, 0xA4, 0xA8, 0x7C, 0x00, 0x00,  // Code pour char g
        0x00, 0x00, 0x7E, 0x08, 0x08, 0x70, 0x00, 0x00,  // Code pour char h
        0x00, 0x00, 0x00, 0x7A, 0x00, 0x00, 0x00, 0x00,  // Code pour char i
        0x00, 0x00, 0x80, 0x80, 0x7A, 0x00, 0x00, 0x00,  // Code pour char j
        0x00, 0x00, 0x7E, 0x10, 0x28, 0x40, 0x00, 0x00,  // Code pour char k
        0x00, 0x00, 0x00, 0x7E, 0x40, 0x00, 0x00, 0x00,  // Code pour char l
        0x00, 0x7C, 0x08, 0x04, 0x78, 0x04, 0x78, 0x00,  // Code pour char m
        0x00, 0x00, 0x7C, 0x08, 0x04, 0x78, 0x00, 0x00,  // Code pour char n
        0x00, 0x00, 0x38, 0x44, 0x44, 0x38, 0x00, 0x00,  // Code pour char o
        0x00, 0x00, 0xFC, 0x28, 0x24, 0x18, 0x00, 0x00,  // Code pour char p
        0x00, 0x00, 0x18, 0x24, 0x28, 0xFC, 0x00, 0x00,  // Code pour char q
        0x00, 0x00, 0x7C, 0x08, 0x04, 0x08, 0x00, 0x00,  // Code pour char r
        0x00, 0x00, 0x08, 0x54, 0x54, 0x20, 0x00, 0x00,  // Code pour char s
        0x00, 0x00, 0x3E, 0x48, 0x40, 0x00, 0x00, 0x00,  // Code pour char t
        0x00, 0x00, 0x3C, 0x40, 0x40, 0x3C, 0x00, 0x00,  // Code pour char u
        0x00, 0x00, 0x1C, 0x60, 0x60, 0x1C, 0x00, 0x00,  // Code pour char v
        0x00, 0x3C, 0x40, 0x70, 0x70, 0x40, 0x3C, 0x00,  // Code pour char w
        0x00, 0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00, 0x00,  // Code pour char x
        0x00, 0x00, 0x0C, 0x90, 0x90, 0x7C, 0x00, 0x00,  // Code pour char y
        0x00, 0x00, 0x64, 0x54, 0x54, 0x4C, 0x00, 0x00,  // Code pour char z
        0x00, 0x00, 0x08, 0x76, 0x81, 0x00, 0x00, 0x00,  // Code pour char {
        0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00,  // Code pour char |
        0x00, 0x00, 0x00, 0x81, 0x76, 0x08, 0x00, 0x00,  // Code pour char }
        0x00, 0x00, 0x10, 0x08, 0x10, 0x08, 0x00, 0x00,  // Code pour char ~    94 lignes
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0xFF, 0x08, 0x08, 0x08, 0x08, 0xFF, 0x00,  // Code pour char H
        0x00, 0xFF, 0x89, 0x89, 0x89, 0x81, 0x81, 0x00,  // Code pour char E
        0x00, 0xE0, 0x1C, 0x13, 0x13, 0x1C, 0xE0, 0x00,  // Code pour char A
        0x00, 0xFF, 0x09, 0x09, 0x09, 0x39, 0xC6, 0x00,  // Code pour char R
        0x00, 0x00, 0x01, 0x01, 0xFF, 0x01, 0x01, 0x00,  // Code pour char T
        0x00, 0x07, 0x08, 0xF0, 0xF0, 0x08, 0x07, 0x00,  // Code pour char Y
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char .
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char .
        0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00,  // Code pour char . 832
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  // Code pour char .
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x0E, 0x1F, 0x3E, 0xFC, 0xFC, 0x3E, 0x1F, 0x0E,  // Code for char  ----
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x08, 0x1C, 0x8A, 0xFF, 0xFF, 0x8A, 0x1C, 0x08,  // Code for char !
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x3C, 0x6E, 0xDB, 0xDF, 0xDF, 0xDB, 0x6E, 0x3C,  // Code for char "
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA,  // Code for char #
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x32, 0x62, 0x60, 0x60, 0x62, 0x32, 0x00,  // Code for char $
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x80, 0x60, 0x7E, 0xFF, 0xFF, 0x7E, 0x60, 0x80,  // Code for char %
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0xFF, 0x81, 0xBD, 0xA5, 0xA5, 0xBD, 0x81, 0xFF,  // Code for char &
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x7E, 0x42, 0x5A, 0x5A, 0x42, 0x7E, 0x00,  // Code for char '
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
         };

//*****************
//Déclaration des variables
char HC595_0,HC595_1,HC595_2,colonne;
char montexte[32];

//******************************************************************************
void send_data(char HC595_0, char HC595_1, char HC595_2)
{
  Spi1_Write(HC595_0);     // données premier circuit
  Spi1_Write(HC595_1);     // données deuxième circuit
  Spi1_Write(HC595_2);     // données troisième circuit
  Latch=1;                // impulsion de validation sur LATCH
  Latch=0;

}
//******************************************************************************
// Programme principal
void main()
{
  ADCON0=0;                         // ADC désactivé
  ADCON1=7;                         // ADC désactivé
  TRISA=1;                          // PORTA.0 configuré en Entrée
  TRISB=0;                          // PORTB configuré en sortie
  TRISC=0;                          // PORTC configuré en sortie
  PORTA=0;                          // mise à zéro des ports A
  PORTB=0;                          // mise à zéro des ports B
  PORTC=0;                          // mise à zéro des ports C
  
//Paramètre de configuration des ports pour la gestion du 74HC595
  Spi1_Init_Advanced(_SPI_MASTER_OSC_DIV4,_SPI_DATA_SAMPLE_MIDDLE,_SPI_CLK_IDLE_HIGH,_SPI_LOW_2_HIGH);

// init."string"
  montexte[0] = 69; // code ascii du E;
  montexte[1] = 70; // code ascii du F;
  montexte[2] = 71; // code ascii du G;
  
// start
  RB1_bit=1;     // impulsion sur entrée RAZ
  RB1_bit=0;     // du 4017
  colonne=1;

//******************************************************************************
//boucle infinie
      while(1)
      {
              HC595_0=ASCII[((montexte[0]-30)*8)+colonne];    // données sur le premier 595
              HC595_1=ASCII[((montexte[1]-30)*8)+colonne];    // données sur le second 595
              HC595_2=ASCII[((montexte[2]-30)*8)+colonne];    // données sur le troisième 595
              RB0_bit=1;          // impulsion sur entrée clock
              RB0_bit=0;          // du 4017
              send_data(HC595_0,HC595_1,HC595_2);      // envoie les données à afficher
              Delay_ms(1);
              colonne++;
              if(colonne>7) colonne=0;
      }  // fin de While
}  // fin de main

ps : bon sinon je vais retenter mais en partant de ton code...

[Hearty]

Bonjour,

Ce code fonctionne,

Alors, je ne comprend pas, il ne ferait pas la conversion
ASCII en numérique si tu entres directement les caractères dans la chaine?

Je vais essayer avec ma routine voir si cela donne la même chose.

à de suite

[invite7a49d0d5]

re ;O]

bon ben c'est cool...
peut-être c'est le compilo, qui est parfois très bizarre (niveau types et conversions, ...)...
peut-être c'était mon "BLANKING" qui foutait la m....
bon en tout cas c'est cool...
je vais pouvoir attaquer le défilement...

[invite7a49d0d5]

rere ;O]

Alors, je ne comprend pas, il ne ferait pas la conversion
ASCII en numérique si tu entres directement les caractères dans la chaine?

oui, j'ai fait des essais avec le débuggueur...
pas évident de récupérer le code ASCII 65 d'une variable char ensuite assignée à "A"...
avec MikroC...
la mise en EEProm du message va simplifier la chose...

[Hearty]

Bonjour,

Vede!!
Grâce à ton aide, j'ai bien avancé, en adaptant ton
l'algorithme de ta routine à la mienne,
j'arrive à débloquer la situation.

Je parviens également à saisir mon texte sous forme:

txt[]="Mon_Texte";

Pour le moment, j'ai un petit souci avec les espaces,
je ne peux taper "Hello World" au premier espace il arrête l'affichage.

Concernant le scrolling en utilisant ma précédente méthode
je dois régler un problème de synchro.

Mais j'ai fait rapidement un test en scrolling par pas de caractère entier.

 void mess1(){

  char txt[]="___HELLO_WORLD!!";
 
  chrmax=strlen(txt);
 if(rafraichir>=1){  
                n++;
            if (vitesse>=4000){  // vitesse de défilement
              dat++; // scrolling caractères
              vitesse=0;

                                       }
               rafraichir=0;
               RB0_bit=1;       // bit d'impulsion de l'entrée clock
               RB0_bit=0;       // du 4017

              if(i>=8)           // compteur sur la totalité des octets du char
                      {
                       i=0;
                       RB1_bit=1;     // RAZ clock 4017
                       RB1_bit=0;
                       }  // fin de If
                     i++;

              HC595_0=font[((txt[i2]-33)*8)+(i-1)];    // données sur le premier 595
              HC595_1=font[((txt[i2]-33)*8)+(i-1)];    // données sur le second 595
              HC595_2=font[((txt[i2]-33)*8)+(i-1)];    // données sur le troisième 595

              send_data(HC595_0,HC595_1,HC595_2);      // envoie les données à afficher
              Delay_ms(1);
              send_data(0,0,0);
             
                     // Test de scroll Lettre par lettre
                      if (n>=96){ n=0;
                      i2++;
                      i3=i2+1;
                      i4=i3+1;
                      dat=0;
                      }
                 
                 if (i2>=chrmax) {i2=0; }
                 if (i3>=chrmax) {i3=0; }
                 if (i4>=chrmax) {i4=0; }

      }
 }

[invite0b09a430]

Bonjour,

Pour les espace essayent en mettant un truc du genre

#define ESPACE 0x20 //code ascii de l'espace

text[]="MonESPACEtexte";

[Hearty]

Merci Izissise,

Je viens de tester,
mais comme je le pensais,
il m'affiche HelloESPACEWorld

En attendant de trouver ce petit bug,
vu que j'en ai un autre, le "!" ne s'affichant pas,
je l'utilise pour générer un espace.

Mais cela ne reste que pour les essais,
je préfèrerais trouver la solution.

[invite7a49d0d5]

Salut,

bon ben c'est cool...
et je t'envoye la suite dès que j'avance...

pour les caractères Space et ! j'ai peur que ce soit une
erreur dans ton tableau de caractères ASCII... il faut
respecter la "normes", cad code ASCII Space = 32
et code ASCII ! = 33...
regardes la table ASCII originale (menu Tools > ASCII Chart)

en fait ton tableau "ASCII" devrait commencer par Space puis !...
et l'opération -32 pour faire les correspondances...
hors, quand tu fais -33 dans tes calculs, tu te retrouves avec :
code ASCII SPACE = 32 ... -33 = -1 ... ce qui ne correspond à
rien dans ton tableau ASCII...

je te laisse méditer ça et te tiens au jus pour la suite,
vede
;O]
____________
...

[Hearty]

Bonsoir,

Comme tu l'as dit, je me doute que le problème se situe
à l'indexation de la table,
seulement si je soustrais ma valeur par -32
pour faire correspondre le début des caractères au standard ASCII,
je me trouve décalé d'une lettre,

Comme tu as pu le constater
mon tableau de stockage des fonts n'est pas en 2D
qui aurait permis de faciliter l'adressage des caractères,
mais me concernant me bloquait pour obtenir un scrolling fluide,
d'où le choix du tableau 1D.

Et donc pour faire correspondre le debut de l'octet sur les 8,
qui dessinent le caractère, je dois soustraire un, ce qui me donne 33.

Même avec ton code j'ai du procéder à cette modif pour recaller le tout.

Quant au i-1, i remplit dans mon code l'équivalent de colonne
dans le tiens, mais par voie d'interruption, le rendant plus rapide,
seulement, pour une raison que j'ignore pour le moment,
le caractère etait décentré sur la matrice, nécessitant ce -1 pour le recaler.

Voilà le pourquoi du comment du moment,

Je reste ouvert à d'autres méthodes bien entendu,
ce qui me parait logique n'est peut-être pas très académique.

[Hearty]

* peu pratique cette édition de message, limitée à 5mn

Edit: je viens en partie de résoudre le problème.

la valeur à soustraire est maintenant 31,
et le tableau de font est modifié comme suit:

        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code pour char Espace
        0x00, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00,  // Code pour char !
        0x00, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00,  // Code pour char !
        0x00, 0x24, 0x7E, 0x24, 0x24, 0x7E, 0x24, 0x00,  // Code pour char #

J'ai tous mes caractères,
en doublant l'espace et le point d'exclamation.