Programmierer gesucht - Programm ähnlich dem MCS-Fonteditor

[Andree-HB]

Ich habe eine LED-Schaltung mit 4x 8-Bit Schieberegistern, die Spaltenweise Texte/Grafiken ausgeben soll, Schaltung steht und funktioniert.

Ich bräuchte nun ein PC-Programm, in dem ich Texte/Grafiken malen kann, und diese Pixelinformation als "Data-Text" ausgibt, welches ich dann einfach in Bascom per copy&paste ins Programm einfügen kann.


Damit man es sich besser vorstellen kann :
http://www.pixelklecks.de/pictures/editor.gif



Es wäre klasse, wenn die Bedienung ähnlich wie im "Original" ist : Pixelhöhe/Breite auswählen, jeden Pixel per Mausklich "färben" und per Zwischenablage Inhalte einfügen und postionieren....speichern/exportieren.


Ich könnte mit netten "Naturalien" bezahlen, Motoren, Displays, Snugboard-Platinen, usw.

[s.o.]

Schon mal bei Kontrollerlab geschaut? Afaik gab's da einen Font-Editor, habe aber nie damit gearbeitet....

[Gock]

Hi!
Ich hatte mal das gleiche Problem und habe es folgendermaßen gelöst:
1. In Excel quadtratische Zellen einstellen
2. bedingte Formatierung -> wenn ZellWert = 1, dann schwarzer Hintergrund, sonst weiß
3. überall dort, wo es leuchten soll, schreibst Du eine 1 rein, woraufhin die Zelle schwarz (oder rot oder sonstwas) wird
4. unter eine Spalte schreibst Du eine Formel, die Dir aus den "1"sen den Binärcode zusammenschreibt, bzw daraus gleich eine Dezimalzahl macht (ich könnte mal nachsehen, ob ich die noch finde...). Die kannst Du dann in Deinen Code einfügen, indem Du sie entweder als .CSV exportierst oder in einen Texteditor kopierst.
Ist zwar nicht so komfortabel wie auf Deinem Bild aber äußerst einfach und funktioniell.
Gruß

[murdocg]

Ich könnte mit einem Bekannten sprechen wir bekommen das bestimmt hin. Naja bis wann brauchst du das ganze?


mfg murdocg

P.S. Interesse an einem Snug-Board hätte ich schon.

Tante Edith: Kann man die auch kaufen? Wieviel kosten die?

[Andree-HB]

Naja bis wann brauchst du das ganze?


Nun ja, bin mitten im Projekt...und hier hakt es ziemlich....Alles "von Hand" zu malen ist echt ein Ätz-Job...alleine für ein simples "Lauflicht" muss man 32x32=1024 Einsen oder Nullen + Kleinkram von Hand schreiben...vorheriges Umrechnen in Hex ist auch nicht schneller...



Kann man die auch kaufen? Wieviel kosten die?


...ich habe nur noch Restbestände für eigene Projekte, würden mich aber bei so einer Aktion von ein paar trennen....



Ist zwar nicht so komfortabel wie auf Deinem Bild aber äußerst einfach und funktioniell


...interessanter Ansatz....auf so eine Idee mit Excel bin ich gar nicht gekommen, thx !

[murdocg]

Im Netz bin ich auf ein ähnliches Programm zum Programmieren eines 3x3x3 LED-Cubes gestoßen. Wenn ich dich richtig verstanden habe sollte es eigent. so wie dieses funktionieren. Und das, bekommen wir denk ich hin.
Ich lade das Programm morgen mal hoch.

[thewulf00]

Nichts leichter als das.

Ich bin leider erst 21 Uhr nach Hause gekommen und habe erst dann den Post gesehen, also entschuldigt den späten Post.

