bonjour,
utilisaton de hdsp2000 : matrice 5x7 leds x 4 série
le code croquis vient de cette page :
CROQUIS
il est long je le mets en supprimant la table de caracteres inutile pour la compréhension
#include <Wire.h>
//*** HDSP2000 Display Demo
//*** ASCII-DEMO
//*** phuinink@gmail.com : liens morts 2024
//*** Paul Huinink has a webpage on displays www.huinink.info and specifically HDSP200X series displays www.spagmon.com
//*** Modified December-2013 by Patrick Hickey: added HP HDSP single digit display and RGB LED
//*** Patrick Hickey ph@nipht.com
//modified 3/2018 by Brandon McRee - removed support for LED and single digit HDSP DISPLAY
//
//figure out latch pin
// an array of 5 bytes per ASCII
// 5 bytes cause 5 columns
// 7 bits per column (no LSB)
const byte ascii_5x7[] = { //when I put this in PROGMEM i get gibberish, without it the SRAM is 87% full...
table caracteres
};
int column[] = {2, 3, 4, 5, 6}; // can change to other pins
int data = 7; // change this to other general input/output arduino-pins as you like
int clock = 8; // change this to other general input/output arduino-pins as you like
int brightness = 2000; // keep high for max visibility. To high will cause flikkering
const int numberOflDisplays = 2; // change this if total number of HDSP200x's is different.
int tekstDat[numberOflDisplays * 4 * 5]; // this is the array that store's what on the displays. 4 digits per display and 5 columns per digit.
unsigned long tijd; // used to trigger events in one of the examples below
char buf[40];
boolean flagRx = false; //allowed to receive if false
//*****************************************************************setup*************************************************************
void setup(){
//Serial.begin(9600);
for (int i = 0; i < 5; i++){
pinMode(column[i], OUTPUT);
}
for (int i = 0; i < 5; i++){
digitalWrite(column[i], LOW);
}
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
digitalWrite(data, LOW);
digitalWrite(clock, HIGH);
tijd = millis();
Wire.begin(8); // join i2c bus with address #8 >>important<<
Wire.onReceive(receiveEvent); // register event
// sais pas ce qui concerne le bus i2c
}
//***********************************************************************************end setup******************************************************
void loop(){
char PROGMEM clr[] = " ";
char PROGMEM scroll[] = "2024 TECH CONTROL PANEL ";
char PROGMEM scroll2[] = "Remember Stupid... you have to drive this home :)";
// ne reprend pas l'affichage apres 1 tour de loop
// on est a la limite de la memoire ram
if(flagRx == false){
delay(10); //needs this delay to be stable
scrollText(scroll, 40); //scrolling text, speed : second number is var howslow how slow this is a test of fastdraw text (short strings)
delay(1000);
scrollText(scroll2, 40);
delay(10);
flagRx = true; // can now recieve
}
else{
writeText(buf);
for (int i = 0; i< 50; i++) draw(); //does this continuously - display HDSP2011
}
/*
scrollText(scroll3, 10);
delay(10);
//short quick text write
scrollText(hello, 8);
scrollText(world, 8);
delay(500);
delay(5);
writeText("TEST") ; //letters only? special charachters
for (int i = 0; i< 100; i++) draw();
delay(5);
writeText("ABCDEFGHIJKLMNOPQRSTUVWXYZ") ;
for (int i = 0; i< 70; i++) draw();
delay(5);
writeText("1234567890") ;
for (int i = 0; i< 100; i++) draw();
delay(5);
writeText("!@#$%^&*()") ;
for (int i = 0; i< 50; i++) draw(); //delay??
delay(5);
delay(1000);
*/
writeText(buf);
for (int i = 0; i< 50; i++) draw(); //does this continuously
}
//****************end of main loop *********************************
void receiveEvent(int howMany) {
int i;
for (i=0; i<howMany; i++){
buf[i] = Wire.read(); //read I2C data (address 8)
}
flagRx = true; // set flag, we received something. will figure out how to clear when
// while (1 < Wire.available()) { // loop through all but the last
}
//int x = Wire.read(); // receive byte as an integer not used
//Serial.println(x); // print the integer
void writeDigit(int positie, int ascii){
for (int i =0; i< 5;i++){
tekstDat[(numberOflDisplays * 4 - positie) * 5 + i] = ascii_5x7[ascii*5+i];
}
}
void scrollText(String tekkst, long howSlow){
int leng = tekkst.length();
for (int u=-numberOflDisplays*4;u<leng;u++){ // first N digits will be spaces. N = all digits of display. So one screen blank before first character apears.
for (int v=0; v< numberOflDisplays*4;v++){
if (( (u+v) >= 0 ) && ((u+v) < leng)){ // separete leading and tailing spaces from actual string
char oneChar= tekkst.charAt(u+v);
writeDigit(v+1, oneChar); // write the character of the string
}
else{
writeDigit(v+1, 32); // write ascii-value 32 = a space.
}
}
for (long teller = 0; teller < howSlow; teller++){
draw();
}
}
}
void writeText(String tekst){
int tl = tekst.length();
int spacesNeeded = 4 * numberOflDisplays - tl;
if (spacesNeeded <0){
tl = 4 * numberOflDisplays;
}
else{
for (int u = 0; u < spacesNeeded; u++){
tekst.concat(" ");
}
tl = 4 * numberOflDisplays;
}
char tekst_[tl];
for (int vv = 0; vv < tl; vv++){
char tt = tekst.charAt(tl-vv-1);
for (int i =0; i< 5;i++){
//tekstDat[vv*5+i] = ascii_5x7[tt*5+i]; //old using SRAM
//tekstDat[vv*5+i] = (pgm_read_byte(ascii_5x7))[tt*5+i]; //new try and read from PROGMEM does not compile :/
}
}
}
void dot(byte x, byte y, boolean oo){
if ((x < (numberOflDisplays *4 * 5)) && (y < 7)){
byte oldByte = tekstDat[x] & (0xFF - (2<<y));
tekstDat[x] = oldByte | (2<<y);
}
}
void draw(){
for (int Kolom = 0; Kolom < 5; Kolom++){ // 5 columns to be strobed
// pumping in 3 x 4 x 7 bits per one stobe of the column
for (int displayNo = 0; displayNo < numberOflDisplays; displayNo++){ // number of displays
for (int digitNo = 0; digitNo < 4; digitNo++){ // 4 characters per display
for (int diodeNo = 0; diodeNo < 7; diodeNo++){ // 7 row-elements
digitalWrite(clock, HIGH);
digitalWrite(data, tekstDat[Kolom + 5*(displayNo*4 + digitNo) ] &(2<<diodeNo)); // magic
digitalWrite(clock, LOW);
}
}
}
digitalWrite(column[Kolom], HIGH);
delayMicroseconds(brightness);
digitalWrite(column[Kolom], LOW);
}
}
c'est le falgRx qui passe à true dans le loop et qui bloque apres 1 "tour" ?
l'adresse i2c 0x08 : c'est pour relier 2 uno en I2C ?
dans la loop j'ai commenté le flagRx = true; et la loop tourne "normalement"
comment utiliser la fonction "receiveEvent" ?
je ne vois pas d'explications sur la page en lien, et les liens donnés dans l'en tete du croquis sont morts, sa video youtube est toujours en ligne
remarques : la table de caracteres se trouve en ram, dans la page en lien 1 personne donne un "truc" pour mettre la table en pgmem ? comment ?
dans la note d'application de hp/avago de 1999, conseille de mettre la table dans une mémoire externe avec un schéma, on est en 1999 et une usine à gaz.....
ces afficheurs ont été récupérés sur des appareils spécifiques mis au rebut en 1996, a base de 8031
Merci pour toutes infos
