INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Arduino 8x8 LED Matrix Multiplexing
07.01.2015, 10:24
Beitrag #9
RE: Arduino 8x8 LED Matrix Multiplexing
Hi,
tja, die Transistoren sind auch dafür da, die Ausgänge des Schieberegisters nicht zu überlasten. Ansonsten lies vielleicht nochmal mein Posting von vorher.
...und wieder: Ja, das Bild ist zu sehen, aber was hast Du erwartet, zu sehen?
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
07.01.2015, 10:32
Beitrag #10
RE: Arduino 8x8 LED Matrix Multiplexing
Ok. Also ich habe eigentlich einen schwarzen Bildschirm erwartet, bis ich nen Text im Monitor eingebe. Und wenn ich das tue herrscht totales Chaos auf der Matrix in alles blinkt durcheinander Smile
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
07.01.2015, 10:48
Beitrag #11
RE: Arduino 8x8 LED Matrix Multiplexing
Hi,
also eher einen "weißen" Bildschirm, da ja alles invertiert ist wegen der fehlenden Transistoren.
Außerdem kann es durchaus sein, dass Du schon was kaputt geschossen hast wegen der fehlenden Vorwiderstände.
Das Coding kommt mir auch ein bisschen komisch vor. "alphabets" wird als [][8]-Array deklariert, aber es werden immer nur 5 Zahlen gefüllt (statt 8). Das kann funktionieren, kommt mir aber dennoch komisch vor.
Mach doch mal folgendes (nach dem Einbauen der Vorwiderstände!): Schreibe einen neuen Sketch, der irgendwas einfaches ohne Scrollen anzeigt. Zum Beispiel ein 4x4-Quadrat in der Mitte oder einen Schrägstrich. Damit ist es dann einfacher, etwas herauszufinden. (Das Coding hinter dem Link ist eh grausam, da will ich mich nicht reinlesen.)
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
07.01.2015, 14:43 (Dieser Beitrag wurde zuletzt bearbeitet: 07.01.2015 18:24 von Martorinho.)
Beitrag #12
RE: Arduino 8x8 LED Matrix Multiplexing
Hallo, erstmal danke für die ganze Hilfe. ich habe mich dazu entschieden den einfachen weg zu gehen und das alles ohne shift register zu machen.

Ich will ja einfach nur diese Lautschrift haben Smile

jetzt habe ich auch einen code, bei dem man aber leider nur im code selber die "message" eingeben kann.

in dem char "requestString[] " wird ja einfach ein wort gespeichert. jetzt wäre es sehr schön, wenn ich über den serial.monitor was eingeben kann, das dann in requestString[] gespeichert wird. aber Serial.read klappt ja leider nicht bei arrays....

im folgenden der code:



Code:
int speed = 20; //number of times to repeat each frame
int pauseDelay = 500;  //microseconds to leave each row  on before moving to the next

char requestString[] = " blablabla " //The string to display
                                           //to change the message in code you right yourself simply
                                           //change this data and reset index and offset to 0
//Variables used for scrolling (both start at 0
int index = 0;  //this is the current charachter in the string being displayed
int offset = 0; //this is how many columns it is offset by

//Pin Definitions
int rowA[] = {9,8,7,6,5,4,3,2};          //An Array defining which pin each row is attached to
                                         //(rows are common anode (drive HIGH))
int colA[] = {17,16,15,14,13,12,11,10};  //An Array defining which pin each column is attached to
                                         //(columns are common cathode (drive LOW))

//Constants defining each charachters position in an array of integer arrays
//Letters
const int A = 0;  const int B = 1;  const int C = 2;  const int D = 3;  const int E = 4;
const int F = 5;  const int G = 6;  const int H = 7;  const int I = 8;  const int J = 9;  
const int K = 10; const int L =11;  const int M = 12; const int N = 13; const int O = 14;
const int P = 15; const int Q =16;  const int R = 17; const int S = 18; const int T = 19;
const int U = 20; const int V =21;  const int W = 22; const int X = 23; const int Y = 24;
const int Z = 25;

//Punctuation
const int COL =26; const int DASH = 27; const int BRA2 = 28; const int  _ = 29; const int LINE = 34;
const int DOT =36;

//Extra Charchters
const int  FULL =30; const int CHECK = 31; const int B2 = 32; const int TEMP = 33;
const int SMILE =35; const int COLDOT = 36;


//The array used to hold a bitmap of the display
//(if you wish to do something other than scrolling marque change the data in this
//variable then display)
byte data[] = {0,0,0,0,0,0,0,0};        

