Arduino Projekte

stim0r0l · 27. Mai 2014

Muss one[8] nicht statisch sein?

/edit, habs mal in einem Online C-Compiler versucht, hatte da aber keine Wahl wie zu kompilieren:
Es gab z.B. kein Byte-Typ, im for durfte man keine Variable initialisieren, Casting war auch nur explizit möglich, und im switch-Statement durfte auch keine Variable initialisiert werden... Aber der Output ist so korrekt.

C

#include <stdio.h>
#include <string.h>
int today;
char *getNumber(int x);
main() {
today = 1;
char* numArray = getNumber(today);
printf("Displaying number ");
printf("%d", today);
printf(" (");
printf("%d", sizeof(numArray));
printf(") :");
int i = 0;
for (i; i < sizeof(numArray); i++) {
int led = numArray[i];
printf("%d",led);
printf(" ");
}
}
char *getNumber(int x) {
if(x == 1) {
static char one[8] = {(char)6,(char)9,(char)10,(char)20,(char)23,(char)34,(char)37,(char)49};
return(one);
}
}

Alles anzeigen

ruffy91 · 27. Mai 2014

Wenn one[8] static ist wird sie im ROM abgelegt, ansonsten wird sie bei jedem Aufruf aus dem ROM neu in den RAM geladen.

Edit: wird auch mit static ins RAM geladen, aber nur 1 mal und bleibt dann, über alle Aufrufe der Funktion, auch wenn man die Variable ändern würde, erhalten. im ROM abgelegt werden sollte sie wenn man das const Keyword benutzt. Der Arduino-Compiler ignoriert das keyword aber mehr oder weniger

rediculum · 27. Mai 2014

Danke für die Hilfe, Leute.

Wenn ich den Code von stim0r0l im GNU compiler laufen lasse, dann werden auch nur die erste 4 digits ausgespuckt

Code

Displaying number 1 (4) :6 9 10 20

Da ist doch was faul, resp. so kompliziert kann das doch nicht sein
Ausserdem muss ich die Zahlen im Array als integer oder bytes haben, da ich sie nachher einer Funktion der FastLED Library übergeben muss. Ok, ich könnte sie mit "atoi" auch vorher kurz konvertieren.

Um auf den Punkt zu kommen, was ich überhaupt machen will.
Ich habe eine header Datei gemacht mit einer Array Matrix für die Zahlen:

Code

#ifndef XMas14_RGB_h
#define XMas14_RGB_h
// single number of first digit
byte one_[] = {3,13,14,16,26,30,41,45};
byte two_[] = {1,2,3,12,17,26,27,28,42,43,44,45,46};
byte three_[] = {1,2,3,12,17,26,27,31,40,43,44,45};
// single number of second digit
byte zero[] = {5,6,8,11,18,21,22,25,32,35,36,39,48,49};
byte one[] = {6,9,10,20,23,34,37,49};
byte two[] = {4,5,6,8,21,23,24,32,39,47,48,49,50};
byte three[] = {4,5,6,8,21,23,24,35,36,47,48,49};
byte four[] = {4,7,8,11,18,21,22,23,24,25,35,36,50};
byte five[] = {4,5,6,7,11,18,23,24,25,35,36,47,48,49};
byte six[] = {5,6,11,18,23,24,25,32,35,36,39,48,49};
byte seven[] = {4,5,6,7,8,21,23,33,38,48};
byte eight[] = {5,6,8,11,18,21,23,24,32,35,36,39,48,49};
byte nine[] = {5,6,8,11,18,21,22,23,24,35,36,47,48,49};
// 2 digit numbers
byte ten[] = {*one_,*zero};
byte eleven[] = {*one_,*one};
byte twelve[] = {*one_,*two};
byte thirteen[] ={*one_,*three};
byte fourteen[] = {*one_,*four};
byte fifteen[] = {*one_,*five};
byte sixteen[] = {*one_,*six};
byte seventeen[] = {*one_,*seven};
byte eighteen[] = {*one_,*eight};
byte nineteen[] = {*one_,*nine};
byte twenty[] = {*two_,*zero};
byte twentyone[] = {*two_,*one};
byte twentytwo[] = {*two_,*two};
byte twentythree[] = {*two_,*three};
byte twentyfour[] = {*two_,*four};
byte twentyfive[] = {*two_,*five};
byte twentysix[] = {*two_,*six};
byte twentyseven[] = {*two_,*seven};
byte twentyeight[] = {*two_,*eight};
byte twentynine[] = {*two_,*nine};
byte thirty[] = {*three_,*zero};
byte thirtyone[] = {*three_,*one};
/*
Function to get array of LED to illuminate based on the integer given.
Return the pointer to the byte array containing the integers for the LED.
*/
byte* getNumbers(byte today) {
switch (today) {
case 0: return zero; break;
case 1: return one; break;
case 2: return two; break;
case 3: return three; break;
case 4: return four; break;
case 5: return five; break;
case 6: return six; break;
case 7: return seven; break;
case 8: return eight; break;
case 9: return nine; break;
case 10: return ten; break;
case 11: return eleven; break;
case 12: return twelve; break;
case 13: return thirteen; break;
case 14: return fourteen; break;
case 15: return fifteen; break;
case 16: return sixteen; break;
case 17: return seventeen; break;
case 18: return eighteen; break;
case 19: return nineteen; break;
case 20: return twenty; break;
case 21: return twentyone; break;
case 22: return twentytwo; break;
case 23: return twentythree; break;
case 24: return twentyfour; break;
case 25: return twentyfive; break;
case 26: return twentysix; break;
case 27: return twentyseven; break;
case 28: return twentyeight; break;
case 29: return twentynine; break;
case 30: return thirty; break;
case 31: return thirtyone; break;
}
}
#endif //XMas14_RGB.h

