OSD programm mit einem ATmega32u4

[Stephen (Gast)]

Hallo,

ich stehe vor einer Mauer und komme leider nicht weiter und suche daher 
hier nach rat.

zum Projekt:
ich möchte ein ATmega32u4 mit einem MAX7456 verbinden um so auf ein 
Kamerabild eine Textausgabe zu geben.

das ist bis jetzt mein Programmcode

/*******************************************************************************************/
/*** Einbinden der Include und Define Dateien **********************************************/
/*******************************************************************************************/
#include <stdio.h>          // Einbinden der Standard I/O Ports
#include <avr/io.h>      //Einbinden Input und Outputs des ATmegas
#include <util/delay.h>    // Einbinden Wartezeit
/*** Port Bits *****************************************************************************/

/*** Globale Variablen *********************************************************************/
int status = 0;                     // bei Programmstart alles O.K.
unsigned int Ticks, geschrieben;    // Hilfsvariablen
unsigned char minE,minZ,stdE,stdZ;  // Variablen zum Arbeiten mit Uhrzeit


/*******************************************************************************************/
/*** Register bitweise beschreiben *********************************************************/
/*******************************************************************************************/
void reg_schreiben(int regAdressen,unsigned int regDaten)
{
  unsigned int teiler;    // Variable für die Bitmaske
  unsigned int zaehler;   // Zählvariable
  
  DDRB |= (1 << PB0); // PB0 als Ausgang festlegen
  DDRB |= (1 << PB1); // PB0 als Ausgang festlegen
  DDRB |= (1 << PB2); // PB0 als Ausgang festlegen
  //DDRB |= (1 << PORTB3); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB4); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB5); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB6); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB7); // PD0 als Ausgang festlegen
  
  //DDRB &= ~(1 << PORTB0); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB1); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB2); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB3); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB4); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB5); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB6); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB7); // PD0 als Eingang festlegen
  
  PORTB &= ~(1 << PB0);   //PB0 Low // Chipselect auf Null Serielle Übertragung beginnen
  PORTB &= ~(1 << PB1);   //PB1 High // Ruhezustand für Clocksignal
  teiler=128;             // Bitmaske (1000 0000) für das MSB
  for(zaehler=0;zaehler<8;zaehler++) // Zählschleife für acht Durchläufe
  {
    if(regAdressen&teiler) // Die Bitwerte von regAdressen und teiler verunden, bei eins...
    {
      PORTB |= (1 << PB2);         //...SDIN auf eins setzen und senden des Bits vorbereiten
    }
    else                 // Wenn regAdressen und teiler nach dem verunden nicht eins ergeben...
    {
      PORTB &= ~(1 << PB2);          //...wird SDIN auf null gesetzt und senden des Bits vorbereiten
    }
    PORTB |= (1 << PB1);               // Sendetakt, Bit bei positiver Flanke senden
    PORTB &= ~(1 << PB1);               // Sendetakt zurücksetzen
    teiler/=2;           // Teilergrundwert durch zwei teilen um nächstes Bit anzusprechen
  }
  PORTB &= ~(1 << PB2);         // SDIN auf Null setzen um das Ende des Datenwortes zu definieren
  PORTB &= ~(1 << PB1);          // Setzt das Taktsignal auf Null keine falschen Signale zu erzeugen
  teiler=128;     // teiler für die nächste Schleife vorbereiten
  _delay_ms(1);    // 1ms Wartezeit damit der MAX7456 die Daten verarbeiten kann bevor die nächsten Daten gesendet werden
  for(zaehler=0;zaehler<8;zaehler++) // Acht Schritte Zählschleife
  {
    if(regDaten&teiler)  // Die Bitwerte von regAdressen und teiler addieren bei eins...
    {
      PORTB |= (1 << PB2);          //...SDIN auf eins setzen und senden des Bits vorbereiten
    }
    else                 // Wenn regAdressen und teiler nach dem verunden nicht eins ergeben...
    {
      PORTB &= ~(1 << PB2);          //...wird SDIN auf null gesetzt und senden des Bits wird vorbereitet
    }
    PORTB |= (1 << PB1);               // Sendetakt, Bit bei positiver Flanke senden
    PORTB &= ~(1 << PB1);               // Sendetakt zurücksetzen
    teiler/=2;           // Teilergrundwert durch zwei teilen um nächstes Bit anzusprechen
  }
  PORTB &= ~(1 << PB2);        // SDIN auf Null setzen um das Ende des Datenwortes zu definieren
             // Ende der seriellen Datenübertragung
  PORTB |= (1 << PB0);
  _delay_ms(1);    // 1ms Wartezeit damit der MAX7456 die Daten verarbeiten kann bevor die nächsten Daten gesendet werden
}

/*******************************************************************************************/
/*** Textausgabe Kamera ************************************************************************/
/*******************************************************************************************/
void ausgabe_kamera (void)
{
    /*** Eine 1 ***/
    reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
    reg_schreiben(0x06,0x26);   // Bestimmt die Position des Zeichens auf dem Bildschirm
    reg_schreiben(0x07,0x01);   // Legt das zu schreibende Zeichen fest
}

