Hallo,
ich befinde mich aktuell in einem Praktikum und habe die Aufgabe
bekommen
ein Display von Conrad, 180847, mit Hilfe des ebenfalls von Conrad
erworbenen, Application Board AVR 32-bit, 192587, in Betrieb zu nehmen.
Da ich in der Programmierung allgemein und bei Mikrocontrollern erst
recht ein echter Anfänger bin, habe ich keine Ahnung wie ich das Display
ansteuern kann. Ein leuchtender Pixel (wenn das geht) würde für den
Anfang reichen, allerdings weiß ich nicht mal ob das Display überhaupt
kompatibel mit diesem AVR µC ist. Alles was ich bis jetzt auf dem µC
geschafft habe sind kleinere Programme, zusammengefügt in ein etwas
größeres, was aber auch nur dank der vorhandenen Demo-Programme gelang.
(Das Programm beinhaltet einen ADC Eingang, Timer, eine RS232
Verbindung, Taster, das LCD-Display für Die Messergebnisse des ADC und
natürlich das momentane Problem OLED Display) Eine externe
Versorgungsschaltung ist auch vorhanden. (24V in 12V, -12V, 2x 5V)
Das Datenblatt verstehe ich so auch nicht komplett, wobei ich doch sehr
erleichtert war als ich gehört habe, dass ich das "Serial interface"
benutzen solle, was zur Folge hat das Pin 5 R/W# und Pin 6 E(RD#)
wegfallen, oder nicht? (Vermute ich anhand der "DESCRIPTION", da dort
nur die anderen Interfaces beschrieben werden.
Bis jetzt habe ich in meinem Programm (ein neues Programm zum testen)
versucht mittels "Port_Attribute" und "Port_WriteBit" zu arbeiten, auch
wenn ich mir nicht sicher bin ob das der richtige Ansatz ist.
Insofern möchte ich mich, hoffentlich noch nicht am Ende, für die
falschen Annahmen o.ä. und für die fehlenden Informationen
entschuldigen, da dies mein erster Forum Beitrag überhaupt ist.
Grüße Lukas.
Hallo,
da kommt wahrscheinlich noch eine Menge Arbeit auf Dich zu.
Hier die Schritte die ich Dir raten möchte, um möglichst zügig
voranzukommen.
1.) HW-Anbindung machen, Basis-Kommunikation aufbauen,
Minmal-Initialisierung des Displays und Pixel anzünden. Das sind auch
die ersten Schritte, die Du machen musst - zumindest um mal zu sehen ob
das Display anspricht (erster großer Meilenstein).
Wenn das erledigt ist, musst Du die
2.) Initialisierung verfeinern (Display-Timings, Orientierung des
Displays, ...). Das ist auch noch nicht die große Sache und man kann
hier später noch Feinjustierungen vornehmen.
3.) Dann willst Du aber brauchbare Inhalte (am wichtigsten ist Text) am
Display darstellen. Der verwendete Display-Controller (SSD1305) hat
keine internen Fonts. Du schreibst lediglich die Pixel, die angezündet
werden müssen in den Videospeicher. Wenn Du hier angekommen bist, würde
ich das Netz durchforsten (nach PC-Tools die Deine gewünschte Font z.B.
in ein C-File konvertieren und entsprechende Ausgaberoutinen, die Du zu
Deinem Programm mitkompilierst). Ich bin mir sicher, dass es hier schon
was von der Community gibt. Glücklcherweise sind sich die meisten
Display-Controller in der Ansteuerung monochromer Displays in den
Auflösungen 128x64 und 132x64 SEHR ähnlich (auch zwischen LCD und OLED),
sodass sich die Anpassungen zwischen den einzelnen Display-Controllern
oft nur auf den Initialisierungs-Code beschränken. Das Anpassen solcher
Treiber ist dann meist nicht mehr die große Sache - vorausgesetzt man
hat schon etwas Erfahrung mit den Display-Controllern.
Alternativ gibt es auch kommerzielle Anbieter für Treiber /
Display-Routinen (z.B. www.ramtex.dk), die vermutli.
Für den ersten Part (BasisInbetriebnahme des Displays) kann ich ein paar
Tipps geben:
1.1) HW-Anbindung (SPI):
offensichtlich verwendest Du die 5V-Variante (VDD) des Displays
(VGY(G)12864L-03)
Pinout des Display-Controllers:
1 -> GND
2 -> 5V (VDD)
3 -> 12V
4 -> D/C mit beliebigem GPIO des AVR32 verbinden;
5 -> N.C. (not connected)
6 -> N.C.
7 -> SCLK (SPI)
8 -> MOSI (SPI)
9 -> N.C.
10 -> N.C.
11 -> N.C.
12 -> N.C.
13 -> N.C.
14 -> N.C.
15 -> CS# (SPI)
16 -> RES# am besten mit einem beliebigen GPIO des AVR32 verbinden,
diesen als Ausgang konfigurieren, bei jedem Programmstart erst eine ms
high setzen, eine ms low setzen, wieder high setzen, 100 ms warten und
dann erst mit den SPI-Commands beginnen - ohne dass ich mir das
RESET-Timing des SSD1305 jetzt genau angeschaut habe - kannst Du selber
machen & Timings optimieren -> Datenblatt des SSD1305 runterladen!);
17 -> GND (select SPI as interface)
18 -> GND (select SPI as interface)
19 -> N.C.
20 -> GND
Bei Verwendung des SPI-Interface kannst Du nur Daten zum Display
schreiben - nicht lesen (diese Display-Controller haben keine
MISO-Leitung); ist aber kein Problem;
1.2) GPIOs / SPI am AVR32 einrichten
Ich kenne Deine Entwicklungsumgebung nicht, aber ich vermute Du
verwendest das Atmel Software Framework (ASF) oder es sind andere
Bibliotheken vorhanden; du benötigst nun die SPI-Routinen; schau mal ob
in Deiner Infrastruktur was da vorhanden ist: schau die verfügbaren
Code-Examples an und lies das SPI-Kapitel Deines AVR32 aufmerksam durch
- Du benötigst ein Grundverständnis darüber, wie die SPI funktioniert!
Du solltest auf ein Oszilloskop zurückgreifen und damit umgehen können.
Ich gehe davon aus dass Dich jemand im Praktikum unterstützt.
Auf jeden Fall müssen die verwendeten SPI-Pins (zumindest SCLK & MOSI)
so konfiguriert werden, dass sie vom SPI-Modul gesteuert werden (nicht
vom GPIO-Modul); die CS-Leitung würde ich in der ersten Phase noch per
Hand (über das GPIO-Modul) kontrollieren (als Output konfigurieren);
dann musst Du das SPI-Modul (im AVR32)konfigurieren;
wichtig sind u. A.:
- SPI-Frequenz <= 4 MHz (limit des SSD1305); stell sie vorerst mal auf 1
MHz oder darunter, um Geschwindigkeitsoptimierungen würde ich mich erst
später kümmern;
- den SPI-Mode einstellen; zumindest manche Bibliotheken benutzen den
Begriff SPI-Mode; SPI-Mode (beim SSD1305) = 0 (bzw. CPHA=0, CPOL=0);
Mode 3 könnte auch funktionieren, mit Mode 0 bist Du aber auf der
sicheren Seite;
hier nochmal zusammengefasst:
1.2.1) GPIOs konfigurieren
RES#, CS#, D/C als Ausgänge am GPIO-Modul konfigurieren;
RES# = high
CS# = high
D/C = low
1.2.2) SPI-Modul konfigurieren (entsprechendes Kapitel im AVR32
datasheet durchlesen!)
SCLK und MOSI müssen so konfiguriert werden, dass sie vom SPI-Modul
kontrolliert werden;
SPI-Mode auf 0 setzen (CPHA=0, CPOL=0)
SPI-Frequenz vorerst auf 1MHz oder darunter einstellen;
8 bits pro Transfer (pro SPI-Datenwort) einstellen;
Delays zwischen den einzelnen Transfers (Bytes bzw. SPI-Datenwörtern)
brauchst Du nicht;
1.2.3) OLED-Display resetieren (siehe Pinout RES#)
1.2.4) OLED-Display Minimalst-Initialisierung
um mal alle Pixel einzuschalten brauchst Du vermutlich nur 2 Befehle
(lies aber auf jeden Fall das Datasheet vom SSD1305 aufmerksam durch -
Du musst nicht alles verstehen - Scroll-Features, wie der Video-Speicher
adressiert wird, Display-Timing, DC-DC-Konverter, Pixel invertiert und
sogar wie das Display an den Display-Controller angebunden ist
(COM/SEG), sollten vermutlich vorerst egal sein);
Du brauchst nun eine Routine, die Kommandos an das Display sendet
(Pseudo-Code):
1
voidssd1305_sendSingleByteCmd(uint8_tcmd)
2
{
3
uint8_tspiRxDummy;// don't care about the received byte;
4
// MISO is not wired anyway;
5
gpioClr(GPIO_DC);// informs SSD1305 that it is about to
spiTransferBuff(&spiRxBuff,&cmd,1);// transfer command byte;
9
// when spi transmits datawords, it's inevidable that the
10
// same number of datawords is received; this function
11
// has to wait for the transmission to finish shifting
12
// the last dataword before returning!
13
gpioSet(GPIO_CS);// transmission end;
14
}
15
16
voidssd1305_initMin(void)
17
{
18
// if ssd1305 has not been reset yet, do it now;
19
//ssd1305_reset();
20
ssd1305_sendSingleByteCmd(0xAF);// turn display on
21
ssd1305_sendSingleByteCmd(0xA5);// turn all pixels on
22
}
Wenn alles funktioniert hat, sollten nach Ausführung der init-Routine
alle Pixel leuchten.
Ich bin nur selten in den Foren aktiv, also kann es sein, daß ich bei
Rückfragen nicht in absehbarer Zeit antworte.
Gruß,
Andreas
VIELEN, RIESIGEN DANK Andreas.^^
Werde mich da jetzt dran setzen und mal schauen wie weit ich da komme.
Ohne den Beitrag säße ich hier wohl einfach nur verzweifelnd rum.
Vielen Dank.
Grüße
Hallo,
ich habe mich jetzt teilweise durch gearbeitet und so manche Probleme
festgestellt.^^
Ich benutze die C-Control Pro IDE, da sie standartmäßig drauf oder
empfohlen war, ist schon ~12 Wochen her.
Bei der "Pinout des Display-Controllers:" kann ich bei P17 und P18 kein
Inferface wählen, da ich keine Bibliothek oder andere Erklärungen in der
IDE finden kann. Allgemein gibt es keine Beispiele zum Thema SPI
lediglich acht Indexeinträge für SPI Abschaltung, SPI_Disable/Enable,
read, write, chan und das ganze mit Buffern. Da wäre dann das zweite
Problem. Ich kann keinen SPI-Mode wählen und die Frequenz aussuchen
funktioniert, allerdings brauche ich für die Frequenz 2 Bit und für die
anderen Einstellungen 5-7 Bit, möglich sind allerdings nur 4 Befehle...
. (Bit 0 + 1 für Frequenz. Wenn bei Beiden Bits = 0 steht dann 4
vermutlich 4MHZ, steht nicht bei.)
Es kann natürlich gut sein das meine fehlende Intelligenz das Problem
ist allerdings habe ich in so manchen Beiträgen gelesen, dass dieses
Thema schlecht dokumentiert sein soll. (in C-Control Pro IDE)
Würde ein Umstieg auf eine andere Entwicklungsumgebung für 4 Wochen Rest
zeit lohnen?
Welche Umgebung wäre besser?
Kennt jemand vernünftige Beispiele, in CompactC, für die SPI?
Bin dann mal weiter rumprobieren. Hoffentlich bis bald.^^
Grüße.
Hallo,
>Bei der "Pinout des Display-Controllers:" kann ich bei P17 und P18 kein>Inferface wählen, da ich keine Bibliothek oder andere Erklärungen in der>IDE finden kann.
...weder die beste Bibliothek noch genialste IDE wird Dir die Arbeit
abnehmen, Pins anzuschließen. Wie ich im vorhergehenden Beitrag
angeführt habe, müssen einfach beide Pins mit GND (Masse) verbunden
werden und es ist damit erledigt. Der Kommentar, den ich dahinter
angeführt habe war nur zur Erläuterung, was es damit auf sich hat:
Damit wird dem Display-Controller mitgeteilt, dass er über die SPI (und
NICHT über einen parallel Datenbus oder I2C) mit dem Mikrocontroller
verbunden ist und entsprechend von dieser Schnittstelle die Befehle
entgegennehmen muss.
>Allgemein gibt es keine Beispiele zum Thema SPI>lediglich acht Indexeinträge für SPI Abschaltung, SPI_Disable/Enable,>read, write, chan und das ganze mit Buffern. Da wäre dann das zweite>Problem. Ich kann keinen SPI-Mode wählen und die Frequenz aussuchen>funktioniert, allerdings brauche ich für die Frequenz 2 Bit und für die>anderen Einstellungen 5-7 Bit, möglich sind allerdings nur 4 Befehle...>. (Bit 0 + 1 für Frequenz. Wenn bei Beiden Bits = 0 steht dann 4>vermutlich 4MHZ, steht nicht bei.)
Wo hast Du bloß Diese Bits/Informationen zusammengekratzt? Ich hatte mit
C-Control noch nie zu tun, aber die Information sind für mich klar (wenn
Sie auch Details vorenthalten).
Wenn Du von "Indexeinträgen" schreibst und damit Bibliotheksfunktionen
meinst, sind da noch ein paar Syntax-Barrieren, die wir ausräumen
müssen.
Jetzt gehst Du mal auf die Seite, wo die Bibliotheks-Funktionen
beschrieben sind:
http://www.c-control-pro.de/documentation/index.html
Dann navigierst Du dich durch den "Verzeichnisbaum" bis zum SPI-Kapitel
durch und findest da SPI_Enable:
gleich im Anschluss sind die Übergabe-Parameter definiert:
chan SPI Kanal (0 - 1)
speed SPI Takt (259000 - 66000000)
bits Anzahl der Datenbits
mode SPI Mode
der Parameter bits beschreibt die ANZAHL DER BITS PRO SPI-DATENWORT BEI
DER ÜBERTRAGUNG (falls Du hier Deine seltsamen Bit-Rückschlüsse
abgeleitet hast).
In der darauf folgenden Tabelle ist auch der Mode beschrieben (0 f.
SPI-Mode 0). Der Controller besitzt zwei SPI-Schnittstellen.
Der Channel (chan) gibt einfach die SPI-Schnittstelle an, mit welcher Du
das Display mit dem Board verdrahtet hast. Wenn Du für die Anbindung den
Kanal 0 verwendest, dann werden die Pin-Namen (Labels) aller SPI-Pins,
die Du verwenden musst, eine 0 enthalten.
heisst im Klartext für die Initialisierung der SPI (bei channel 0):
1
SPI_Enable(0,1000000UL,8,0);// vorerst nur ~1 MHz; SPI-Mode 0, 8 bits pro Datenwort
Das war vermutlich schon die komplette Initialisierung der SPI -
einfacher geht es wirklich nicht. Anhand der API und Doku (hier ist
zumindest nicht explizit angeführt, dass /CS per Hand gesetzt werden
muss) lässt sich annehmen, dass die CS-Leitung bereits vom SPI-Modul
kontrolliert wird (oder von den Funktionen). Das Setzen/Löschen (und
vermutlich Initialisieren) der CS-Leitung in meinem vorhergehenden
Beitrag kannst Du Dir also wahrscheinlich sparen (mit Oszilloskop
nachprüfen).
das macht aus der Funktion ssd1305_sendSingleByteCmd folgendes:
1
voidssd1305_sendSingleByteCmd(bytecmd)
2
{
3
Port_WriteBit(GPIO_DISP_DC,PORT_OFF);/* informs SSD1305 that it is about to receive a command; */
Hallo,
zu der Sache mit dem SPI_Enable. Ich habe die Befehle durch die Index
Suche gesucht und da steht was vollkommen anderes. Hab mir eigentlich
gedacht, dass durch die Suche genau das was in der Bibliothek steht
gefunden wird. Das hab ich gefunden --> "void SPI_Enable(byte ctrl);"
war wohl mein Fehler sorry.^^
Die Bits kommen auch von dem Fund.
------------------------------------------------------------------------
Bit 7 - SPI Interrupt Enable (nicht einschalten, kann von C-Control Pro
nicht genutzt werden)
Bit 6 - SPI Enable (muss gesetzt sein)
Bit 5 - Data Order (1 = LSB first, 0 = MSB first)
Bit 4 - Master/Slave Select (1 = Master, 0 = Slave)
Bit 3 - Clock polarity (1 = leading edge falling, 0 = leading edge
rising)
Bit 2 - Clock Phase (1 = sample on trailing edge, 0 = sample on leading
edge)
------------------------------------------------------------------------
(immer dieses kleingedruckte Mega ...)
Mein Problem ist das, dass ich mir andere Projekte durch x maliges
Testen beigebracht habe, was hier ja nicht geht.
---> SPI_Write((word)cmd); funktioniert so nicht (auch nicht mit
Werten).
Ich habe das word durch Zahlen ersetzen und das cmd löschen müssen,
damit das Programm wieder funktionstüchtig war. Die Konfiguration der
SPI, das resetten, der Timer, sowie der Rest klappt soweit.
(jedenfals werden keine Fehlermeldungen angezeigt, das Display zeigt ja
noch nichts an von daher denke ich, das der Quelltext soweit richtig
ist).
Was mir noch einfällt, soll man bei "SPI_Write((word)cmd);" für word den
Befehl einsetzen, der dann abgeschickt wird oder soll man sich einen
Befehl, auf Seite 12 des Display Datenblattes aussuchen, die Bits in
"SPI_WriteBuf" schreibt und davor D/C = 0 setzt?
Ich muss schon sagen das ich solch einen Quelltext oder generell auf die
"Voreinstellungen" niemals selber gekommen wäre. Für mich wäre das wohl
so etwas wie Zahlen/Buchstaben/Zeichen raten gewesen. Leider.
Wird mich auch mal mit meinem Chef dran setzen.
Ich mag es selber nicht wenn man fertige Ergebnisse vorgesetzt bekommt,
denn ohne dass man was selber macht versteht man es auch nicht und vor
allem kann man zukünftige Probleme bei z.B. Umbauten nur sehr schlecht
lösen.
Vielen Dank für die Antwort und entschuldige meine Inkompetenz.^^
Grüße.
Hallo,
>---> SPI_Write((word)cmd); funktioniert so nicht (auch nicht mit>Werten).
Mit dieser Beschreibung ist es niemandem möglich, zu helfen. Bitte genau
schildern, wie sich "funktioniert so nicht" bemerkbar macht (gibt die
IDE beim Kompilieren einen Fehler aus? Wenn ja - wie lautet die
Fehlermeldung?).
>Ich habe das word durch Zahlen ersetzen und das cmd löschen müssen,>damit das Programm wieder funktionstüchtig war.
Kann mir das anhand der bisherigen Schilderung z.B. so erklären, dass Du
"SPI_Write((word)cmd);" irgendwo willkürlich in dein Programm (main?)
reinkopiert hast und "cmd" dort nicht bekannt ist, anstatt - wie
angegeben - in dieser Funktion verwendest (in der "cmd" als
Übergabeparameter dient):
1
voidssd1305_sendSingleByteCmd(bytecmd)
2
{
3
Port_WriteBit(GPIO_DISP_DC,PORT_OFF);/* informs SSD1305 that it is about to receive a command; */
4
SPI_Write((word)cmd);// write single byte command
5
}
cmd ist vom Typ "byte", weil der Display-Controller grundsätzlich für
8-Bit breite SPI-Datenwörter ausgelegt ist; die Bibliotheksfunktion
SPI_Write hingegen verwendet ein 16-Bit-word als Übergabeparameter, weil
das SPI-Modul bis zu 16-Bit-Breite Datenwörter unterstützt (wenn die SPI
mit 8-Bit breiten Datenwörtern konfiguriert wurde, werden die oberen
8-Bit des Übergabeparameters ignoriert); auch um auf die
unterschiedlichen Datentypen aufmerksam zu machen, wurde ein expliziter
type cast (Typenkonvertierung) gemacht:
1
SPI_Write((word)cmd);// explicit type cast
Es wird in diesem Fall jedoch genauso funktionieren (der typecast
erfolgt implizit - ohne Dein Zutun):
1
SPI_Write(cmd);// implicit type cast
GPIO_DISP_DC musst Du natürlich selber ZUVOR definieren (je nachdem, an
welchen Pin Du das Signal am AVR32 angeschlossen hast).
z.B. bei D/C-Signal an PB00:
1
#define GPIO_DISP_DC PB00 // das selbe wie #define GPIO_DISP_DC 32
>Mein Problem ist das, dass ich mir andere Projekte durch x maliges>Testen beigebracht habe, was hier ja nicht geht.
Das Problem ist, dass Dir offensichtlich fundamentale C-Kenntnisse
fehlen. Ist nicht böse gemeint, aber Du wirst es sehr schwer haben, wenn
Du Dir diese Grundkenntnisse nicht aneignest.
Am besten geht das, indem man ein C-Buch liest und jemanden kennt, den
man zwischendurch mit Fragen durchlöchern kann. Vielleicht kann Dich
hier Dein Chef oder Projekt-Begleiter unterstützen. Die Grundkenntnisse
über C wird Dir vermutlich keiner über ein Forum beibringen
können/wollen.
Gruß,
Andreas
Hallo,
>Mit dieser Beschreibung ist es niemandem möglich, zu helfen. Bitte genau>schildern, wie sich "funktioniert so nicht" bemerkbar macht (gibt die>IDE beim Kompilieren einen Fehler aus? Wenn ja - wie lautet die>Fehlermeldung?).
Syntax Fehler 1 + 2:
Quelltext:
void ssd1305_sendSingleByteCmd (byte cmd)
{
Msg_WriteText("Ausgabe erfolgt...\r\r");
Port_WriteBit( GPIO_DISP_DC, PORT_OFF);
SPI_Write((word)cmd); <--- Markierte Zeile
}
Meldung:
Verzeichnis: Syntax Fehler - unerwartetes Symbol: 'word'
Verzeichnis: Syntax Fehler - unerwartetes Symbol: 'cmd' (selbe Zeile)
Wenn ich das cmd lösche und für word beispielsweise eine 1 einsetze
bekomme ich bei dem Versuch auf die Funktion zuzugreifen folgendes zu
lesen:
Syntax Fehler:
Quelltext:
void Beispiel(void)
{
ssd1305_sendSingleByteCmd(); <--- Markierte Zeile
}
Meldung:
Verzeichnis: Syntax Fehler - Zuwenig Argumente für Aufruf von Funktion
ssd1305_sendSingleByteCmd.
Mit,
> void ssd1305_initMin (void)>{> ssd1305_sendSingleByteCmd( 0xAF); // turn display on> ssd1305_sendSingleByteCmd( 0xA5); // turn all pixels on>}
,
klappt das allerdings ohne Fehlermeldung, ist aber nicht das aktuelle.
> Kann mir das anhand der bisherigen Schilderung z.B. so erklären, dass Du>"SPI_Write((word)cmd);" irgendwo willkürlich in dein Programm (main?)>reinkopiert hast und "cmd" dort nicht bekannt ist, anstatt - wie>angegeben - in dieser Funktion verwendest (in der "cmd" als>Übergabeparameter dient):
In main oder in sonst einer Funktion ist es nicht.
Ich habe deine Funktion kopiert und wollte, wie weiter oben schon
beschrieben, auf deine Funktion zugreifen.
Das mit dem definieren von "GPIO_DISP_DC" ist natürlich so ne Sache bei
der ich nich geschaltet habe.^^ (Nach der Fehlermeldung habe ich
"GPIO_DISP_DC" einfach als variable deklariert.
>Das Problem ist, dass Dir offensichtlich fundamentale C-Kenntnisse>fehlen. Ist nicht böse gemeint, aber Du wirst es sehr schwer haben, wenn>Du Dir diese Grundkenntnisse nicht aneignest.
Oh ja.
Ist nichts dran, was man "böse" auffassen sollte.
Da kann ich auch keine Ausreden finden.^^
Haben in der Schule "nur" C++ gehabt. C++ in Richtung: ,,Wir schreiben
jetzt alles in die main Funktion (wusste bis zu meinem Praktikum nicht
einmal das man x beliebige Funktionen nutzen kann) und lassen das
Programm stumpf abarbeiten und dann schauen wir mal was kommt...
(Fachabi Yeahh)
(jetzt weiß ich warum die Lehrer trotz der eins so traurig geguckt
haben)
Vielen Dank.
Grüße.
Hallo,
Ohne Erklärungen der folgenden Schritte schlage ich Dir nun folgendes
vor:
die Funktion void ssd1305_sendSingleByteCmd (byte cmd) wird
folgendermaßen geändert/erweitert:
1
#define GPIO_DISP_DC 32 // for now; just check if it compiles;
2
voidssd1305_sendSingleByteCmd(unsignedcharcmd)
3
{
4
// Msg_WriteText("Ausgabe erfolgt...\r\r");
5
Port_WriteBit(GPIO_DISP_DC,0);
6
SPI_Write(cmd);
7
}
--> Kompileren; gibt's noch Fehler? wenn ja, welche?
Wenn das alles noch nichts gebracht hat, poste hier Dein ganzes C-File
(besser als Datei anhängen, nicht in den Beitrags-Text einfügen).
Falls es jedoch funktioniert, aufräumen:
#define GPIO_DISP_DC 32
32 durch das GPIO-Define ersetzen (z.B. "PB00" je nachdem welchen Pin Du
hierfür verwendest);
Gruß,
Andreas
Hallo,
> #define GPIO_DISP_DC 32 // for now; just check if it compiles;
Mir wird kein Fehler angezeigt. Scheint zu klappen.
> --> Kompileren; gibt's noch Fehler? wenn ja, welche?
Der einzige Fehler wäre jetzt noch:
Quelltext:
...
if(!(TimerZurAusgabe%10))
{
ssd1305_sendSingleByteCmd();
}
...
Ende
Fehlermeldung:
Verzeichnis:Semantik Fehler - Zuwenig Argumente für Aufruf von Funktion
ssd1305_sendSingleByteCmd
Ist einfach der Sprung von meiner x beliebigen Funktion auf deine
empfohlene Funktion.
C-File müsste im Anhang sein.
Ich kann Werktags (außer Samstags) von 9:00Uhr bis 14:00Uhr antworten.
(oder eher fragen)
Vielen Dank erneut.
Grüße.
Hallo,
falls Du nicht schon ein paar Probleme selbst rausgefunden hast, hier
ein paar Tipps:
1.) Das sich das Programm nicht kompilieren lässt, ist klar. Immerhin
rufst Du in Deinem Beispiel ssd1305_sendSingleByteCmd ohne
Übergabeparameter auf - der ist nicht optional! Schließlich willst Du
der Funktion das Command übergeben, das zum Display-Controller gesendet
wird. Wie gesagt - die C-Grundkenntnisse musst Du selber lernen.
2.) Du rufst offensichtlich IO-Funktionen (z.B. Port_Attribute) auf,
ohne zu verstehen, wie die funktionieren. Die Attribute müssen binär
verodert werden. Rufst Du die Funktion für den selben Pin 2x
hintereinander mit unterschiedlichen Attributen auf, gelten die letzten
(ein zuvor als Output konfigurierter Pin wird ggf. zum Input).
3.) Wenn Du SCLK vom Channel 1 des Controllers als /CS verwendest, KANN
die Leitung nicht automatisch gesetzt werden.
Besser Du setzt die Leitung vorerst manuell (nach dem die korrekt
initialisiert wurde), wie in meinem ersten Beitrag vorgeschlagen.
Hoffentlich hast Du die anderen SPI-Leitungen besser gewählt.
Generell: probier nicht so viel wahllos rum, sondern ließ die
Dokumentationen durch - bis Du sie verstehst. Wenn die Pixel erst mal
leuchten, wirds noch komplizierter - soviel kann ich schon verraten.
Versuch mal das modifizierte File im Anhang. Gut möglich, dass noch ein
paar Fehler drin sind. Es kommt dem was Du erreichen willst aber näher.
Gruß,
Andreas
Hallo,
bei dem angehangenen Quelltext funktioniert, außer der "Function
declarations" am Anfang alles. Ich habe die vier Deklarationen aus
kommentiert und dann kamen auch keine Meldungen mehr. Geleuchtet hat
zwar nichts allerdings sieht das Programm schon mal nach etwas aus.^^
Danke.
> define GPIO_DISP_CS PB21 // why THIS pin?
In deiner ersten Antwort stand ja unter 1.2.1
> RES#, CS#, D/C als Ausgänge am GPIO-Modul konfigurieren;
.
> 3.) Wenn Du SCLK vom Channel 1 des Controllers als /CS verwendest, KANN
die Leitung nicht automatisch gesetzt werden.
SCLK also P7 des Displays ist mit SCK PD02 auf dem µC verbunden. Dachte
mir SCLK und SCK bedeuten das selbe und werden vom µC, wegen der
Namensgebung, direkt erkannt.
Grüße.
PS:
Die Versorgung ist angeschlossen.
Hallo,
damit wir vom selben sprechen:
>> define GPIO_DISP_CS PB21 // why THIS pin?>In deiner ersten Antwort stand ja unter 1.2.1>> RES#, CS#, D/C als Ausgänge am GPIO-Modul konfigurieren;>.
Natürlich brauchst Du die CS-Leitung. Aber ich hätte eine verwendet, die
dediziert als CS vom SPI-Modul eingesetzt werden kann, sodass sie auch
automatisch vom Modul gesetzt werden kann (wenn auch erst in einer
revidierten Version). Du verwendest beim Interface offensichtlich für CS
den Ausgang PB21, der kann vom SPI-Modul selbst nur als SCLK des
Channels 1 verwendet werden.
Ist egal, bleib vorerst mal bei dem Pinout. Das Manuelle setzen des Pins
scheint derzeit die beste Variante.
>> 3.) Wenn Du SCLK vom Channel 1 des Controllers als /CS verwendest, KANN>die Leitung nicht automatisch gesetzt werden.>SCLK also P7 des Displays ist mit SCK PD02 auf dem µC verbunden. Dachte>mir SCLK und SCK bedeuten das selbe und werden vom µC, wegen der>Namensgebung, direkt erkannt.
Das ist auch korrekt. Der Einwand bezieht sich auf die CS-Leitung
(seitens Display), nicht auf die SCK-Leitung seitens Display.
Der verwendete Controller kann die SPI-Signale ( (CS, MISO,) MOSI, SCLK)
auf verschiedenen Pins ausgeben (bzw. lesen). Z.B. ist SCLK für Channel
0 auf PD02 grundsätzlich verfügbar - wie Du richtig erkannt hast - aber
auch auf PD06 und anderen Pins. Auf welchen Pin der nun wirklich
verwendet wird, geht aus der Bibliotheks-Doku nicht hervor, da ist ein
Blick in den Schaltplan (Schematic) bzw. die Pin-Beschriftungen des
Boards vermutlich der beste Anhaltspunkt.
Ich würde nun nochmals alle SPI-Pins durchchecken.
Anschließend würde ich die Funktion in der Hauptschleife, in der
Dummy-Commands (NOP) zum Display gesendet werden aktivieren (derzeit
auskommentiert) und ein Oszilloskop an den von Dir gewählten CS-Pin,
MOSI, SCLK und D/C anhängen. In der Hauptschleife eine kurze Wartezeit
zwischen den SPI-Transfers einzubauen wäre auch hilfreich, dann sind die
einzelnen Transfers besser voneinander zu unterscheiden und die Timings
besser zu prüfen.
Hier sollten nun permanent SPI-Transfers laufen (alle Leitungen müssen
Ihre vorgesehene Funktion erfüllen).
Auch die RES-Leitung muss überprüft werden.
Aufpassen auf:
RES - wird das gewünschte Reset-Timing aus der Init-Funktion
eingehalten? Ist die Leitung nach dem Init wirklich high?
CS (von Dir gewählte) - geht die Leitung vor der Übertragung auf low und
nach dem die SCLK-Leitung die Takte ausgibt wieder auf high?
CS (nach Board-Beschriftung) - am Board gibt's wahrscheinlich auch eine
dedizierte CS-Leitung; wenn das der Fall ist, kannst Du sie auch mal
anhängen und sehen was die macht;
SCLK - sieht man überhaupt Flanken? Welche Frequenz?
MOSI - sind Zustandsänderungen (saubere Flanken) zu erkennen, wenn der
Clock auf SCLK ausgegeben wird?
DC - ist die Leitung immer auf low (ist für's erste erforderlich!)?
Ein Oszilloskop ist für die Feststellung des Problems von größter Hilfe.
Ich hoffe es ist eines verfügbar und jemand kann Dir im Umgang damit
helfen.
Es gibt auch C-Control-Foren. Die Leute dort können Dir sicher bei den
spezifischen Dingen (SPI-Interface bzw. HW-Anbindung) weiterhelfen.
Ich werd' mich vorerst mal aus dem Thread zurückziehen.
Viel Glück.
Gruß,
Andreas
Hallo,
wollte gerade meinen Arbeitsplatz wechseln (hab mehrere Projekte) und
wollte dir nur noch schnell danken.
Heute habe ich leider keine Zeit mehr an dem Projekt, ich werde morgen
allerdings alles ausprobieren und genauer durchgehen.
In dem Sinne vielen Dank und noch einen schönen Tag.
Andreas schrieb:> Ich werd' mich vorerst mal aus dem Thread zurückziehen.
so kurz vor dem Ziel sollte man nicht aufgeben. Probiert es doch
ersteinmal mit einem Software-spi, da kann man die Funktion der pins mit
entsprechenden delays auch ohne oszi überprüfen. Außerdem läßt sich die
Funktionn des spi für einen anfänger leichter nachvollziehen.
Hallo,
so war das nicht gemeint.
Meine Deadline wird der 28.08 sein, da das mein letzter Praktikumstag
ist und ich danach keinen Zugang zur Gerätschaft haben werde.
Außerdem studiere ich etwas später.
Grüße
Hallo,
@Andreas:
Vielen Dank für deine Hilfe und die Zeit die du dir genommen hast.
Wollte anstatt der Antwort jetzt eigentlich schreiben was als Ergebnis
raus kam allerdings weiß ich nicht ob das noch Sinn ergibt.
(Kommt davon, wenn man nicht zu ende liest. NENE
@Grundschüler:
Entschuldige bitte die Frage aber soll ich die Funktion in mein
Programm integrieren oder soll ich lieber ein neues anfangen?
Und danke für die Antwort.
Grüße auch an die, die eventuell nur mit lesen.^^
das ist die hw-spi-Funktion, die Probleme macht (?)
> SPI_Write((word)cmd); <--- Markierte Zeile
diese ersetzen durch die sw-spi-Funktion...
Vorher prüfen, ob spi-Polarität und spi-Phase stimmen (Datenblatt LCD)
Hallo,
bei meinem alten Programm gibt es keine Funktion die für Probleme sorgt.
Das Problem ist bei dem Programm einfach nur das, dass keine Pixel
leuchten.
Bei dem Programm von Andreas kommt folgendes:
(31,1): Syntax Fehler - unerwartetes Symbol: 'void'
(32,1): Syntax Fehler - unerwartetes Symbol: '{'
(33,24): Syntax Fehler - erwartete ';' , gefunden ')'
(40,16): Syntax Fehler - unerwartetes Symbol: '|'
(41,5): Semantik Fehler - Funktion Port_Attribute schon definiert
(41,21): Syntax Fehler - unerwartetes Symbol: '54'
(42,5): Semantik Fehler - Funktion Port_Attribute schon definiert
(42,21): Syntax Fehler - unerwartetes Symbol: '53'
(44,5): Semantik Fehler - Funktion SPI_Enable schon definiert
(44,16): Syntax Fehler - unerwartetes Symbol: '0'
(45,5): Semantik Fehler - Funktion SPI_SetChan schon definiert
(45,17): Syntax Fehler - unerwartetes Symbol: '0'
(Quelltexte im Anhang)
Mit deiner Funktion bekomme ich komische Syntax Fehler wie:
Syntax Fehler - unerwartetes Symbol';' --- sck_off;
oder:
Syntax Fehler - unerwartetes Symbol '>' --- for(u8 i=8;i>0;i--){
(nur bei der von dir geposteten Funktion)
Die Variablen sind deklariert werden aber nicht erkannt. Warum auch
immer.
Grüße.
Lukas schrieb:> Mit deiner Funktion bekomme ich komische Syntax Fehler wie:>> Syntax Fehler - unerwartetes Symbol';' --- sck_off;
sck_off muss von dir zuerst definiert werden.
der sck-pin muss als Ausgang gesetzt werden. dann musst du einen Befehl
sck_off definieren, der den sck-pin auf 0 setzt.
#define sck_off Port_WriteBit( ???, PORT_OFF)
etc.
Voraussetzung ist aber, dass du zumindest weißt, wie Portpins zu setzen
und zu löschen sind.
Hallo,
Es sieht wohl doch so aus, dass ich komplett andere Aufgaben bekomme.
Die SPI-Polarität und auch die SPI_Phase sollten so richtig sein.
Da sich mein Praktikum dem Ende neigt und ich mein Hauptprojekt zum Ende
bringen möchte würde ich dem Beitrag hier ein Ende setzen, damit niemand
auf Antworten hofft oder wartet.
Ich bedanke mich sehr bei Andreas und Grundschüler für eure investierte
Zeit und verabschiede mich hiermit.
Grüße.
Lukas schrieb:> ein Display von Conrad, 180847, mit Hilfe des ebenfalls von Conrad> erworbenen, Application Board AVR 32-bit, 192587, in Betrieb zu nehmen.
Ich hoffe nur du hast das alles nicht selbst bezahlen müssen...
Mich hat ja fast der Schlag getroffen als ich die Preise bei Conrad
gesehen habe.
Thread beobachten
Seitenaufteilung abschalten