Zur Übersicht - INFO - Neueste 50 Beiträge - Neuer Beitrag - Suchen - Zum C-Control-I-Forum - Zum C-Control-II-Forum

Re: Display eDip 240-7 ansteuern Kategorie: Programmierung Basic (von Josef - 20.06.2010 13:05)
Als Antwort auf Re: Display eDip 240-7 ansteuern von PeterS - 18.06.2010 7:43
Ich nutze:
C-Control Pro Mega128
> > > Hi,
> > >
> > > am meisten lernst Du dabei, wenn Du 90% selber machst, und bei Deinen un├╝berwindlichen Hindernissen
> > > um Hilfe fragst. Stell doch einfach hier Fragen, wie das eine oder andere gel├Âst wird.
> > >
> > > Gruss Peter
> >
> > Hallo,
> > gut dann will ich mal zu meiner ersten H├╝rde kommen:
> > Bei der Programmierung der C-Control II mit C2, kann man ein HEX-File in den Flash-Speicher schreiben,
> > worauf dann Systeminterne Routinen zugreifen. Speziell bei dem eDip-Treiber wird auf diesem Weg
> > die komplette String-Verarbeitung und die Checksummen-Berechnung durchgef├╝hrt.
> > F├╝r die Pro habe ich bisher keine vergleichbare Funktion finden k├Ânnen.
> > Da es keine Infos gibt, was in den HEX-Files f├╝r ein Code steckt, kann ich die Funktionen auch nicht mit
> > normalen Code nachbilden.
> > Das ist eigentlich mein gr├Â├čtes Problem beim ├╝bersetzen des Treibers von C2 nach C-Pro.
> >
> > Gru├č NewBee
>
> Die HEX-Files sind Assemblerroutinen f├╝r eine andere CPU. Die Stringverarbeitung und die
> Checksummenberechnung mu├č man dann per Hand neu schreiben.
>
> Gruss Peter

Hallo

ich habe ein Projekt mit dem eDIP 240-7LWTP gemacht.
ich kann nur Peter mit der Aussage "am meisten lernst Du dabei, wenn Du 90% selber machst"
zustimmen.

Anbei sende ich dir trotzdem meine Files:
Ich habe die Programme jedoch nur auf meine Bed├╝rfnisse angepasst.
//-------------- Programm f├╝r Ausgabe von Steuercodes bzw. Texten --------------
//
// Bei Textausgabe len=Textl├Ąnge, code1/2 entsprechende Steuerzeichen,
// x1/y1/x2/y2 Positionsplatzhalter, downC/upC sind Zuweisungen f├╝r Tasten-
// definition. x1/y1/x2/y2/downC/upC werden bei Wert 255 ignoriert; len bei 0.
//
void eDIP_cmd(byte len,char code1,char code2,byte x1,byte y1,byte x2,byte y2,
              byte downC, byte upC)
{
  byte m_len;
  m_len=len;
  bcc_eDIP=0;               // Checksummenz├Ąhler auf Null setzten
  if (len>0) len=len+1;     // Textl├Ąnge+NULL (Textabschlu├č)
  len=len+3;                // ESC, code1, code2
  if (x1!=255) len=len+1;       if (y1!=255) len=len+1;
  if (x2!=255) len=len+1;       if (y2!=255) len=len+1;
  if (downC!=255) len=len+1;    if (upC!=255) len=len+1;

  I2C_Start();              // IIC Bus Starten
  I2C_Write(eDIP_W);        // Schreibadresse des Displays auf Bus
  I2C_Write(DC1);           // Protokollbeginn f├╝r Ausgabecode/Text
  bcc_eDIP=bcc_eDIP+DC1;    // Zeichen f. Protokollbeginn zu Checksumme addieren
  I2C_Write(len);           // L├Ąnge der zu ├╝bertragenen Byte angeben
  bcc_eDIP=bcc_eDIP+len;    // Bytel├Ąnge zu Checksumme
  I2C_Write(ESC);           // Befehlseinleitung
  bcc_eDIP=bcc_eDIP+ESC;
  I2C_Write(code1);         // Befehlscode 1 ├╝bertragen
  bcc_eDIP=bcc_eDIP+code1;
  I2C_Write(code2);
  bcc_eDIP=bcc_eDIP+code2;
//~~~~~~~~~~~~~~~~~~~~~~~~~~ Positionen ├╝bertragen ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  if (x1!=255)
  {
    I2C_Write(x1); bcc_eDIP=bcc_eDIP+x1;  // Position ausgeben, Checksumme erh├Âhen
  }
  if (y1!=255)
  {
    I2C_Write(y1); bcc_eDIP=bcc_eDIP+y1;
  }
  if (x2!=255)
  {
    I2C_Write(x2); bcc_eDIP=bcc_eDIP+x2;
  }
  if (y2!=255)
  {
    I2C_Write(y2); bcc_eDIP=bcc_eDIP+y2;
  }
  if (downC!=255)
  {
    I2C_Write(downC); bcc_eDIP=bcc_eDIP+downC;
  }
  if (upC!=255)
  {
    I2C_Write(upC); bcc_eDIP=bcc_eDIP+upC;
  }
  if (m_len==0) Checks_IICstop_ACK();  // Wenn kein Text len=0 -> Abschlu├č
  // ansonsten muss vom aufrufenden Prg noch der Text aufgerufen werden
}