/*******************************************************************************************/
/*** Textausgabe wenn Signal da, kein Alarm ************************************************/
/*******************************************************************************************/
void cam_ok (void)
{
  /***************** Kamera ***************/
  /*** Groß K ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x20);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x15);   // Legt das zu schreibende Zeichen fest

  /*** klein a ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x21);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x25);   // Legt das zu schreibende Zeichen fest

  /*** klein m ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x22);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x31);   // Legt das zu schreibende Zeichen fest

  /*** klein e ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x23);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x29);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x24);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest

  /*** klein a ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x25);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x25);   // Legt das zu schreibende Zeichen fest
}

/*******************************************************************************************/
/*** Textausgabe "Error" *******************************************************************/
/*******************************************************************************************/
void error (void)
{
  /*** Groß E ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x20);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x0F);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x21);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x22);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest

  /*** klein o ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x23);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x33);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x24);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest
}

/*******************************************************************************************/
/*** Statusabfrage der einzelnen Zustände **************************************************/
/*******************************************************************************************/
void abfrage_status (unsigned char i)
{
  if(i==0)  // Sorgt für reibungslose Darstellung im Alarmfall bzw. Signalausfall
  {
    /*** OSD vorbereiten ***/
    reg_schreiben(0x00,0x40);   // OSD für Konfiguration ausschalten
    reg_schreiben(0x04,0x44);   // 8Bit Übertragungsmodus wählen und alle OSD bezogenen Register zurücksetzen
  }
  switch (0)
  {
    case 0:     cam_ok();           // OSD Textausgabe "PAL S14 Kamera"
    ausgabe_kamera();   // OSD Textausgabe der aktiven Kamera
    break;
      
    default:    error();            // OSD Textausgabe "Kein Signal Kamera"
  }
  reg_schreiben(0x00,0x48);   // OSD nach der Konfiguration wieder einschalten
}
/*******************************************************************************************/
/*** Hauptprogramm *************************************************************************/
/*******************************************************************************************/
void main (void)
{
  while(1)
  {
    error();
  }
}

bitte um mithilfe.
ich hab leider keine ahnung mehr was ich noch machen kann

[Rufus Τ. F. (rufus)]

Stephen schrieb:
> ich hab leider keine ahnung mehr was ich noch machen kann

Du könntest versuchen, Dein Problem zu beschreiben. Derzeit sieht man 
nur, daß Du das hier nicht gelesen hast:

Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang.

Aber das wird nicht Dein Problem sein, da bin ich mir sicher.

Was erwartest Du jetzt? Daß jemand Deine (nicht näher beschriebene 
Schaltung) nachbaut, Dein Programm übersetzt, laufen lässt und versucht, 
herausfzufinden, wo etwas nicht geht?

[Stephen (Gast)]

Ah sorry :/ war ein wenig im Stress.

Also folgendes.

Ich möchte mithilfe eines ATmegas32u4 und dem MAX7456 eine 
Schrifteinblendung auf ein Kamera-bild erzeugen.

Problem ist wenn ich das Programm lade sehe ich keine Bild Einblendung.

hab an den SPI Ports MOSI etc. mit einem Oszi gemessen und festgestellt 
das irgendeine Datenübertragung statt findet.

leider bekomme ich trotz alldem keine Schrifteinblendung.

Entwickelte Hardware ist leider noch nicht auf dem Papier gelandet wird 
aber schnellst möglich nachgeholt.


Jetzt hoffe ich mir das mir jemand helfen kann mit mir zusammen das 
problem zu lösen.

[Karl M. (Gast)]

Wie geht den dass ?

Stephen schrieb:
> Entwickelte Hardware ist leider noch nicht auf dem Papier gelandet wird
> aber schnellst möglich nachgeholt.

per Versuch und Misserfolg ?

Ich kann mir nicht vorstellen ohne Dokumentation zu entwickeln.
Deshalb erstelle ich immer zu erst einen Schaltplan und setze dies dann 
über eine Platine in reale Hardware um.

[Rufus Τ. F. (rufus)]

Karl M. schrieb:
> Wie geht den dass ?

au-au-aua.

[Stephen (Gast)]

naja ich habe mir die standart schaltplänen für die jeweiligen Chips 
angeguckt und habe diese dann nachgebaut und per SPI schnittstelle 
verbunden

im anhang sind diese schaltpläne auf die mein Versuch aufgebaut ist

[Stephen (Gast)]

B0 als Chipselect signal
B1 als Clock signal
B2 als SDIN signal
das sind die Pins für meine Datenübertragung auf den MAX

[wendelsberg (Gast)]

Aus Deinen - sorry fuer die harten Worte, hingerotzten Fragmenten - kann 
man nicht einmal erkennen, ob Du nicht eventuell Ein- und Ausgang 
vertauscht hast.

Aber mal grundsaetzlich: Kannst Du ueberhaupt mit dem MAX7456 
kommunizieren?
Der wird ja irgendwelche Register haben, die solltest Du im ersten 
Schritt auslesen und anzeigen.

wendelsberg

[Stephen (Gast)]

@wendelsberg ja muss zu geben das ist echt alles einwenig frag würdig 
mit den Infos.
und ich glaube das hilft hier keinen weiter wenn ich nicht nochmal von 
ganz vorne beginne und anfange eine ordentliche Dokumentation zu 
erstellen.

Ich werd erstmal ein schaltplan erstellen und mich dann erneut melden...

trotzdem vielen dank für die schnellen kommentare

[Stephen (Gast)]

Hallo,

ich hab mich jetzt mal ran gesetzt und ein Schaltplan meiner Platine 
angefertigt.

Außerdem habe ich die Programm noch mal angepasst

/*******************************************************************************************/
/*** Einbinden der Include und Define Dateien **********************************************/
/*******************************************************************************************/
#include <stdio.h>          // Einbinden der Standard I/O Ports
#include <avr/io.h>      //Einbinden Input und Outputs des ATmegas
#include <util/delay.h>    // Einbinden Wartezeit
#include <stdlib.h>         //Bibliothek für float to string
#include <stdint.h>      //Standart Integertypen
#include <string.h>      //Bibliothek für Zeichenketten
/*** Port Bits *****************************************************************************/

/*** Globale Variablen *********************************************************************/
unsigned int Ticks, geschrieben;    // Hilfsvariablen


/*******************************************************************************************/
/*** Register bitweise beschreiben *********************************************************/
/*******************************************************************************************/
void reg_schreiben(int regAdressen,unsigned int regDaten)
{
  unsigned int teiler;    // Variable für die Bitmaske
  unsigned int zaehler;   // Zählvariable
  
  DDRB |= (1 << PB0); // PB0 als Ausgang festlegen
  DDRB |= (1 << PB1); // PB0 als Ausgang festlegen
  DDRB |= (1 << PB2); // PB0 als Ausgang festlegen
  //DDRB |= (1 << PORTB3); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB4); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB5); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB6); // PD0 als Ausgang festlegen
  //DDRB |= (1 << PORTB7); // PD0 als Ausgang festlegen
  
  //DDRB &= ~(1 << PORTB0); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB1); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB2); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB3); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB4); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB5); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB6); // PD0 als Eingang festlegen
  //DDRB &= ~(1 << PORTB7); // PD0 als Eingang festlegen

  
  PORTB &= ~(1 << PB0);   //PB0 Low // Chipselect auf Null Serielle Übertragung beginnen
  //PORTB |= (1 << PB0);   //PB0 High // Chipselect auf Null Serielle Übertragung beginnen
  PORTB &= ~(1 << PB1);   //PB1 Low // Ruhezustand für Clocksignal
  teiler=128;             // Bitmaske (1000 0000) für das MSB
  for(zaehler=0;zaehler<8;zaehler++) // Zählschleife für acht Durchläufe
  {
    if(regAdressen&teiler) // Die Bitwerte von regAdressen und teiler verunden, bei eins...
    {
      PORTB |= (1 << PB2);         //...SDIN auf eins setzen und senden des Bits vorbereiten
    }
    else                 // Wenn regAdressen und teiler nach dem verunden nicht eins ergeben...
    {
      PORTB &= ~(1 << PB2);          //...wird SDIN auf null gesetzt und senden des Bits vorbereiten
    }
    PORTB |= (1 << PB1);               // Sendetakt, Bit bei positiver Flanke senden
    PORTB &= ~(1 << PB1);               // Sendetakt zurücksetzen
    teiler/=2;           // Teilergrundwert durch zwei teilen um nächstes Bit anzusprechen
  }
  PORTB &= ~(1 << PB2);         // SDIN auf Null setzen um das Ende des Datenwortes zu definieren
  PORTB &= ~(1 << PB1);          // Setzt das Taktsignal auf Null keine falschen Signale zu erzeugen
  teiler=128;     // teiler für die nächste Schleife vorbereiten
  _delay_ms(10);    // 1ms Wartezeit damit der MAX7456 die Daten verarbeiten kann bevor die nächsten Daten gesendet werden
  
  for(zaehler=0;zaehler<8;zaehler++) // Acht Schritte Zählschleife
  {
    if(regDaten&teiler)  // Die Bitwerte von regAdressen und teiler addieren bei eins...
    {
      PORTB |= (1 << PB2);          //...SDIN auf eins setzen und senden des Bits vorbereiten
    }
    else                 // Wenn regAdressen und teiler nach dem verunden nicht eins ergeben...
    {
      PORTB &= ~(1 << PB2);          //...wird SDIN auf null gesetzt und senden des Bits wird vorbereitet
    }
    PORTB |= (1 << PB1);               // Sendetakt, Bit bei positiver Flanke senden
    PORTB &= ~(1 << PB1);               // Sendetakt zurücksetzen
    teiler/=2;           // Teilergrundwert durch zwei teilen um nächstes Bit anzusprechen
  }
  PORTB &= ~(1 << PB2);        // SDIN auf Null setzen um das Ende des Datenwortes zu definieren
             // Ende der seriellen Datenübertragung
  PORTB |= (1 << PB0);
  //PORTB &= ~(1 << PB0);   //PB0 Low // Chipselect auf Null Serielle Übertragung beginnen
  _delay_ms(1);    // 1ms Wartezeit damit der MAX7456 die Daten verarbeiten kann bevor die nächsten Daten gesendet werden
}

/*******************************************************************************************/
/*** Textausgabe Kamera ************************************************************************/
/*******************************************************************************************/
void ausgabe_kamera (void)
{
    /*** Eine 1 ***/
    reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
    reg_schreiben(0x06,0x26);   // Bestimmt die Position des Zeichens auf dem Bildschirm
    reg_schreiben(0x07,0x01);   // Legt das zu schreibende Zeichen fest
}

/*******************************************************************************************/
/*** Textausgabe wenn Signal da, kein Alarm ************************************************/
/*******************************************************************************************/
void cam_ok (void)
{
  /***************** Kamera ***************/
  /*** Groß K ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x20);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x15);   // Legt das zu schreibende Zeichen fest

  /*** klein a ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x21);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x25);   // Legt das zu schreibende Zeichen fest

  /*** klein m ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x22);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x31);   // Legt das zu schreibende Zeichen fest

  /*** klein e ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x23);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x29);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x24);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest

  /*** klein a ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x25);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x25);   // Legt das zu schreibende Zeichen fest
}

/*******************************************************************************************/
/*** Textausgabe "Error" *******************************************************************/
/*******************************************************************************************/
void error (void)
{
  /*** Groß E ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x20);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x0F);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x21);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x22);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest

  /*** klein o ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x23);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x33);   // Legt das zu schreibende Zeichen fest

  /*** klein r ***/
  reg_schreiben(0x05,0x00);   // Definiert das ein Zeichen in den Videospeicher geschrieben wird
  reg_schreiben(0x06,0x24);   // Bestimmt die Position des Zeichens auf dem Bildschirm
  reg_schreiben(0x07,0x36);   // Legt das zu schreibende Zeichen fest
}

/*******************************************************************************************/
/*** Hauptprogramm *************************************************************************/
/*******************************************************************************************/
void main (void)
{
  while(1)
  {
    ausgabe_kamera();
  }
  return 0;
    
}

desweiteren habe ich jetzt weitere Messungen unternommen und habe 
herausgefunden, dass das Taktsignal vorhanden ist, das auf dem MOSI was 
übertragen wird und das das CS Signal richtig arbeitet.

Trotz alldem bekomme ich immer noch keine Ausgabe auf dem BILDSCHIRM.

habe mehrere Kollegen schon befragt die sich mit Programmierung 
auskennen gefragt. Diese meinten das es auf dem ersten blick erstmal 
alles Gut aussieht.

Bitte um Hilfe!

Danke schon mal im vorraus

[wendelsberg (Gast)]

Ich kann mich nur wiederholen:

wendelsberg schrieb:
> Kannst Du ueberhaupt mit dem MAX7456
> kommunizieren?
> Der wird ja irgendwelche Register haben, die solltest Du im ersten
> Schritt auslesen und anzeigen.

wendelsberg

[Mario L. (mlatzig)]

Wie wendelsberg weiter oben geschrieben hat, würde ich auch 
softwaretechnisch die Kommunikation prüfen und erst einmal langsam 
anfangen.

Wenn ich das erste Mal mit einem mir bisher unbekannten Bausteil 
kommuniziere, versuche ich im ersten Schritt erst einmal irgendein 
Status-Register auszulesen, ohne gleich eine konkrete Funktion 
auszuführen.

Ich habe mal aus Interesse kurz in das Datenblatt geschaut, und es gibt 
hier auch ein STAT-Register (AxH), das ausgelesen werden könnte.

Wenn das Auslesen hier schon nicht klappt, also einem Default-Status 
entsprechend unsinnige Werte, wie z.B. FFH, zurückbekommen würdest, 
würde ich die SPI-Kommunikation so stark verlangsamen, dass man diese 
debuggen kann (es sei denn, man hat gleich einen Logikanalysator).

[Stephen (Gast)]

Mario L. schrieb:
> (es sei denn, man hat gleich einen Logikanalysator).

Wir haben es mit einem Logikanalysator schön darstellen können die 
kommunikation des SPI

Im Anhang sind diese Messdaten zu sehen

erstes Datenwort ist:
0x05,0x00
zweites Datenwort ist:
0x06,0x26
drittes Datenwort ist:
0x07,0x01

als die Kommunikation funktioniert theoretisch

[Mario L. (mlatzig)]

Und das Lesen des STAT-Registers?

Ich will nun mich nicht jetzt intensiv mit dem Datenblatt 
beschäftigen...

Aber zwei Punkte als Hinweis, die mir noch aufgefallen sind:

Power-On-Reset:
"...The display memory is reset, and the OSD is enabled typically
50ms after the supply voltage has stabilized and a sta-
ble 27MHz clock is available. The user should avoid
SPI operations during this time to avoid unexpected
results. After 50ms (typical), STAT[6] can be polled to
verify that the reset sequence is complete (Figure 22)..."

Initialisierung:
Müssen evtl. noch Register zur Initialisierung gesetzt werden?
Register VM0 (z.B. "Bit3 OSB Image enable" und VM1?

Meistens sind ja die Default-Werte nach einem Reset so gesetzt, dass ein 
Baustein deaktiviert (z.B. Sleep Mode) ist und erst irgendwo "enabled" 
werden muss...

[wendelsberg (Gast)]

Stephen schrieb:
> als die Kommunikation funktioniert theoretisch

Nein, um das beurteilen zu koennen, muesste man 1. wissen, welches 
Signal was darstellt (Ok, kann man sich zusammenreimen, aber das sind 
nur Vermutungen) und 2. die andere Richtung der Kommunikation auch 
sehen.

Zusammengereimt: das Senden sieht gut aus, ob der Baustein antwortet, 
sieht man nicht, also auch nicht, ob er es versteht oder ueberhaupt 
bekommt.

wendelsberg

[Jens (Gast)]

Also auf den ersten Blick sieht es so aus als ob du deine SPI per 
Software ansprichst. Also du tackerst die Bits zu Fuß raus. Warum tust 
du das?
Du hast doch sogar die Leitungen der SPI verbunden.
Ich schlage vor, dass du das Hardwaremodul vom Controller verwendest. Da 
kannst du einigen Problemen aus dem Weg gehen.

Wenn du an der Softwarelösung festhalten willst, dann prüfe bitte zuerst 
ob da auch die richtigen Werte geschrieben werden.
Du schreibst ja, dass auf MOSI irgendwas passiert. Aber es ist von 
enormer Wichtigkeit, was da genau passiert!!! ;-)

Gruß, Jens

[Jens (Gast)]

Dein Clock sieht auch nicht nach 50% Duty aus. Überprüfe bitte ob die 
Signale auch lang genug anliegen, dass der MAX das verstehen kann.

[Jens (Gast)]

Und wenn ich mir die Signale genauer anschaue:
Mess mal die Spannung an deinem CS.
Dein Oszi ist auf 100mV/DIV. Das heist, dass dein High Signal am CS nur 
0,5V groß ist.
Oder habe ich mich da verlesen? Prüfe das mal nach.
Eventuell brauchst du am CS einen Pull Up.

[Rufus Τ. F. (rufus)]

Jens schrieb:
> Dein Oszi ist auf 100mV/DIV. Das heist, dass dein High Signal am CS nur
> 0,5V groß ist.

1:10-Tastkopf?

[K. J. (Gast)]

Hm wo ist deine Configuration für den IC, du musst noch einige Register 
setzten damit da was kommt

Ich zwar asm für PIC16 aber da kannst es eigentlich gut raus lesen.

max7456_conf                                    ; Max7456 Config
        movlw   0x00                            ; VM0 Video Mode Register 0 (Write)
        movwf   SPI_DATA_WRITE 
        call            SPI_Send
        movlw   B'01001000'             ; 0 , 1=PAL, 00=Auto Sync, 1=Enable OSD, 0=Enable OSD immer, 0=SW RST, 0=Enable Video Buffer
        movwf   SPI_DATA_WRITE 
        call            SPI_Send       
        movlw   0x01                            ; VM1 Video Mode Register 1
        movwf   SPI_DATA_WRITE 
        call            SPI_Send
        movlw   B'00000100'             ; 0 = NA, 000=Background MODE Brightness 100%, 11=Blinking Time 160ms, 00=Blinking Duty Cycle BT:BT
        movwf   SPI_DATA_WRITE
        call            SPI_Send       
        movlw   0x02                            ; HOS Horizontal Offset Register
        movwf   SPI_DATA_WRITE 
        call            SPI_Send
        movlw   B'00111111'             ;00 = NA, 000000 = Horitzontal Offset (Blanking)
        movwf   SPI_DATA_WRITE
        call            SPI_Send       
        movlw   0x03                            ; HOS Vertical Offset Register
        movwf   SPI_DATA_WRITE 
        call            SPI_Send
        movlw   B'00111111'             ;00 = NA, 000000 = Vertical Offset (Blanking)
        movwf   SPI_DATA_WRITE
        call            SPI_Send       
        return

http://www.grautier.com/grautier/archives/60-C2OSD-V1.0.html

[Jens (Gast)]

@ Rufus Τ. Firefly:

Könnte sein. Aber da er nicht schreibt wie er misst, soll er bitte 
nachsehen dass das passt.
Auch sind an dem Signal unschöne Unterschwinger. Daher meine Vermutung, 
dass da was nicht in Ordnung.

Aber da er sich nicht mehr meldet wird das Problem behoben sein.
Leider bekommt man nicht immer Rückmeldung an was es jetzt gelegen hat. 
So muss jeder andere immer wieder die gleichen Fehler machen. Viele 
holen sich hier Hilfe, aber die Ergebnisse behalten sie für sich.
Schade!

Grüße an alle, Jens

[Rufus Τ. F. (rufus)]

Jens schrieb:
> Aber da er nicht schreibt wie er misst,

Kennen wir doch. Altes Motto: "Wer misst, misst Mist".

[Stephen (Gast)]

Hallo das Problem ist noch nicht gelöst,
dieses Projekt ist eine Nebentätigkeiten meiner Arbeit.
da ich Hauptsächlich im Entstörungsdienst arbeite ist es schwierig 
ständig das Forum durch zu lesen.

Erstmal vielen dank für die vielen aufschlussreichen Antworten.
mir ist selber auch noch eingefallen das ich eventuell die Ports noch 
Konfigurieren muss und werde das mal über das Wochenende versuchen, 
desweiteren kann sein das das CS Signal unsauber aussieht weil ein 
falscher Tastkopf Verwendet wurde.

Durch das Oszi haben wir außerdem die Möglichkeit die übertragenen Daten 
über den SPI Bus ausgeben zu lassen in klar Text und die sind ebenfalls 
gleich der Übertragung. aber ich muss zugeben es war mir auch schon eine 
Überlegung wert heraus zu finden ob der MAX überhaupt versteht was ich 
mit ihm spreche.

[Stephen (Gast)]

Rufus Τ. F. schrieb:
> Jens schrieb:
>> Aber da er nicht schreibt wie er misst,
>
> Kennen wir doch. Altes Motto: "Wer misst, misst Mist".

Ich messe die Taktleitung, CS, und Daten mit einem Messtaster x10

[Stephen (Gast)]

Mario L. schrieb:
> Ich habe mal aus Interesse kurz in das Datenblatt geschaut, und es gibt
> hier auch ein STAT-Register (AxH), das ausgelesen werden könnte.

da ich mich mit ATmega noch nicht so richtig befasst habe und dies das 
erste projekt damit ist, wäre mir ein beispiel dazu sehr lieb.

habe sonst immer nur mit AT89XX programmiert

da ist bei ATmega die PORT ansteuerung und #defines schon anders

Jens schrieb:
> Also auf den ersten Blick sieht es so aus als ob du deine SPI per
> Software ansprichst. Also du tackerst die Bits zu Fuß raus. Warum tust
> du das?

Wie meinst du das? genau?

[Karl H. (kbuchegg)]

Stephen schrieb:
> Mario L. schrieb:
>> Ich habe mal aus Interesse kurz in das Datenblatt geschaut, und es gibt
>> hier auch ein STAT-Register (AxH), das ausgelesen werden könnte.
>
> da ich mich mit ATmega noch nicht so richtig befasst habe und dies das
> erste projekt damit ist, wäre mir ein beispiel dazu sehr lieb.

Als erstes gehst du jetzt mal her und gliederst deine 16 Bit Transfer 
Routine ind 2 8 Bit Einheiten, wobei du dir für den Austausch von 8 Bit 
EINE FUNKTION schreibst und nicht 2 mal den Code wiederholst. (Und die 
Kommentare, die nur das wiederholen, was sowieso jeder im Code lesen 
kann, die lässt du gleich weg bzw. machst dir #define für die 
Pinfunktion). Und gleichzeitig soll die Funktion dann auch die 8 Bit 
sammeln, die von der Gegenseite im Austausch zu deinen 8 Bit gesendet 
werden.

#define MISO PB3
#define MOSI PB2
#define SCLK PB1
#define CS   PB0

uint8_t Transfer8Bit( uint8_t Byte )
{
  uint8_t zaehler;
  uint8_t Teiler = 0x80;
  uint8_t Result = 0x00;

  for( zaehler = 0; zaehler < 8; zaehler++ )
  {
    if( Byte & Teiler )
      PORTB |= (1 << MOSI);
    else
      PORTB &= ~(1 << MOSI);


    Result <<= 1;
    if( PINB & ( 1 << MISO ) )
      Result |= 0x01;

    PORTB |= (1 << SCLK);
    PORTB &= ~(1 << SCLK);

    Teiler >>= 1;
  }

  return Result;
}

Mit dieser Hilfsfunktion setzt du dann die 16 Bit Übertragung zusammen

uint8_t Transfer( uint8_t regAdresse, uint8_t regDaten )
{
  uint8_t Result;

  PORTB &= ~(1 << CS);

  Transfer8Bit( regAdresse );
  _delay_ms(10);

  Result = Transfer8Bit( regDaten );

  PORTB |= (1 << CS);

  _delay_ms(1);

  return Result;
}

Den ganzen Quatsch mit ständiger Neuinitiliasierung des DDR Register 
fasst du in eine eigene Funktion zusammen und rufst die EINMALIG am 
Start von main auf! Es gibt keinen Grund das immer wieder neu zu machen 
und sich damit Register/Datenübertragung sinnlos aufzublasen.

void InitSPI()
{
  DDRB |= (1 << CS);
  DDRB |= (1 << SCLK);
  DDRB |= (1 << MOSI);
  DDRB &= ~( 1 << MISO );
}

Und dann probierst du das STAT Register auszulesen (Register Adresse 
0xA0), ehe du irgendwas anderes machst.
Einen Schritt nach dem anderen. Es ist sinnlos 3300 Seiten Code zu 
schreiben wenn du noch nicht mal weisst, ob deine Übertragung klappt.

[Stephen (Gast)]

okay danke @Karl Heinz

mir bringt aber nichts das register auszulesen wenn ich mir es nicht 
anzeigen kann,

ich benutze kein terminal Programm.

also wenn ich mir das ausgeben lassen möchte müsste ich das über die BNC 
buchse tun aber das wird nicht funktionieren.

ich könnte halt nur versuchen via Oszi den MISO zu messen um zu gucken 
was da eigentlich drauf liegt

[Karl H. (kbuchegg)]

Stephen schrieb:
> okay danke @Karl Heinz
>
> mir bringt aber nichts das register auszulesen wenn ich mir es nicht
> anzeigen kann,

Och du Armer.
Welcher Teufel hat dich geritten als Anfänger ein System aufzubauen, auf 
dem du keine simple Ausgabemöglichkeit hast? Fehler. Schwerer Fehler.

> also wenn ich mir das ausgeben lassen möchte müsste ich das über die BNC
> buchse tun aber das wird nicht funktionieren.

Es gibt auch noch LED an einem ansonsten unbenutzten Pin. Ist zwar nicht 
das Gelbe vom Ei aber besser als nix.

[Karl H. (kbuchegg)]

So wich ich das sehe, hast du am PortD alle 8 Pins frei.
-> 8 Leds drann (samt Vorwiderstand).

[Stephen (Gast)]

Karl H. schrieb:

> Es gibt auch noch LED an einem ansonsten unbenutzten Pin. Ist zwar nicht
> das Gelbe vom Ei aber besser als nix.

LED sind vorhanden und auch schon als hilfsmittel eingesetzt so kann ich 
sehen was passiert.
CS = LED leuchtet
MISO = LED flackert sehr schnell das somit nur ein gedimmtes leuchten 
entsteht
MOSI = identisch MISO
CLK = flackert vor sich hin aber auch relativ schnell

[Karl H. (kbuchegg)]

Stephen schrieb:
> Karl H. schrieb:
>
>> Es gibt auch noch LED an einem ansonsten unbenutzten Pin. Ist zwar nicht
>> das Gelbe vom Ei aber besser als nix.
>
> LED sind vorhanden und auch schon als hilfsmittel eingesetzt so kann ich
> sehen was passiert.
> CS = LED leuchtet
> MISO = LED flackert sehr schnell das somit nur ein gedimmtes leuchten
> entsteht
> MOSI = identisch MISO
> CLK = flackert vor sich hin aber auch relativ schnell

Aha.
Und wie gibst du dir dort das Byte so aus, dass du kontrollieren kannst, 
was du vom MAX gekriegt hast. Falls du überhaupt etwas gekriegt hast?

Gerade als Anfänger ist das WICHTIGSTE überhaupt, dass du irgendwo eine 
Ausgabemöglichkeit hast, auf der du dir Zwischenergebnisse, Bytes die du 
von einer Peripherie gekriegt hast, Messergebnisse, etc. etc. etc. 
einfach und zuverlässig ausgeben lassen kannst! Du stocherst momentan im 
Nebel. Und das musst du abstellen! Der Nebel muss weg. Ein Text-LCD wär 
noch besser aber 8 LED sind schon mal genausoviel wert, wie es eine 20% 
Sehfähigkeit für einen vorher komplett Blinden ist.

[Stephen (Gast)]

Karl H. schrieb:

> Aha.
> Und wie gibst du dir dort das Byte so aus, dass du kontrollieren kannst,
> was du vom MAX gekriegt hast. Falls du überhaupt etwas gekriegt hast?
>
> Gerade als Anfänger ist das WICHTIGSTE überhaupt, dass du irgendwo eine
> Ausgabemöglichkeit hast, auf der du dir Zwischenergebnisse, Bytes die du
> von einer Peripherie gekriegt hast, Messergebnisse, etc. etc. etc.
> einfach und zuverlässig ausgeben lassen kannst! Du stocherst momentan im
> Nebel. Und das musst du abstellen! Der Nebel muss weg. Ein Text-LCD wär
> noch besser aber 8 LED sind schon mal genausoviel wert, wie es eine 20%
> Sehfähigkeit für einen vorher komplett Blinden ist.

Die Ausgabemöglichkeit habe ich via den OSZI
mit dem gerät kann ich mir die übertragenen Daten anzeigen kann in BIN, 
HEX, ASCII

[Karl H. (kbuchegg)]

Schön. Dann gibt es ja kein Problem mehr.
Viel Spass noch.

[Karl H. (kbuchegg)]

Das andere was Anfänger abstellen müssen, das ist die Überheblichkeit zu 
glauben, sie könnten auf Anhieb ein fehlerfreies Programm schreiben. Da 
hilft dir dein OSZI wahnsinnig viel, wenn du in der SPI Routine 
empfangsseitig einen Fehler hast. Dein Oszi zeigt dir zwar (vielleicht) 
die Rückmeldung richtig an, aber was dein Programm 'versteht' kann eine 
ganz andere Sache sein.

Wie gesagt: Viel Spass noch.

[Stephen (Gast)]

Karl H. schrieb:
> Schön. Dann gibt es ja kein Problem mehr.
> Viel Spass noch.

Danke das löst aber immer noch nicht wirklich mein Problem

Ich hab auf Arbeit nicht die besagten Möglichkeiten trotz alldem bin ich 
in der Überzeugung das auch ohne terminal Ausgabe es möglich sein muss 
das Problem irgendwie zu lösen.

Die Hardware ist auch jetzt nicht das non plus ultra.

Denn das ganze Projekt entsteht aus der Not heraus weil das Alte OSD was 
eine andere Firma entwickelt hat zu alt ist und es keine Ersatzteile 
mehr gibt.

Ich bin für jeden Rat offen und verstehe auch die Lösung mit den LED's 
damit ich sehen kann BIT für BIT was mir von MAX zurück gegeben hat.

Aber sobald ich weiß er gibt mir was zurück was ich weiß da wir am MISO 
UND MOSI gemessen haben kann ich sagen er Kommuniziert.

Ich denke das Problem wird daran liegen das der ATmega und der MAX sich 
nicht verstehen, weil sie beide andere Sprachen sprechen...

Und ich werde erstmal versuchen die jeweiligen PORTS und KONFIGURATIONEN 
vorzunehmen vllt bewirkt das was.

[Jens (Gast)]

Hallo Stephan,

zur ersten Frage:
Du setzt die Pins von deinem PortB in Software.
Es gibt aber auch eine Hardware SPI. Schau mal ins Datenblatt. Da kannst 
du den Wert, den du senden willst einfach in ein Register schreiben 
(SPDR) und das Hardware Modul taktet dir die Daten auf die Leitungen.

Zu deinem Debuggen:
Mit dem Oszi kannst du zwar sehen, was auf der Leitung los ist, aber du 
siehst nicht ob der Controller oder der Max das auch verstanden hat.
Das ist wie wenn sich zwei Menschen in unterschiedlichen Sprachen 
unterhalten und du schaust zu. Da weisst du nicht was die reden und die 
anderen beiden wissen das auch nicht. Das ist schlicht sinnlos.

Du musst den Inhalt des Register vom Max einlesen. Dann vergleichen ob 
das auch der Wert ist, den du verschickt hast und wenn das richtig ist 
schaltest du eine LED an. Ansonsten nicht. Dann weisst du ein bisschen 
weiter.

Ich vermute dein Problem in der Funktion reg_schreiben(). Du hast da 
keine Wartezeiten drin. Je nach dem wie schnell der Controller durch 
deine Schleifen im Inneren geht gibt er die Taktsignale aus. Die Zeiten 
für die High-Phase und die Low-Phase vom Clock sollte aber in etwa 
gleich sein. Das wird bei dir nicht der Fall sein.
Du kannst das mit dem Oszi messen. Strecke die Zeit eines Bytes auf die 
gesamte Länge vom Oszi und schau wie lange die Zeiten sind. Da sind auch 
Grenzwerte im Datenblatt angegeben, die man einhalten sollte.
(Das Problem umgehst du mit der Hardware-SPI)

Gruß, Jens

[Stephen (Gast)]

Karl H. schrieb:
> Das andere was Anfänger abstellen müssen, das ist die
> Überheblichkeit zu
> glauben, sie könnten auf Anhieb ein fehlerfreies Programm schreiben. Da
> hilft dir dein OSZI wahnsinnig viel, wenn du in der SPI Routine
> empfangsseitig einen Fehler hast. Dein Oszi zeigt dir zwar (vielleicht)
> die Rückmeldung richtig an, aber was dein Programm 'versteht' kann eine
> ganz andere Sache sein.
>
> Wie gesagt: Viel Spass noch.

Wie gesagt danke das du mir helfen möchtest und bin auch wirklich 
dankbar darüber.
Ich werd das mit den LED ebenfalls versuchen und herrausfinden ob die 
Daten Kommunikation überhaupt zustande kommt

[Stephen (Gast)]

Jens schrieb:
> (Das Problem umgehst du mit der Hardware-SPI)

Das werde ich auch mal versuchen ich danke dir Jens.

werde das aber erst am Wochenende schaffen.

[Karl H. (kbuchegg)]

Jens schrieb:

> für die High-Phase und die Low-Phase vom Clock sollte aber in etwa
> gleich sein.

Wobei das normalerweise nicht so kritisch ist. Der Max reagiert auf die 
steigende Flanke. Mit der fallenden Taktflanke hat er nichts am Hut.

Was natürlich sein kann, ich hab da jetzt das Datenblatt nicht 
hinreichend genau studiert, das ist, dass sein Taktzeiten zu kurz sind. 
Ich denke aber nicht. So ein Schieberegister ist keine Raketentechnik. 
Die sind normalerweise schneller als das was man mit einem 16Mhz 
Prozessor noch schaffen kann.

Wie schon von mehreren Seiten angesprochen: STAT auslesen.

Und ja, ich hab das auch im Datenblatt gesehen, dass der Baustein per 
Default nach einem Reset keine OSD Ausgabe macht. Aber ich hab das 
Datenblatt allerdings auch nur schnell überflogen.

[Stephen (Gast)]

Danke für die vielen Antworten ich denke mal genau das ist der 
springende Punkt das einfach einfach kein OSD ausgegeben wird wegen dem 
Reset ich werd das mal alles überprüfen und mich dann nochmal melden.

[Marc V. (Firma: Vescomp) (logarithmus)]

Stephen schrieb:
> Ich bin für jeden Rat offen und verstehe auch die Lösung mit den LED's
> damit ich sehen kann BIT für BIT was mir von MAX zurück gegeben hat.

 Dein MEGA hat auch EEPROM, da kann man sich die Werte die der MAX
 zuruckgeschickt hat, aufschreiben und spater per ISP oder AvrDude
 auslesen, anstatt einen Haufen LEDs oder OsziBildschirm zu dekodieren.

[Stephen (Gast)]

Wie lese ich denn das STAT register aus.
habt ihr da eventuell ein beispiel code?

[Mario L. (mlatzig)]

Karl Heinz hat weiter oben schon einen Beispiel-Code gepostet und auch 
beschrieben.

Seine Funktion

uint8_t Transfer8Bit( uint8_t Byte )

sendet ein einzelnes Byte über MOSI und liefert gleichzeitig ein ggf. 
empfangenes Byte über MISO zurück...

Da der MAX7456 mit CS Low erst ein Adress-Byte benötigt, und dann als 
zweites ein Daten-Byte braucht bzw. im Falle vom STAT-Register auch ein 
Daten-Byte zurückliefert, hat Karl Heinz dir sogar die entsprechende 
Hilfs-Funktion geschrieben:

uint8_t Transfer( uint8_t regAdresse, uint8_t regDaten )

Du müsstest also nur seine Funktion die Adresse 0xA0 übergeben und als 
zu schreibendes Datenbyte z.B. 0x00 (Wert Null) als Dummy-Byte mitgeben:

uint8_t status = Transfer( 0xA0, 0x00 );

Zurück bekommst du den Wert des STAT-Registers vom MAX7456.

Figure 20 vom Datenblatt zeigt ein ähnliches Beispiel mit Register 0xB0 
(DMDO -  Display Memory Data Out).

[Stephen (Gast)]

Okay danke verstehe wir werden das jetzt mal testen und versuchen 
auszulesen.

ich kann doch theoretisch dann sagen schick beispiel A rüber wenn MAX A 
zurück liefert schalte ein Port mit LED high

[Karl H. (kbuchegg)]

Stephen schrieb:
> Okay danke verstehe wir werden das jetzt mal testen und versuchen
> auszulesen.
>
> ich kann doch theoretisch dann sagen schick beispiel A rüber wenn MAX A
> zurück liefert schalte ein Port mit LED high

Ja das kannst du. Und wenn deine LED schaltet, dann weisst du auch das 
soweit sehr wahrscheinlich alles in Ordnung ist. Spannnend wird es nur, 
wenn die LED nicht angeht. Dann weisst du erst mal nur, dass nicht alles 
in Ordnung ist, hast aber immer noch keinen Plan, wie die Sache 
eigentlich aussieht. Und dann fängt es an interessant zu werden.

[Stephen (Gast)]

kann ich theoretisch über eine SPI schnittstelle womit ich zurzeit 
programmiere auch ein Terminal Programm ansteuern?
und eine normale Printf ausgabe damit mache?

[Karl H. (kbuchegg)]

Stephen schrieb:
> kann ich theoretisch über eine SPI schnittstelle womit ich zurzeit
> programmiere auch ein Terminal Programm ansteuern?

theoretisch ist vieles möglich. Man kann auch eine Serielle 
Schnittstelle komplett in Software aufbauen. Die Frage ist nicht, was 
man theoretisch kann, sondern was du praktisch hinkriegst.
Und nein. Einfach so funktioniert das nicht. Du musst dafür schon 
programmieren. Ich hab mir die LED am Port nicht deswegen ausgedacht, 
weil ich dich in etwas reinlocken will, sondern weil ich versuche zu 
retten was zu retten ist, und du das auch noch stemmen können sollst.

Vielleicht brauchst du die 8 LED nicht und alles funktioniert auf 
Anhieb. Vielleicht.

[Karl H. (kbuchegg)]

Laut Schaltplan sind am Mega32 auch noch die Pins der seriellen 
Schnittstelle frei. Da einen FT232 drann, der die Kommunikation dann auf 
USB bringt und am PC ein Terminalprogramm dazu, ist auch eine Option.
Aber auch hier: Ohne Vorleistung in Form von Hardware und Code wird das 
nichts.

[Stephen (Gast)]

also ich möchte es folgender maßen versuchen

uint8_t Auslesen = 0x00;

Transfer(0xA0, 0x00);

Auslesen = Transfer();

if(Auslesen != 0x00)
    {
      PORTD &= ~(1<<LED1);
      _delay_ms(1000);
      PORTD |= (1<<LED1);
      _delay_ms(1000);
    }
    else
    {
      PORTD &= ~(1<<LED2);
      _delay_ms(1000);
      PORTD |= (1<<LED2);
      _delay_ms(1000);
    }

so würde ich das jetzt überprüfen.

[Karl H. (kbuchegg)]

Stephen schrieb:

> so würde ich das jetzt überprüfen.

Ja dann mach das.

Aber wozu das Blinken? Entweder die LED an LED1 ist an, oder die an 
LED2. Das Blinken ist schon wieder viel zu viel Arbeit ohne dass du 
etwas dafür bekommst. Im Prinzip reicht auch 1 LED. Denn die einzige 
Information die du bekommst (ungleich 0) kannst du mit 2 Zuständen 
anzeigen. Entweder die LED leuchtet oder sie leuchtet nicht

  if( Transfer( 0xA0, 0x00 ) != 0x00 )
    PORTD &= ~(1<<LED1);
  else
    PORTD |= (1<<LED1);

Man muss das ganze auch nicht übermässig kompliziert machen. Ich hätt 
mir ja die 8 LED angeschlossen und geschrieben

  while ( 1 )
    PORTD = Transfer( 0xA0, 0x00 );

dann hätt ich auf den 8 LED direkt den zustand aller Bits im Status 
Register gesehen. Und deswegen auch die 8 LED. Denn der Vergleich mit 
dem Datenblatt hätte dann schon gezeigt, ob ich in der Transfer Routine 
beim Empfang alle Bits auf der richtigen Flanke abnehme, oder ob die ev. 
um 1 Bit verschoben sind.

Aber ist ok. Es geht auch mit einer oder 2 LED. Dafür dass du an dem 
Ding jetzt schon fast 4 Tage rumdokterst, sind die 10 Minuten für das 
Anlöten von ein paar Kabel mit LED ja direkt eine Okkasion. Aber ok. 
Auch debuggen gehört zum Job und muss gelernt werden.

[Stephen (Gast)]

Karl H. schrieb:
> Man muss das ganze auch nicht übermässig kompliziert machen. Ich hätt
> mir ja die 8 LED angeschlossen und geschrieben

Also ich mal mir jetzt ein Kreuz auf ein Blatt und hau mein Kopf rauf.

Das ist echt die Simpelste Lösung und beste die ich mir vorstellen kann 
;)

Danke das wird sofort getestet und das Ergebnis in weniger Minuten 
bekannt gegeben

[Karl H. (kbuchegg)]

Stephen schrieb:
> Karl H. schrieb:
>> Man muss das ganze auch nicht übermässig kompliziert machen. Ich hätt
>> mir ja die 8 LED angeschlossen und geschrieben
>
> Also ich mal mir jetzt ein Kreuz auf ein Blatt und hau mein Kopf rauf.
>
> Das ist echt die Simpelste Lösung und beste die ich mir vorstellen kann
> ;)

?
Was denkst du, warum ich das seit fast 24 Stunden vorschlage?
Was hattest du gedacht, warum ich im Schaltplan nach einem komplett 
freien Port gesucht habe, auf dem man die 8 Bit zweckentfremden kann?

[Stephen (Gast)]

Karl H. schrieb:
> while ( 1 )
>     PORTD = Transfer( 0xA0, 0x00 );


hab es jetzt so probiert und alle LED sind aus.

eventuell ein Kommunikations problem?

[Mario L. (mlatzig)]

Stephen schrieb:
> ich kann doch theoretisch dann sagen schick beispiel A rüber wenn MAX A
> zurück liefert schalte ein Port mit LED high

Ich hab das Gefühl, du weisst noch nicht, was es mit den Adressen für 
die Register und den Registern selbst im MAX auf sich hat. Du kannst 
eigentlich hier nicht erwarten, wenn du ein Byte über SPI schickst, das 
gleiche Byte auch wieder zurückkommt, auch mit Hinblick auf deinem 
zuletzt geposteten Code.

Im Falle des STAT Registers (Adresse 0xA0) dürftest du nicht 0x00 
zurückerhalten, wenn ich die Bits im Datenblatt interpretiere. Das, was 
ich als Dummy-Byte, bezeichnet habe, hat keinen Einfluss auf den 
Rückgabewert der Funktion, also in dem Beispiel oben, der Wert des STAT 
Registers.

[Stephen (Gast)]

Mario L. schrieb:
> Stephen schrieb:
>> ich kann doch theoretisch dann sagen schick beispiel A rüber wenn MAX A
>> zurück liefert schalte ein Port mit LED high
>
> Ich hab das Gefühl, du weisst noch nicht, was es mit den Adressen für
> die Register und den Registern selbst im MAX auf sich hat. Du kannst
> eigentlich hier nicht erwarten, wenn du ein Byte über SPI schickst, das
> gleiche Byte auch wieder zurückkommt, auch mit Hinblick auf deinem
> zuletzt geposteten Code.
>
> Im Falle des STAT Registers (Adresse 0xA0) dürftest du nicht 0x00
> zurückerhalten, wenn ich die Bits im Datenblatt interpretiere. Das, was
> ich als Dummy-Byte, bezeichnet habe, hat keinen Einfluss auf den
> Rückgabewert der Funktion, also in dem Beispiel oben, der Wert des STAT
> Registers.

Das war mir irgendwie schon klar.

Also ich hab die Variante von Karl Heinz und den 8 LED's angewendet
und es noch mal erneut programmiert
und Raus kommt die BIT folge 1011 1111 also 0xBF

[Stephen (Gast)]

Hab jetzt mal eine wartezeit eingebaut um besser die zustände bzw das 
auslesen besser zu entziffern.

der Wert ändert sich ständig der von MISO zurück geliefert wird.

[Mario L. (mlatzig)]

Das wäre jetzt ein Erfolg, du hast eine Rückmeldung vom MAX.

Bit 6 (PD6) ist der wichtigste, der muss ja auf 0 sein (Reset complete).

Hast du ein PAL-Signal am Video-Eingang, dann müsste ja theoretisch 
(laut Datenblatt) ja Bit 0 auf 0 gehen usw...

Du könntest nun anhand des STAT Registers weiter experimentieren, oder 
dich mit der Initialisierung (Beispiel Code auch weiter oben) 
beschäftigen.

[wendelsberg (Gast)]

Karl H. schrieb:
> Laut Schaltplan sind am Mega32 auch noch die Pins der seriellen
> Schnittstelle frei. Da einen FT232 drann, der die Kommunikation dann auf
> USB bringt und am PC ein Terminalprogramm dazu, ist auch eine Option.

Der Atmega32U4 hat USB an Bord, das allerdings muss man auch 
programmieren. Richtig programmiert meldet der sich als serielle 
Schnittstelle am PC an. Das Suchwort dafuer ist die "LUFA Library".

wendelsberg

[Stephen (Gast)]

wir haben folgende bit reihenfolgen zurück bekommen

PD7  PD6  PD5  PD4  PD3  PD2  PD1  PD0
1  0  0  1  1  0  0  1

1  0  1  1  0  0  1  0

1  0  0  0  0  0  0  0

1  0  0  1  1  0  1  1

1  0  1  0  0  0  0  0

1  0  1  0  0  1  1  1

das sind die Werte die wir mal aufnehmen konten

PD6 ist immer LOW

[Mario L. (mlatzig)]

Evtl. fehlt nun hier die Initialisierung. Ich habe ja auch noch nie mit 
dem Baustein gearbeitet, daher kann ich auch jetzt nicht groß 
weiterhelfen.

Habe hier nochmal die Initialisierung von theborg0815 in C-Code für dich 
umgesetzt, die könntest du noch ausprobieren. Das Code-Fragment müsste 
dann vor deiner Endlos-Schleife stehen:

  // VM0 Video Mode Register 0 (Write)
  // 0 , 1=PAL, 00=Auto Sync, 1=Enable OSD, 0=Enable OSD immer, 0=SW RST, 0=Enable Video Buffer
  Transfer(0x00,0b01001000); 
  // VM1 Video Mode Register 1
  // 0 = NA, 000=Background MODE Brightness 100%, 11=Blinking Time 160ms, 00=Blinking Duty Cycle BT:BT
  Transfer(0x01,0b00000100); 
  // HOS Horizontal Offset Register
  // 00 = NA, 000000 = Horitzontal Offset (Blanking)
  Transfer(0x02,0b00111111); 
  // HOS Vertical Offset Register
  // 00 = NA, 000000 = Vertical Offset (Blanking)
  Transfer(0x03,0b00111111);

[Stephen (Gast)]

Mario L. schrieb:
> Evtl. fehlt nun hier die Initialisierung. Ich habe ja auch noch nie mit
> dem Baustein gearbeitet, daher kann ich auch jetzt nicht groß
> weiterhelfen.
>
> Habe hier nochmal die Initialisierung in C-Code für dich umgesetzt, die
> könntest du noch ausprobieren. Das Code-Fragment müsste dann for deiner
> Endlos-Schleife stehen:
>   // VM0 Video Mode Register 0 (Write)
>   // 0 , 1=PAL, 00=Auto Sync, 1=Enable OSD, 0=Enable OSD immer, 0=SW
> RST, 0=Enable Video Buffer
>   Transfer(0x00,0b01001000);
>   // VM1 Video Mode Register 1
>   // 0 = NA, 000=Background MODE Brightness 100%, 11=Blinking Time
> 160ms, 00=Blinking Duty Cycle BT:BT
>   Transfer(0x01,0b00000100);
>   // HOS Horizontal Offset Register
>   // 00 = NA, 000000 = Horitzontal Offset (Blanking)
>   Transfer(0x02,0b00111111);
>   // HOS Vertical Offset Register
>   // 00 = NA, 000000 = Vertical Offset (Blanking)
>   Transfer(0x03,0b00111111);



JA!

genau das war der FEHLER!

[Stephen (Gast)]

Eine sache habe ich noch...

der unterste ausgabe ist bei der Adresse 0xFF

aber leider nur bis hälfte des Bildes.

die HOS und VOS register habe ich schon soweit angepasst

wie bekomme ich das jetzt soweit runter gezogen das es bis zum untersten 
Bild rand schreibbar ist?

[Mario L. (mlatzig)]

Der soll doch 16 Zeilen haben. Ich zähle bei dir um die 10 Zeilen. Auch 
Register 0x05 (DMAH) Bit 0 (für Address Bit 8) mit benutzt ...?

[häh (Gast)]

Warum ist das Bild so schief?

[Stephen (Gast)]

danke das mit dem Register werd ich mal versuchen...
werd mich mal weiter in das Projekt vertiefen...

DANKE FÜR ALLE DIE MITGEHOLFEN HABEN!

häh schrieb:
> Warum ist das Bild so schief?

weil ich es schief fotografiert habe und weil der Bildschirm abschüssig 
steht