Alles anzeigen

Im .ino File soll dann im Prinzip das von weiter oben passieren:

Code

byte* numArray = getNumbers(today);
for (byte i = 0; i < sizeof(numArray); i++) {
led = numArray[i];
Serial.print(led); Serial.print(" ");
fadeInRandColour(led);
}

Ihr seht auch, dass ich für die 2 Stelligen Zahlen auch gerne die Arrays zusammenfügen möchte. Aber ich glaube so geht das auch nicht. Ich kenne strcat um Strings zu concatinaten, aber wie kann man das einfach mit Arrays machen? Muss ich da jedes Element auslesen und dann beim anderen Array anfügen?!?

Ich werde das Phänomen mal noch im Arduino Forum posten

rediculum · 27. Mai 2014

So, beim Arduino Forum kriegt man meistens die Antwort "Es geht nicht so wie du es machen willst". Irgendwie programmier ich zu dynamisch und zur Laufzeit. Ich kann mich mit diesem c++ einfach nicht anfreunden.

Naja, jedenfalls hab ich jetzt einen anderen Approach gewählt und einen multidimensionalen Array erstellt. Die Zeilen sind die Tage und die Spalten die Nummer der LED des WS2801 Strangs (50 LEDs).

Das funktioniert jetzt soweit

Code

/* 10 20 30 40 50
LED Matrix of WS2801 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 */
int matrix[2][50] = { {0,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,1,1,0},
{0,0,0,0,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0}
};
//byte zero[14] = {5,6,8,11,18,21,22,25,32,35,36,39,48,49};
//byte one[8] = {6,9,10,20,23,34,37,49};
void setup() {
Serial.begin(9600);
byte today = 0;
byte led;
for (int i; i < 50; i++) {
if (matrix[today][i] == 1) {
Serial.print("LED ");
led = i + 1;
Serial.print(led);
Serial.println(" on");
}
}
Serial.println("");
}
void loop() {
}

Alles anzeigen

Jetzt werde ich mal noch die FastLED Library einbinden, den RTC und hoffen, ich kann das Zeugs auf meine Art zusammenfügen

rediculum · 28. Mai 2014

Vergiss es, ich gebs auf.
Der Atmega328 mit seinen 2kb SRAM bringt meine Matrix für 31 Zahlen à 50 LEDs nicht hin und mir sind die Ideen ausgegangen, wie ich sonst die Zahlen auf die LED Matrix bringen soll.
Auch so gehts nicht:

Code

int matrix[31] = { 00001101001000000100110010000001001100100000000110,
00000100110000000001001000000000010010000000000010,
00011101000000000000101100000001000000100000001111,
00011101000000000000101100000000001100000000001110
};

Nach ca. dem 20. element spuckt Serial.print nur noch wirres Zeugs oder gar nix mehr und das Programm bleibt hängen (die loop Methode geht nicht).

BLJ · 28. Mai 2014

Hast du n Link zum thread was du genau ausgeben möchtest?

btw., bei der HSC08 Programmierung (ja das ist noch lange vor Arduino) konnte/musste man z.T. selber memory maps machen. Programmcode wurde afaik nicht ins Ram geladen und man konnte da n bisschen am verfügbaren Speicher rumschrauben.
Du solltest eigentlich schon Byte für Byte ausgeben können.

EDIT:
also bei deinem Ersten Post "Hab jetzt mal angefangen mit dem Code für die XMAS Beleuchtung ...."
ist das Problem:

du gibst die Länge des pointers aus, und scheinbar ist das ein 16Bit Prozessor, ergo ist der Pointer 2 Byte lang, also steht dann in der Klammer (2).
Und dann gibst du den Pointer aus, das heisst die Adresse des Pointers wird geprintet,.. und das sind dann eben die 2 Zahlen.

rediculum · 28. Mai 2014

Zitat

Original von BLJ
Hast du n Link zum thread was du genau ausgeben möchtest?

Ja, ich habe hier mal jetzt noch genauer gepostet, was ich machen möchte. Versammt, so schwer kann das doch nicht sein. Ich mein da wird mit Arduino riesen LED Displays gemacht und die müssen ja auch irgendwie die Zeichenkette gespeichert haben.