Hier ist nun V0.3 des Programms. Für Änderungen einfach melden. Der Download ist kostenfrei, uneinschränkt (Bandbreite) und unendlich oft möglich. Ich garantiere die Virenfreiheit des Programmes, aber ich empfehle trotzdem einen Scan. Das geht z.B. hier (http://www.kaspersky.com/de/virusscanner).

Download hier: Img2Data.zip (http://www.wurserver.net/Img2Data.zip) [231 KiB] V0.3

Source-Download für Delphi 7 hier: Img2Data_src.zip (http://www.wurserver.net/Img2Data_src.zip) [13 KiB] V0.3

Historie:
- V0.3: Beliebige Breite, Scrollen, Verschiebung des Bildes auch diagonal und in beliebigen Sprüngen.
- V0.2: Funktion zum Spiegeln der Bytes hinzugefügt.

Hinweise:
- Ich denke, dass die Spaltenangabe von Andreé falsch war, also dass die Spalten hinten beginnen. Beide Fälle sind im Programm abgedeckt, einfach den Haken bei "Spiegeln" setzen.
- Unten in der Ecke sieht man die aktuelle Position, falls das jemandem hilft.
- Exportieren geht bisher nur in die Zwischenablage. Das Speichern und Laden von Dateien ist auch machbar, aber nur, falls es auch jemand braucht.

Screenshot (von Version 0.1):
http://apload.de/bild/16692/test9TP8V.png

[chr-mt]

Hi,
ich habe das so gemacht:
Das Fontfile, das der Fonteditor erzeugt, geöffnet und mit Suchen & Ersetzen gearbeitet.
Also :Ersetze alle ".dB" mit "DATA"
Ersetze alle ";" mit " ' "
Fertig :)

Ist halt nicht in binärer Schreibweise, aber ist ja kein Problem.

EDIT:
Schönes Programm thewulf00! Habe es jetzt erst gesehen.

Gruß
Christopher

[Andree-HB]

Boahhh, wie geil ist das denn ???
Du bist mein ganz persönlicher Held am Morgen !!!

Genausoetwas habe ich mir gewünscht...nur müssten leider wirklich noch die Bits in den Bytes rotiert werden (LED`s falsch angeordnet). Sinnigerweise könnte/müsste ich das jetzt im Programm machen, habe aber mit "rotate" nicht das gewünschte Ergebnis :

Data &B11111000

ergibt derzeit (anzeigentechnisch)
00011111

nach "rotate", left
10001111

nach "rotate", right
00111110

...irgendwie schliesst sich mir diesbezüglich gerade nicht der Kreis - Muss man den rotate-Befehl für ein Byte achtmal durchlaufen lassen ?

[Andree-HB]

Ich habe mal die Anordnung der Bytes (grün) eingezeichnet
http://www.pixelklecks.de/pictures/editor2.gif

"meine" Zeile müsste lauten :

(Byte 3,2,1,0)
Data &B00000000 , &B00000000 , &B00000000 , &B00000000
Data &B00000010 , &B00000000 , &B00000000 , &B00000000
Data &B00001110 , &B00000000 , &B00000000 , &B00000000
Data &B00111110 , &B00000000 , &B00000000 , &B00000000

[sast]

Hi thewulf00,

Sehr schönes Tool, was du da gebastelt hast. Was ist denn das für eine Komponente, mit der man Pixel malen kann?

sast

[thewulf00]

Hi Andree,
ich habe Dir eine rotate-Funktion eingefügt. Bitte schau mal, ob die's tut. V0.2 ist jetzt oben und zum Download bereit.

Edit: Ich sehe gerade, die wolltest ja auch eine andere Spaltenreihenfolge. Hab ich noch schnell integriert.

@sast:
Das ist keine Komponente.
Ich benutze einfach die Canvas-Oberfläche des Formulars: (Für das Zeichnen)

procedure TForm1.img_rePaint;
var r :Trect;
I,J :Integer;
begin
For I:=0 to 31 do
For J:=0 to 31 do begin
r.Left := img_offset+i*10+1;
r.Top := img_offset+j*10+1;
r.Right := r.Left+9;
r.Bottom := r.Top+9;

if img_array[I,J] then
Canvas.Brush.Color := clPurple
else
Canvas.Brush.Color := clWhite;

Canvas.FillRect(r);
end;

Canvas.Pen.Color := clLtGray;

For I:=0 to 32 do begin
canvas.MoveTo(img_offset,img_offset+i*10);
canvas.LineTo(img_offset+32*10,img_offset+i*10);

canvas.MoveTo(img_offset+i*10,img_offset);
canvas.LineTo(img_offset+i*10,img_offset+32*10);
end;

Canvas.Brush.Color := Form1.Color;

canvas.TextOut(img_offset,img_offset-15, '0');
canvas.TextOut(img_offset-15,img_offset, '0');
For I:=1 to 4 do begin
canvas.TextOut(img_offset+10*I*8-10,img_offset-15, IntToStr(8*I-1));
canvas.TextOut(img_offset-15,img_offset+10*I*8-10, IntToStr(8*I-1));
end;

end;


Aufgerufen wird diese Funktion bei allen Aktionen, die den Datenbestand ändern, und beim Windows-Repaint-Signal (TForm1.FormPaint).

Zum Ändern der Pixel benutze ich folgende Funktion, die ich in die Ereignisse TForm1.FormMouseMove und TForm1.FormMouseUp eingefügt habe:

procedure TForm1.PaintItem(X,Y :Integer; mLeft,mRight :Boolean);
VAR iX, iY :Integer;
changed :Boolean;
begin
iX := (X-img_offset) DIV 10;
iY := (Y-img_offset) DIV 10;
if (iX < 0) OR (iX > 31) OR (iY < 0) OR (iY > 31) THEN
exit;

StatusBar1.Panels[0].Text := '('+IntToStr(iX)+'|'+IntToStr(iY)+')';

changed := False;

IF mLeft THEN begin
if not(img_array[iX,iY]) then
changed := True;
img_array[iX,iY] := True;
end;

IF mRight THEN begin
if (img_array[iX,iY]) then
changed := True;
img_array[iX,iY] := False;
end;

if (changed) then
list_recalc;

img_rePaint;
end;

Wie Du siehst, wird hier auch das Neumalen wieder angestoßen. Ebenso wie das Neuberechnen der Liste.



Für alle Interessierten ist jetzt der Source zum Download verfügbar.

[Andree-HB]

Es ist fast perfekt so !!!! Megagenial !!! ick` könnt Dir knuutschen !!!

Kann man nun nur noch die Breite beliebig machen - dann kann man nämlich auch Schriftzüge/Worte erstellen....

http://www.pixelklecks.de/pictures/editor4.gif

http://www.pixelklecks.de/pictures/sekt.jpg

[thewulf00]

Die Breite heißt dann "nach unten", also die Anzahl der Data-Zeilen?

[sast]

@Andree-HB

Dein Projekt sieht ja schon recht fertig aus. Gratulation!
Durch was kommen denn die Wellen zustande?

Hast du geplant, auch eine Änderung der Anzeige zu implementieren, ohne dass du den Controller neu programmierst? Thewulf00's Programm hat ja noch ausreichend Potential.

@thewulf00
Ist ja eine wirklich genial einfache (einfach geniale) Möglichkeit. Meistens denkt man viel zu kompliziert.
Da wirst du wohl jetzt noch etwas mehr Dynamik in das Array bringen müssen ;-)

Die Wünsche der Anwender sind unerschöpflich ;o)

sast

[Andree-HB]

genau, die Spaltenanzahl der Pixel beliebig verbreitern (Höhe/Zeilen bleibt immer gleich, da 4x8-Bit=32), und dann entsprechend die Datazeilen nach unten erweitern....

http://www.pixelklecks.de/pictures/editor5.gif

[thewulf00]

Ist ja eine wirklich genial einfache (einfach geniale) Möglichkeit. Meistens denkt man viel zu kompliziert.
Ja, ich habe ne Weile drüber nachgedacht und einfach mal probiert. Es hat gut geklappt. Das Ganze auf Scrollbarkeit zu erweitern, ist jetzt die Herausforderung.



Da wirst du wohl jetzt noch etwas mehr Dynamik in das Array bringen müssen ;-)
JAAA, endlich mal ne Aufgabe... ;)
Jetzt wirds langsam interessant...