//The alphabet
//Each Charachter is an 8 x 7 bitmap where 1 is on and 0 if off
const int _A[] = {B0001000,
                  B0010100,
                  B0100010,
                  B1000001,
                  B1111111,
                  B1000001,
                  B1000001,
                  B0000000};

const int _B[] = {B1111110,
                  B0100001,
                  B0100001,
                  B0111110,
                  B0100001,
                  B0100001,
                  B1111110,
                       B0000000};

const int _C[] = {B0011111,
                  B0100000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B0100000,
                  B0011111,
                       B0000000};

const int _D[] = {B1111100,
                  B0100010,
                  B0100001,
                  B0100001,
                  B0100001,
                  B0100010,
                  B1111100,
                       B0000000};

const int _E[] = {B1111111,
                  B1000000,
                  B1000000,
                  B1111100,
                  B1000000,
                  B1000000,
                  B1111111,
                       B0000000};

const int _F[] = {B1111111,
                  B1000000,
                  B1000000,
                  B1111100,
                  B1000000,
                  B1000000,
                  B1000000,
                       B0000000};

const int _G[] = {B0011111,
                  B0100000,
                  B1000000,
                  B1001111,
                  B1000001,
                  B0100001,
                  B0011111,
                       B0000000};

const int _H[] = {B1000001,
                  B1000001,
                  B1000001,
                  B1111111,
                  B1000001,
                  B1000001,
                  B1000001,
                       B0000000};

const int _I[] = {B1111111,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B1111111,
                       B0000000};

const int _J[] = {B0001111,
                  B0000001,
                  B0000001,
                  B0000001,
                  B0000001,
                  B1000001,
                  B0111110,
                       B0000000};

const int _K[] = {B1000011,
                  B1000100,
                  B1001000,
                  B1110000,
                  B1001000,
                  B1000100,
                  B1000011,
                       B0000000};

const int _L[] = {B1000000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B1000000,
                  B1111111,
                       B0000000};

const int _M[] = {B1110110,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                       B0000000};

const int _N[] = {B1000001,
                  B1100001,
                  B1010001,
                  B1001001,
                  B1000101,
                  B1000011,
                  B1000001,
                       B0000000};

const int _O[] = {B0011100,
                  B0100010,
                  B1000001,
                  B1001001,
                  B1000001,
                  B0100010,
                  B0011100,
                       B0000000};

const int _P[] = {B1111110,
                  B0100001,
                  B0100001,
                  B0111110,
                  B0100000,
                  B0100000,
                  B0100000,
                       B0000000};

const int _Q[] = {B0011100,
                  B0100010,
                  B1000001,
                  B1000001,
                  B1000101,
                  B0100010,
                  B0011101,
                       B0000000};

const int _R[] = {B1111110,
                  B0100001,
                  B0100001,
                  B0101110,
                  B0100100,
                  B0100010,
                  B0100001,
                       B0000000};

const int _S[] = {B0111111,
                  B1000000,
                  B1000000,
                  B0111110,
                  B0000001,
                  B0000001,
                  B1111110,
                       B0000000};

const int _T[] = {B1111111,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                       B0000000};

const int _U[] = {B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B0111110,
                       B0000000};

const int _V[] = {B1000001,
                  B1000001,
                  B1000001,
                  B1000001,
                  B0100010,
                  B0010100,
                  B0001000,
                       B0000000};
                  
const int _W[] = {B1000001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B1001001,
                  B0110110,
                       B0000000};

const int _X[] = {B1000001,
                  B0100010,
                  B0010100,
                  B0001000,
                  B0010100,
                  B0100010,
                  B1000001,
                       B0000000};

const int _Y[] = {B1000001,
                  B0100010,
                  B0010100,
                  B0001000,
                  B0001000,
                  B0001000,
                  B0001000,
                       B0000000};

const int _Z[] = {B1111111,
                  B0000010,
                  B0000100,
                  B0111110,
                  B0010000,
                  B0100000,
                  B1111111,
                       B0000000};

const int _COL[] = {B0000000,
                  B0011000,
                  B0011000,
                  B0000000,
                  B0011000,
                  B0011000,
                  B0000000,
                       B0000000};

const int _DASH[] = {B0000000,
                  B0000000,
                  B0000000,
                  B0111110,
                  B0000000,
                  B0000000,
                  B0000000,
                       B0000000};

const int _BRA2[] = {B0010000,
                  B0001000,
                  B0000100,
                  B0000100,
                  B0001000,
                  B0010000,
                  B0000000,
                       B0000000};                  

const int __[] = {B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                       B0000000};

const int _FULL[] = {B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                     B1111111,
                       B0000000};                  