//----------------------- Leseanforderung an Display ---------------------------
void eDIP_cmd_read(char code1)
{
  byte len;
  bcc_eDIP=DC2;
  len=1;
  I2C_Start();
  I2C_Write(eDIP_W);                // Schreiben ins Display
  I2C_Write(DC2);
  I2C_Write(len);
  bcc_eDIP=bcc_eDIP+len;
  I2C_Write(code1);
  bcc_eDIP=bcc_eDIP+code1;
}

//--------------- Programm f├╝r die Vorbereitung der Zeichenausgabe -------------
//Format ist durch ├ťbergabe ├Ąnderbar
void eDIP_Text(char Format)
{
  len=StringLength(Zeichenkette);  // L├Ąnge der ├╝bergebenen Zeichen bestimmen
  eDIP_cmd(len,'Z',Format,TXT_x,TXT_y,255,255,255,255);
  Zeichenk();
}

//------------------- Programm gibt die Zeichen Byteweise aus ------------------
void Zeichenk(void)
{
  int m_Zeichen, i;
  i=0;
  while((Zeichenkette[i])&&(i   {
      switch (Zeichenkette[i])  // Zeichenausgabe
      {
        case '├ť':
        m_Zeichen=├ť;            // Sonderzeichen in Hex ausgeben
        break;
        case '├╝':
        m_Zeichen=├╝;
        break;
        default:
        m_Zeichen=Zeichenkette[i];
      }
      I2C_Write(m_Zeichen);    // Zeichen ans Display senden
      bcc_eDIP=bcc_eDIP+m_Zeichen;  // Checksumme aktualisieren
      Zeichenkette[i]=0;       // Zeichenarray leeren
      i++;
  }
  I2C_Write(NULL);             // Null bedeutet f├╝r Display -> Zeichenende
  bcc_eDIP=bcc_eDIP+NULL;      // Checksumme aktualisieren
  Checks_IICstop_ACK();        // Checksumme ├╝bergeben und ├ťbertragung beenden
  for(i=i;i   // undefinierte Zust├Ąnde im weiteren Programmablauf _< BUG von IDE
}

//-------------- Befehlsbest├Ątigung mit Checksumme und Bus stoppen -------------
void Checks_IICstop_ACK(void)
{
  I2C_Write(bcc_eDIP);              // ├ťbergabe der Checksumme
  I2C_Stop();                       // Bus stoppen
  AbsDelay(1);                      // Verz├Âgerung notwendig, da Display f├╝r die
                                    // Bereitstellung der Daten Zeit ben├Âtigt
  eDIP_ACK();                       // Best├Ątigung von Display abholen
}

//------------------------- IIC Bus stoppen ------------------------------------
void eDIP_ACK(void)
{
  I2C_Start();
  I2C_Write(eDIP_R);                // Lesemodus beim Display einstellen
  eDIP_Daten[i]=I2C_Read_NACK();    // Best├Ątigung vom Display anfordern
  #ifdef TEST
  Msg_WriteText("  eDIP Best.:"); Msg_WriteWord(eDIP_Daten[i]);
  #endif
  I2C_Stop();
}

//---- Programm f├╝r alternative Touch-Abfrage(pullen) anstatt SBUF Interrupt ---
/*
eDIP_read_bcc=0; i=0; eDIP_Daten[i]=0;
if ((Port_ReadBit(eDIP_SBUF)==0)&&(eDIP_Daten[i]!=255))
{
  eDIP_cmd_read('S');
  Checks_IICstop_ACK();
  eDIP_ACK();
  if (eDIP_Daten[i]==DC1)
  {
    eDIP_read_bcc=eDIP_Daten[i];
    eDIP_ACK();
    send_len=eDIP_Daten[i];
    eDIP_read_bcc=eDIP_read_bcc+eDIP_Daten[i];
    for(i=0;i     {
      eDIP_ACK();
      eDIP_read_bcc=eDIP_read_bcc+eDIP_Daten[i];
    }
  i++;
  eDIP_ACK();
  Msg_WriteText("  eDIP-Check:"); Msg_WriteWord(eDIP_Daten[i]);
  Msg_WriteText("  Check:"); Msg_WriteWord(eDIP_read_bcc);
  }
}
*/
void ISR_SBUF(void)
{
    Ext_IntDisable(5);
    int irqcnt;
    irqcnt=Irq_GetCount(INT_5);
    byte eDIP_read_bcc, send_len;
    for (i=0;i     i=0;  eDIP_read_bcc=0; send_len=0;

    eDIP_cmd_read('S');        // Sendepuffer anfordern
    Checks_IICstop_ACK();      // ACK vom eDIP abholen
    if (eDIP_Daten[i]!=ACK)
    {
    Msg_WriteText("KEIN ACK!!!!!!!!!!!!");
    Msg_WriteWord(eDIP_Daten[i]);
    }
    eDIP_ACK();                // DC1 abholen
    if (eDIP_Daten[i]==DC1)
    {
      eDIP_read_bcc=eDIP_Daten[i];  // Checksumme aktualisieren->DC1
      eDIP_ACK();                   // N├Ąchstes Byte holen
      send_len=eDIP_Daten[i];
      #ifdef TEST
      Msg_WriteText("  eDIP-Touch_len:"); Msg_WriteWord(eDIP_Daten[i]);
      #endif
      eDIP_read_bcc=eDIP_read_bcc+eDIP_Daten[i];
      for(i=0;i       {
        eDIP_ACK();
        eDIP_read_bcc=eDIP_read_bcc+eDIP_Daten[i];
        #ifdef TEST
        Msg_WriteText("  eDIP-Touch:"); Msg_WriteWord(eDIP_Daten[i]);
        #endif
        if (i==eDIP_Dat_limit-1) break;  // Array├╝berlauf verhindern
      }
      eDIP_ACK();
      #ifdef TEST
      Msg_WriteText("  eDIP-Checksumme:"); Msg_WriteWord(eDIP_Daten[i]);
      Msg_WriteText("="); Msg_WriteWord(eDIP_read_bcc);
      #endif
      if ((eDIP_Daten[i]==eDIP_read_bcc)&&(i>0)) eDIP_Touch=eDIP_Daten[i-1];
      else eDIP_Touch=0;
      #ifdef TEST
      Msg_WriteText("  Touch_aktuell:"); Msg_WriteWord(eDIP_Touch); Msg_WriteChar(CR);
      #endif
    }
    else  Msg_WriteWord(eDIP_Daten[i]);
    #ifdef TEST
    Msg_WriteText("  ISR i:");
    Msg_WriteWord(i); Msg_WriteChar(CR);
    #endif
}
Bei der Touchabfrage wird nur die letzte gedr├╝ckte Taste ausgewertet. Baragraph werden auch
nicht ausgewertet.
Du musst noch entsprechende Definitionen durchf├╝hren.

Gru├č
JosefR


    Antwort schreiben


Antworten:

Re: Display eDip 240-7 ansteuern (von Henry Mallon - 23.06.2010 20:38)
    Re: Display eDip 240-7 ansteuern (von tomsfinest - 13.08.2010 9:48)