Die Wünsche der Anwender sind unerschöpflich ;o)
Richtig - mal sehen, wie lange ich mithalten kann. Falls Du Delphi beherrscht, kannst Du mir auch gern Tipps geben.

[Andree-HB]

Dein Projekt sieht ja schon recht fertig aus. Gratulation!
Durch was kommen denn die Wellen zustande?


Durch das Zittern in den Händen...*g*
...der Versuchsaufbau hat ja schliesslich auch eine Höhe von einem Meter (!)




Hast du geplant, auch eine Änderung der Anzeige zu implementieren, ohne dass du den Controller neu programmierst?


Mal gucken, erstmal ist nur statischer Text/Grafik angesagt....vielleicht werde ich die Inhalte von SD-Card einlesen...aber soweit bin ich noch nicht....

Sehr coool....das Projekt kostet bisher lediglich ein bestücktes Snugboard und ca. weitere 7,- Euro an Teilen.

[thewulf00]

Ja, mit Freeware geht alles billiger und schneller... :D

Die Breite nehme ich mir jetzt mal vor. Das ist anstrengend. Mal sehen, ob mir was Einfaches einfällt.

[Andree-HB]

...gar nicht mal so einfach, das Alles alleine mit Fernauslöser im dunklen Badezimmer zu koordinieren ! ;-)