const int _CHECK[] = {B1010101,
                     B0101010,
                     B1010101,
                     B0101010,
                     B1010101,
                     B0101010,
                     B1010101,
                       B0000000};
                  
const int _B2[] = {B0111110,
                   B0000001,
                   B0000001,
                   B0001111,
                   B0000001,
                   B1000001,
                   B0111110,
                       B0000000};

const int _TEMP[] = {B0000011,
                     B0011111,
                     B0111111,
                     B1111110,
                     B1111111,
                     B0011111,
                     B0000011,
                       B0000000};

const int _LINE[] = {B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                     B0000001,
                       B0000000};                    
                
const int _SMILE[] = {B000000,
                      B1100100,
                      B1100010,
                      B0011001,
                      B1100010,
                      B1100100,
                      B0000000,
                      B0000000};                    
                  

const int _DOT[] = {B0000000,
                  B0000000,
                  B0000000,
                  B0000000,
                  B1100000,
                  B1100000,
                  B0000000,
                  B0000000};                    
                  
const int _COLDOT[] = {B0000000,
                       B0110000,
                       B0110000,
                       B0000000,
                       B0110011,
                       B0110011,
                       B0000000,
                       B0000000};                  

//Load the bitmap charachters into an array (each charachters position corresponds to its previously defined index (ie _A (a's bitmap)
//is at index 0 and A = 0 so letters[A] will return the 'A' bitmap)
const int* letters[] = {_A,_B,_C,_D,_E,_F,_G,_H,_I,_J,_K,_L,_M,_N,_O,_P,_Q,_R,_S,_T,_U,_V,_W,_X,_Y,_Z,_​COL,_DASH,_BRA2,__, _FULL, _CHECK, _B2, _TEMP, _LINE, _SMILE, _DOT, _COLDOT};

//Setup runs once when power is applied
void setup()
{
  for(int i = 0; i <8; i++){  //Set the 16 pins used to control the array as OUTPUTs
    pinMode(rowA[i], OUTPUT);
    pinMode(colA[i], OUTPUT);
    Serial.begin(9600);
  }
}

//repeats  
void loop()
{
updateMatrix();
}



void updateMatrix(){
  loadSprite();
  showSprite(speed);
}


//An array holding the powers of 2 these are used as bit masks when calculating what to display
const int powers[] = {1,2,4,8,16,32,64,128};

//Loads the current scroll state frame into the data[] display array
void loadSprite(){
  int currentChar = getChar(requestString[index]);
  int nextChar = getChar(requestString[index+1]);
  
  for(int row=0; row < 8; row++){                    //iterate through each row
    data[row] = 0;                                   //reset the row we're working on
    for(int column=0; column < 8; column++){         //iterate through each column
     data[row] = data[row] + ((powers[column] & (letters[currentChar][row] << offset)));   //loads the current charachter offset by offset pixels
     data[row] = data[row] + (powers[column] & (letters[nextChar][row] >> (8-offset) ));   //loads the next charachter offset by offset pixels
    }
  }
  offset++;                                          //increment the offset by one row
  if(offset==8){offset = 0; index++; if(index==sizeof(requestString)-2){index=0;}}         //if offset is 8 load the next charachter pair for the next time through
}

void showSprite(int speed2){
for(int iii = 0; iii < speed2; iii++){                 //show the current frame speed2 times
  for(int column = 0; column < 8; column++){            //iterate through each column
   for(int i = 0; i < 8; i++){                          
       digitalWrite(rowA[i], LOW);                      //turn off all row pins  
   }
   for(int i = 0; i < 8; i++){ //Set only the one pin
     if(i == column){     digitalWrite(colA[i], LOW);}  //turns the current row on
     else{                digitalWrite(colA[i], HIGH); }//turns the rest of the rows off
   }

   for(int row = 0; row < 8; row++){                    //iterate through each pixel in the current column
    int bit = (data[column] >> row) & 1;
    if(bit == 1){
       digitalWrite(rowA[row], HIGH);                   //if the bit in the data array is set turn the LED on
    }

   }
   delayMicroseconds(pauseDelay);                       //leave the column on for pauseDelay microseconds (too high a delay causes flicker)
  }
}
}