BLJ · 28. Mai 2014

ok hab das mal angeschaut. Was ist denn das genaue Interface zu den Leds? Oder gibst du die Position als Nummer auf dem Serial aus? Oder musst du die Position als char-nummer ausgeben? (das heisst, "Buchstabe" 9 = Zahl 9, hat aber den int Wert [ASCII Code] 57).
Sind das IOs die du ansteuerst? Mach mal ein Beispiel: Wie bringst du die LED an Position 25 zum leuchten? (fixer Code).

EDIT: hast du das schon angeschaut: http://www.arduino.cc/en/Reference/PROGMEM ?

rediculum · 28. Mai 2014

Die LEDs kann ich mit der FastLED Library steuern. Ich muss einfach die LED nummer als integer angeben. Das ist noch das kleinste Problem. Wie im Arduino Thread geschrieben, habe ich eine LED matrix vom 1-50 und um die 1 darzustellen, muss ich LED 6,9,10,20,23,34,37 und 49 aufleuchten lassen mittels der FastLED Funktion. Also macht man da am Besten ein Array und iteriert diesen durch um die LEDS aufzuleuchten. Eigentlich futz-einfach, aber ich kriegs mit den scheiss Arrays nicht hin diese zu referenzieren.
Wegen dem 2d Array, ja PROGMEM wäre eventuell ein Hack! Danke

ruffy91 · 28. Mai 2014

Wie wärs mit nem 10*50 Array?
"0" --> array[0-49]
"1" --> array[1*50+(0-49)]
"2" --> array[2*50+(0-49)]
usw.
benötigt zwar 500Byte, spielt aber keine Rolle wenn du es mit Progmem ablegst.

rediculum · 30. Mai 2014

BitBool hat mein Problem gelöst und sogar der SRAM scheint genug zu sein.

rediculum · 13. August 2014

Hier mal ein Bild als Prototyp für die X-Mas Beleuchtung:

Und noch ein Video

Und der Code:
XMas14_RGB.ino : http://pastebin.com/ReVFbb0d
XMas14_RGB.h: http://pastebin.com/Eibxumba
BitBool.h: http://pastebin.com/8VYtNtsa

Und die Verpackung:

Immer wieder geil, wozu man RJ45 sonst noch gebrauchen kann

PS: Auf banggood.com ist das UNO 21% günstiger. Kostet nur noch $8.75

rediculum · 30. November 2014

Hier das Endprodukt und derCode dazu.

rediculum · 20. November 2015

Hey Leute, wie siehts mit euren Weihnachtsbeleuchtungen für diese Jahr aus? Ich bin inzwischen umgezogen und habe leider kein perforiertes "Balkongländer" mehr, sodass ich jetzt meine WS2811 LEDs wie OOR vor 2 Jahren am Fensterrahmen anbringen werde.

Snipa · 24. November 2015

Hier ... ein Arduino-Projekt von einem gelangweiltem Mann

https://www.youtube.com/watch?v=pQ2dI_B_Ycg

Irgendwelche Freiwillige?

OutOfRange · 28. November 2015

Bei mir wie jedes Jahr 150 RGB LEDs in Sechs Fenstern, letztes Jahr kamen da noch ein, zwei Sequenzen dazu. Diese Jahr hab ich aber leider keine Zeit für Erweiterungen, auch wenn ich da schon seit Ewigkeiten gerne einen Ausbau vornehmen würde.

melloman · 22. Dezember 2015

Die einen haben ihn vielleicht an der Netgame gesehen, für die anderen hier ein kleines Video von meinem PipBoy auf Arduino Basis...

https://www.youtube.com/watch?v=KUnUcDM2cjk

rediculum · 23. Dezember 2015

Hab zwar noch kein FO4 gespielt, sieht aber geil aus das Teil.

melloman · 24. Dezember 2015

ist auch nicht aus Fallout4 sondern Fallout3/New Vegas

Poly · 8. Februar 2016

Tach

Ich hab da eine Idee für ein kleines Arduino Projekt und habe da ne Frage/Meinungsfrage dazu ..

Ziel: Arduino mit PIR Bewegungsdetektor und einem Relais. Eine IKEA LED Stripe welche an der inneren Seite des Bettrahmens montiert ist. Bewegung schaltet Relais ein und damit die LED Lichter. Damit sollte ein dezentes und nicht-störendes Licht erzeugt werden für nächtliche Streifzüge durch die Wohnung.

Meine Frage hierzu wäre .. soll ich mit dem Relais die AC oder die DC Seite der LEDs schalten? (AC Netzkabel -> AC/DC Netzteil -> Led Stripes )

Die Seite des DCs wäre wohl "sicherer". Die AC Seite wäre jedoch praktischer weil es generell dann für alles funktioniert was man dran schliesst. Villeicht übersehe ich auch was

Cheers,
Poly