http://www.pixelklecks.de/pictures/pfeil.jpg

[murdocg]

Ok, da warst du schneller^^ Naja dein Tool ist aber auch richtig gut geworden in so kurzer Zeit.

[thewulf00]

Ok!

Es ist vollbracht. Schaut, ob es recht ist.

PS: Die Verschiebung des Bildes ist jetzt auch diagonal und in beliebigen Schritten möglich.
PPS: Diese Dynamische Breitenanpassung mit Speicher-reallokation ist sehr buganfällig, also schaut, ob Fehler drin sind.

[sast]

Ich kann ja nur über das Programm im allgemeinen urteilen und das sieht gut aus.

Über die Funktionalität kann nur Andree Kritik üben.

sast

[thewulf00]

Den Code wirst Du bestimmt auch verstehen?
Schau Dir doch mal das Klassenkonstrukt für das dynamische Array an.

[Andree-HB]

Es ist vollbracht. Schaut, ob es recht ist.


ich stehe extremst in deiner Schuld - so ist das Programm absolut perfekt, ich wüsste keinerlei Verbesserungen.

Und so sìeht`s aus, wenn RN-User zusammenarbeiten :

http://www.pixelklecks.de/pictures/rn.jpg

(Anzeigefläche etwa 1x2 Meter)

[thewulf00]

SUPER! Sieht echt riesig aus!

Ich muss jetzt los, die Umzugsvorbereitungen rufen.

Für etwaige Fehler, Fragen und Änderungen bin ich heute Abend wieder on.

[Ceos]

hrrrrrrmmm hrrrr schickes ding, das kommt mir mit meinem touchscreen display sehr entgegen ^^, kannst du vielelicht noch irgendwo n kleines bild einbauen, wo das symbol auch in pixelgröße dargestellt wird? (vll. doppelte pixelgröße, monitore sind ja wensentlich besser als die LCDs)

irgendwie geht mit der eindruck fürs fertige symbol verloren wenn das so überdimensional groß ist ^^

mit was hastn das geschrieben ?

[sast]

procedure TForm1.BitBtn4Click(Sender: TObject);
VAR b :TBitmap;
I,J :Integer;
begin
Form1.Hide;
Form2.Show;
b := TBitmap.Create;
b.Width := 32;
b.Height := 32;

Das soll doch bestimmt auch passend zur Bildgröße sein.

Und nur als Hinweis, "img_breite" wird nie verwendet. Jedenfalls hat Delphi das nicht nochmal gefunden :)

Das Destroy ist in diesem Fall auch nicht ganz so wichtig, da du ja das Array nie ganz wegwirfst, abgesehen vom Beenden des Programmes.

sast

edit:
@Andree 1x2m, das ist wirklich Klasse geworden.

[Andree-HB]

Ihr werdet demnächste mal sehen, was damit geplant ist...momentan bin ich schon mal schwerstens begeistert, was innerhalb kürzester Zeit umgesetzt werden konnte.

Die Mechanik/Elektronik war das kleinste Problem....für mich war`s dann erst ein Riesenberg, den Controller & Schieberegister zu programmieren...aber eine Zeile führte zur nächsten...und so schlimm war`s dann gar nicht.

Und jetzt noch, die Anzeigedaten so extremst komfortabel erstellen zu können, das finde ich wirklich toll !!!!

Ich muss jetzt noch an den Timings ein bisschen arbeiten, dann bin ich vorerst fertig....

http://www.pixelklecks.de/pictures/lichtleiste.jpg

[thewulf00]

Hey, Andree: Mach doch das Bild mal invertiert. Würde mich auch mal interessieren. :)

@Ceos: In Delphi 7. Das steht aber im Downloadthread. Das Bild füge ich sofort ein.

@sast: Dein Kommentar zu Deinem Code erschließt sich mir nicht ganz. Ist etwas verlorengegangen? Ich sehe den Code nur bis zur Zeile "b.Height := 32; ".

[Andree-HB]

Hey, Andree: Mach doch das Bild mal invertiert. Würde mich auch mal interessieren.


Klappt Bestens :

http://www.pixelklecks.de/pictures/andree1.gif

http://www.pixelklecks.de/pictures/andree2.jpg

[thewulf00]

Total cool. Ich meinte aber eher komplett invertiert. Aber es reicht auch so. Geilomat deine Entwicklung!

[Andree-HB]

Damit man mal die Größenordnung in etwa sehen kann :

http://www.pixelklecks.de/pictures/andree3.jpg

[sast]

Es ging mir nur darum dir zu zeigen, welche Stelle im Code ich meine.

Bei der Übernahme in die Zwischenablage muss
b.Width := 32;
dann auch an die tatsächliche Weite angepasst werden.
b.Width := Image.Width;

sast

[thewulf00]

Achso ok.

@Ceos: Ich habs gestern nicht mehr geschafft. Heute Abend komme ich auch nicht dazu. Morgen vielleicht.

@Andree: Is ja riesig :D

[Andree-HB]

Hat jemand einen Ansatz für mich, wie ich die Pixeldaten über UART/RS232 in das RAM vom Atmega schieben kann ?
Kann man sich überhaupt ein RAM-Array anlegen und es mit Daten füllen ?

Ich habe ja schliesslich 1024 Byte an RAM auf dem MC, und das beladen der Grafik wäre über RS232 erheblich komfortabler als über Entwicklungsumgebung & ISP.

[thewulf00]

Das Beschreiben des RAMs geht nicht von selbst. Wenn Du diese Funktion brauchst, musst Du sie Dir selber programmieren.

[Andree-HB]

...ich habe schon überlegt, ob ich mir jedes Byte in eine seperate Variable schreibe und abrufe...also vorher 256 Variablen definieren oder so....aber das sind nur Gedanken eines Programmierstümpers... ;-)

Ich trainiere aber derzeit gerade mit einem Bootloader herum, das würde mir auch die Funktionalität geben, die ich brauche....

[sast]

Wo hast du es denn bisher liegen? Im Progmem oder als Array?

sast

Edit: so schlecht ist die Idee mit der Variablen erst mal nicht. Du brauchst aber nur eine. Und zwar ein Array der Größe 256.

[thewulf00]

Ich würde Deinem Controller einfach die Möglichkeit geben, in einen Modus zu gehen, in dem er dann neue Daten per RS232 erhält und in den RAM schreibt. Dann kannst Du es so definieren, wie Du willst, und sogar im laufenden Betrieb updaten.

[sast]

Die Frage ist, wie du mit den Daten umgehen willst.

Wie oft wird der Schriftzug geändert. Sollen die aktuellen Daten nach einem Reset verfügbar sein, oder nur ein Defaultsatz, ist der Controller ständig an der RS232 Schnittstelle?

Ich möchte nur mal anmerken, dass bei einer dauerhaften Speicherung auch der EEPROM interessant ist. Der geht immerhin 100000 mal zu beschreiben, während der Flash nur 10000 mal mitmacht laut DB.

Zum Bootloader: Ich habe sehr gute Erfahrungen mit dem AVRootloader gemacht

sast

[thewulf00]

@Sast: Die Schreibzyklen sind prinzipiell richtig. Das ist aber zweierlei:
Zum Einen geht es hier um die Frage EEPROM oder RAM, und nicht EEPROM oder FLASH,
zum Anderen ist diese Zahl nur eine Garantie, so wie das MHD. Flashspeicher kann auch über 16 Mio Mal beschrieben werden, ohne Probleme (siehe Test c't).
Aber die Daten ins EEPROM zu schreiben, ist auf jeden Fall sinnvoll.

[Andree-HB]

Zum Bootloader: Ich habe sehr gute Erfahrungen mit dem AVRootloader gemacht


...ich gerade auch - kann jetzt ganz easy über USB/Seriell-Wandler & Bootloader flashen....wenn man weiß, wie`s geht, dann geht`s supereinfach! ;-)

[sast]

Ich wollte auch nur darauf hinweisen, dass das EEPROM eine Überlegung wert ist. Da kann man dann in aller Ruhe die Daten über die RS232 reinschaufeln. Oder man verwendet den AVRootloader der macht auch bloß nichts anderes.

Theoretisch könnte man ja die Übertragung der Daten gleich mit in dein Img2Data Progrämmchen mit aufnehmen.

sast

[thewulf00]

Das löst aber Dein Problem nicht. Denn Flashen heißt: Den Flash überschreiben, und das ist, siehe Sasts Post, nicht empfehlenswert für häufige Änderungen (z.B. bei Datenarrays).

[thewulf00]

Theoretisch könnte man ja die Übertragung der Daten gleich mit in dein Img2Data Progrämmchen mit aufnehmen.
Auch ne Idee!
Man müsste sich eben über eine Variante Gedanken machen, die auch universell einsetzbar ist, sonst könnte nur Andree es verwenden. :D

[sast]

Das mit dem Flashen siehst du falsch. Das macht Andree zwar zur Zeit so wenn ich es richtig verstanden habe, aber er muss ja bloß eine EEPROM lese Routine integrieren und kann dann ebenfalls über den AVRootloader auch den EEPROM beschreiben. Ist schon ein ziemlich geniales Ding.

Andererseits kann er wie schon erwähnt, durch den Zusatz einer EEPROM Schreibroutine und der UART Funktionalität, dass Ganze recht schön aus der Anwendung erledigen. Da sollten es dann aber auch nach Möglichkeit Rohdaten sein die da rübergeschaufelt werden.

@Andree: wie hast du denn nun die Daten bisher in deinem Programm liegen gehabt?

sast

[Andree-HB]

@Andree: wie hast du denn nun die Daten bisher in deinem Programm liegen gehabt?


...derzeit fest im Programm (flash) - eine Routine, die die Grafikdaten über UART empfängt und evtl. ins EEprom schreibt, das geben meine Kenntnisse derzeit nicht her... ;-)

Der momentane Zustand ist für mich schon extrem komfortabel - Grafik erstellen, per Zwischenablage jeweils kopieren und dann per Bascom-IDE compilen und über Bootloader/USB flashen. Geht jetzt auch problemlos mit meinem Laptop ohne ISP.

[thewulf00]

Na da muss aber noch eine EEPROM-Lagerung her - schon allein des Lerneffektes wegen!

Wir helfen Dir auch^^
Und wenn ich ne Schnittstellenbeschreibung bekomm, dann integrier ich auch gern eine Übertragung aus dem Progrämmchen herraus.

[sast]

Guten Morgen Andree,

vielleicht solltest du es als erstes nur mit dem Lesen aus dem EEPROM probieren. Wie es geht steht zB. in http://www.mikrocontroller.net/topic/7517

Wenn du als erstes eine Information über die Länge deines Bildes einbaust, bist du sogar recht flexibel was das Bild angeht. Danach legst du einfach ein Byte nach dem anderen in den EEPROM und holst es dir bei Bedarf in ein Array. Das sollte normalerweise schneller gehen als bei der Anzeige direkt auf das EEPROM zurückzugreifen. Aber bei Bascom weißt du wahrscheinlich mehr als ich, da ich normalerweise C verwende. Wenn du das im Griff hast kann man über UART und EEPROM schreiben nachdenken.

sast

Wegen der derzeitigen Datenhaltung in deinem Programm bin ich etwas irritiert, da du alle 4 Byte ein Data haben wolltest (Data &B00000011 , &B00000000 , &B00000000 , &B00001100
Data &B00011100 , &B11111000 , &B00110000 , &B00011000
Data &B00010000 , &B00001110 , &B11011000 , &B00110000). Hast du dafür mehrere Variablen verwendet, oder nutzt du für alle Daten nur ein Array?

[Andree-HB]

Hast du dafür mehrere Variablen verwendet, oder nutzt du für alle Daten nur ein Array?


...das ist nur übersichtshalber für mich, weil es immer eine ganze Spalte à 32 Bit bedeutet - ich lese es aber nacheinander weg, könnte also auch alles hintereinander geschrieben werden.

Zudem gebe ich ehrlich zu, dass ich mich mit Tabellen & Arrays vom Verständnis her schwer tue. Ich weiß bei meinem Code nur so zu 80% genau, was ich tue - der Rest ist gediebt, funktionert aber ! :-)

[sast]

80% ist doch super

Und wenn du Fragen zu Arrays hast, dafür ist das Forum schließlich da. Es haben ja nicht alle Informatik studiert. Ich ziehe immer den Hut vor Leuten, die sich sowas autodidaktisch aneignen.

sast

[Andree-HB]

ziehe immer den Hut vor Leuten, die sich sowas autodidaktisch aneignen


Nun ja, ist aber qualitativ sicherlich schon besser, wenn man es in einer Vorlesung (richtig) lernt, oder von Jemandem, der sich wirklich damit auskennt. Ansonsten bildet sich schnell ein gefährliches Halbwissen. Dennoch wundere ich mich immer, das ich fast immer meine gesteckten Ziele erreiche...hat wohl viel mit eigener Motivation zu tun.

Ausserdem ist das Internet ein geniales Werkzeug, welches man sich als absolutes Quell des Wissens bedienen kann. Was wäre vielleicht aus mir (beruflich) geworden, wenn ich das zu meiner Schul- / Lehrzeit schon gehabt hätte....naja, es passt schon so ganz gut ! :-)

[sast]

Hier mal ein Beispiel für ein .eep File, wie es thewulf00 erzeugen könnte, wenn man es direkt in das EEPROM laden will. ist nur ein Rahmen 32x32. Ich hoffe, ich habe die Checksummen richtig berechnet. Alles Handarbeit.



//Daten mit
//Spiegeln = true;
//Komplette Nullbytes am Anfang und Ende kürzen = false;
//Bytes intern spiegeln = true;
//Spaltenreihenfolge invertieren = true;

Data &B11111111 , &B11111111 , &B11111111 , &B11111111
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B00000001 , &B00000000 , &B00000000 , &B10000000
Data &B11111111 , &B11111111 , &B11111111 , &B11111111

//.eep Intel HEX file
//Hexformat: ":" XX=Anzahl Nutzbytes XXXX=Adresse XX=Typ XX..XX=0-n Nutzbytes
// XX=Checksum(Zweierkomplement aus allem was in der Zeile davor steht) CR LF

:02000E000020D0
:04001000FFFFFFFFF0
:040014000100008067
:040018000100008063
:04001C00010000805F
:04002000010000805B
:040024000100008057
:040028000100008053
:04002C00010000804F
:04003000010000804B
:040034000100008047
:040038000100008043
:04003C00010000803F
:04004000010000803B
:040044000100008037
:040048000100008033
:04004C00010000802F
:04005000010000802B
:040054000100008027
:040058000100008023
:04005C00010000801F
:04006000010000801B
:040064000100008017
:040068000100008013
:04006C00010000800F
:04007000010000800B
:040074000100008007
:040078000100008003
:04007C0001000080FF
:0400800001000080FB
:0400840001000080F7
:0400880001000080F3
:04008C00FFFFFFFF74
:00000001FF


Das erste Word gibt sozusagen die Breite aus Img2Data wieder und sagt somit dem Controller wie groß das Ganze ist.

sast

[thewulf00]

Das wäre ja genial, wenn es so ginge...
Super Arbeit @sast.

[Ceos]

iiich meld mich mal auf deinen rat ^^

wäre echt nett wenn du ne möglichkeit einbauen könntest, das ganze auch als array für C ausgeben kannst, so ala

char pic[x][y] = { ..... }

alternativ ginge natürlich auch ein 1-dimensionales array, weil mir ehrlich gesagt grade nciht mehr einfallen will, wie man ein mehrdimensionales array initialisiert ^^

x müsste quasi die spalte sein und y die byteposition für die pixelbytes

ich bräuchte das nämlich für nen simples alphabet für mein LCD

[thewulf00]

Die Links von meinem Programm waren leider tot. Ich habe das Programm daher erneut hochgeladen und die Links aktualisiert. Wenn es mal wieder nicht gehen sollte, einfach eine PN und gut.

[Andree-HB]

Moin Kollegen,
im Zuge der Projektvorstellungen für den Verein bin ich gerade dabei, meine eigenen Sachen mal wieder auf den neuesten Stand zu bringen.

Habe eben dafür mal ein paar aktuelle Fotoaufnahmen mit meinem “Pixelschwert” gemacht, Stichwort "Langzeitbelichtung & Bewegung" :
http://www.pixelklecks.de/projekteii/pixelschwert/index.html


Original
http://www.pixelklecks.de/pictures/hackerspace_pixel2.jpg


Bearbeitet
http://www.pixelklecks.de/pictures/hackerspace_pixel3.jpg
http://www.pixelklecks.de/pictures/hackerspace_pixel.jpg

[thewulf00]

Wow!

Und was ist denn das für ein cooles Programm, unten links im letzten Bild??? :)

[Andree-HB]

...soetwas Tolles bekomt man nur hier.... :-)