//returns the index of a given charachter
//for converting from a string to a lookup in our array of charachter bitmaps
int getChar(char charachter){
int returnValue = Z;
switch(charachter){
  case 'A': returnValue = A; break;
  case 'a': returnValue = A; break;
  case 'B': returnValue = B; break;
  case 'b': returnValue = B; break;
  case 'C': returnValue = C; break;
  case 'c': returnValue = C; break;
  case 'D': returnValue = D; break;
  case 'd': returnValue = D; break;
  case 'E': returnValue = E; break;
  case 'e': returnValue = E; break;
  case 'F': returnValue = F; break;
  case 'f': returnValue = F; break;
  case 'G': returnValue = G; break;
  case 'g': returnValue = G; break;
  case 'H': returnValue = H; break;
  case 'h': returnValue = H; break;
  case 'I': returnValue = I; break;
  case 'i': returnValue = I; break;
  case 'J': returnValue = J; break;
  case 'j': returnValue = J; break;
  case 'K': returnValue = K; break;
  case 'k': returnValue = K; break;
  case 'L': returnValue = L; break;
  case 'l': returnValue = L; break;
  case 'M': returnValue = M; break;
  case 'm': returnValue = M; break;
  case 'N': returnValue = N; break;
  case 'n': returnValue = N; break;
  case 'O': returnValue = O; break;
  case 'o': returnValue = O; break;
  case 'P': returnValue = P; break;
  case 'p': returnValue = P; break;
  case 'Q': returnValue = Q; break;
  case 'q': returnValue = Q; break;
  case 'R': returnValue = R; break;
  case 'r': returnValue = R; break;
  case 'S': returnValue = S; break;
  case 's': returnValue = S; break;
  case 'T': returnValue = T; break;
  case 't': returnValue = T; break;
  case 'U': returnValue = U; break;
  case 'u': returnValue = U; break;
  case 'V': returnValue = V; break;
  case 'v': returnValue = V; break;
  case 'W': returnValue = W; break;
  case 'w': returnValue = W; break;
  case 'X': returnValue = X; break;
  case 'x': returnValue = X; break;
  case 'Y': returnValue = Y; break;
  case 'y': returnValue = Y; break;
  case 'Z': returnValue = Z; break;
  case 'z': returnValue = Z; break;
  case ' ': returnValue = _; break;
  case '3': returnValue = B2; break;
  case '<': returnValue = TEMP; break;
  case '*': returnValue = FULL; break;
  case '|': returnValue = LINE; break;  
  case '_': returnValue = _; break;  
  case ':': returnValue = COL; break;  
  case '-': returnValue = DASH; break;  
  case ')': returnValue = BRA2; break;  
  case '%': returnValue = SMILE; break;  
  case '.': returnValue = DOT; break;    
  case '^': returnValue = COLDOT; break;      
  }
  return returnValue;
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
07.01.2015, 18:24
Beitrag #13
RE: Arduino 8x8 LED Matrix Multiplexing
ja der läuft.

sry, bin nicht so forenerfahren.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
07.01.2015, 18:37
Beitrag #14
RE: Arduino 8x8 LED Matrix Multiplexing
Hi,
Du musst halt über Serial ein Zeichen nach dem anderen einlesen (Serial.available und so) und jedes Zeichen so lange an einen String hängen (geht am besten mit der Klasse String), bis ein Zeilenende (CHR13)) kommt. Vielleicht noch eine Sicherung einbauen, dass nicht hunderte von Zeichen gespeichert werden.
Wenn Du dann den Eingabestring zusammen hast, dann entsprechend auf die Ausgabe kopieren und "leeren".
Mein Tipp dazu wäre: Mach das erstmal unabhängig von dem LED-Kram, also in einem neuen Sketch. Ansonsten kann es komplex werden.
Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  verständnisfrage colorduino/8x8 rgb Matrix hello_world 3 320 19.04.2016 10:51
Letzter Beitrag: hotsystems
  LED Matrix Multiplexing mit Schieberegister MrFuzzy 5 698 08.04.2016 16:23
Letzter Beitrag: MrFuzzy
  LCD Anzeige für Arduino Mega2560 an Arduino Due? DaniDD 1 802 03.06.2015 12:16
Letzter Beitrag: DaniDD
  Arduino Pin mit anderem Arduino auslesen - geht das? Gelegenheitsbastler 8 3.205 08.05.2015 20:49
Letzter Beitrag: Bitklopfer
Information 14x14 LED Matrix Display mit Funk erweitern thedude 8 2.715 07.04.2015 13:46
Letzter Beitrag: thedude
  RGB-LED Matrix Panel Janis.Gruber 2 2.094 03.09.2013 18:30
Letzter Beitrag: Janis.Gruber
Question Arduino Mega ADK oder Arduino Due? Baja-Junky 1 4.159 14.08.2013 21:16
Letzter Beitrag: Bitklopfer
  6 x 6 Matrix mit SMD RGB LEDs Tomsen 3 3.375 06.06.2013 06:08
Letzter Beitrag: peterunterhofer

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste