INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
03.05.2015, 15:47 (Dieser Beitrag wurde zuletzt bearbeitet: 05.05.2015 09:45 von HaWe.)
Beitrag #1
seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
hallo,
ich habe hier einen ganz seltsamen Effekt bei meinem LCD-TFT:

sobald ich diese Funktion
void LCDcls()
einfüge:

Code:
UTFT   myGLCD(QD220A,   A2,    A1,  A5,   0,   A3);  
extern   uint8_t SmallFont[];
int16_t  _curx_, _cury_ ;  // last x,y cursor pos on TFT screen

void LCDcls()  { myGLCD.clrScr(); _cury_ =0; _curx_ =0; }

blockiert mein Display und zeigt nichts mehr an, auch wenn ich diese Funktion niemals aufgerufen habe!
(das Programm allerdings läuft weiter, alle Serial.print() Ausgaben werden auf dem Monitor angezeigt!)
Huh

kommentiere ich die betreffende Zeile aus
Code:
// void LCDcls()  { myGLCD.clrScr(); _cury_ =0; _curx_ =0; }

klappt es wieder!

wie kann das sein ???





ps,
wenn ich diese Zeile
Code:
myGLCD.clrScr(); _cury_ =0; _curx_ =0;

in den Code selber komplett ausgeschrieben reinschreibe (ohne Funktion oder Macro), blockiert das LCD übrigens auch.

Ich kapier's nicht Sad
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.05.2015, 16:14
Beitrag #2
RE: seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
Fehler schon ohne Funktionsaufruf ?
sind die Variablen vielleicht vom System vorbelegt? Probier doch mal, sie anders zu benennen!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.05.2015, 08:38
Beitrag #3
RE: seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
hi,
nein, daran lag es nicht.
Ich habe den Fehler weiter eingrenzt und mal den ganzen Kopf erst mal auskommentiert:
Code:
//int16_t  _curx_, _cury_ ;  // last x,y cursor pos on TFT screen
//void LCDcls()  { myGLCD.clrScr(); _cury_ =0; _curx_ =0; }
(Variablen _curx_, _cury_ werden auch nirgends verwendet)
Kompiliert -> läuft ohne Fehler.

Und jetzt kommts:
schon wenn ich die int16_t Deklaration wieder reinnehme, hängt das Display:
Code:
int16_t  _curx_, _cury_ ;  // last x,y cursor pos on TFT screen
//void LCDcls()  { myGLCD.clrScr(); _cury_ =0; _curx_ =0; }

Kompiliert -> Display hängt nach der ersten Werte-Ausgabe in Setup( )
(wie gesagt: Variablen _curx_, _cury_ werden nirgends verwendet !)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.05.2015, 09:44 (Dieser Beitrag wurde zuletzt bearbeitet: 05.05.2015 09:44 von HaWe.)
Beitrag #4
RE: seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
dasselbe passiert übrigens bei allen beliebigen Variablen, die ich global deklariere:

Code:
int16_t qwert1, qwert2; // nie benutzt !

LCD (UTFT) hängt nach den ersten Bildschirm-Ausgaben in setup(),
Programm läuft aber und alle Ausgaben per Serial.print() funktionieren einwandfrei.

Was ist das denn für ein Mist???

Huh
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.05.2015, 15:51 (Dieser Beitrag wurde zuletzt bearbeitet: 05.05.2015 18:35 von HaWe.)
Beitrag #5
RE: seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
selber Fehler unter 1.6.3

das ist der Code:
Code:
/*
Backpropagation Netz / net
optimiert für Arduino Due
Version BPN 0023
*/

#include <SPI.h>
#include <SD.h>
#include <UTFT.h>
#include <ardustdio.h>
#include <malloc.h>

//-------------------------------------------------------------------------------------
// TFT LCD
//UTFT   myGLCD(Model, SDA=MISO, SCL, CS, RESET, RS)
  UTFT   myGLCD(QD220A,   A2,    A1,  A5,   0,   A3);   // adjust model parameter and pins !

extern   uint8_t SmallFont[];

#define  LCDWhiteBlack()  {myGLCD.setColor(255, 255, 255); myGLCD.setBackColor(  0,   0,   0);}
#define  LCDNormal()      {myGLCD.setColor(255, 255, 255); myGLCD.setBackColor(  0,   0,   0);}
#define  LCDInverted()    {myGLCD.setColor(  0,   0,   0); myGLCD.setBackColor(255, 255, 255);}
#define  LCDWhiteRed()    {myGLCD.setColor(255, 255, 255); myGLCD.setBackColor(255,   0,   0);}
#define  LCDYellowBlue()  {myGLCD.setColor(255, 255,   0); myGLCD.setBackColor( 64,  64,  64);}


#define  LCDmaxX 220
#define  LCDmaxY 176

//int16_t  curx_ , cury_ ;  // last x,y cursor pos on TFT screen
//void lcdcls()  { myGLCD.clrScr(); cury_ =0; curx_ =0; }
//void curLF() { if( cury_ <= (LCDmaxY-10) ) cury_ += 10; else cury_ = 0; }

//-------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------
// SD Card
#define  SD_CSpin  53
File     myFile;
char     fname[64];
//-------------------------------------------------------------------------------------
// misc
#define  TimerMS()    millis()
#define  LRAND_MAX    32767
#define  srand(seed)  randomSeed(seed)
#define  rand()       random(LRAND_MAX)
#define  rando()      ((float)rand()/(LRAND_MAX+1))
int32_t  RSeed;

#define  pswitchon(pin)   (!digitalRead(pin))    // btn press for pinMode(pin, INPUT_PULLUP)
#define  pswitchoff(pin)  ( digitalRead(pin))    // btn press for pinMode(pin, INPUT_PULLUP)
#define  pbtn(pin)        (!digitalRead(pin))    // alias


//-------------------------------------------------------------------------------------
// user interface:  button pad control pins
#define  PIN_ESC    13
#define  PIN_UP     12
#define  PIN_OK     11
#define  PIN_DN      4
#define  PIN_LE      3
#define  PIN_RI      2

//-------------------------------------------------------------------------------------
int8_t  btnpressed() {
   return ( pbtn(PIN_ESC)||pbtn(PIN_UP)||pbtn(PIN_OK)||pbtn(PIN_DN)||pbtn(PIN_LE)||pbtn(PIN_​RI) );
}

//-------------------------------------------------------------------------------------
int8_t   getbtn() {
   int8_t  choice= -1;
  
   // wait until button pad pressed
   while (!  btnpressed() );
  
   if( pbtn(PIN_ESC) ) choice = PIN_ESC;
   if( pbtn(PIN_UP) )  choice = PIN_UP;
   if( pbtn(PIN_OK) )  choice = PIN_OK;
   if( pbtn(PIN_DN) )  choice = PIN_DN;
   if( pbtn(PIN_LE) )  choice = PIN_LE;
   if( pbtn(PIN_RI) )  choice = PIN_RI;
  
   // wait until button pad released
   while (  btnpressed() );
  
   return choice;  
}

//-------------------------------------------------------------------------------------
// neural net
#define  NUMIN      8
#define  NUMHID    12
#define  NUMOUT    10

#define  NUMPAT     8        // <<< number of actually trained patterns;
                             // <<< to do: auto-restrict to actually existing number of patterns!


float    Input[NUMPAT+1][NUMIN+1];
float    Target[NUMPAT+1][NUMOUT+1];
float    WeightLIn[NUMIN+1][NUMHID+1];
float    WeightLOut[NUMHID+1][NUMOUT+1], Output[NUMPAT+1][NUMOUT+1];

int16_t  NumPattern = NUMPAT; // <<< number of actually trained patterns;
                              // <<< to do: auto-restrict to actually existing number of patterns!

int16_t  NumInput = NUMIN, NumHidden = NUMHID, NumOutput = NUMOUT;
int32_t  epoch;
float    Error;

//-------------------------------------------------------------------------------------
// mem test
extern  char _end;
extern  "C" char *sbrk(int i);
char    *ramstart=(char *)0x20070000;
char    *ramend=(char *)0x20088000;


#define MAXMSIZE  16     // number of maximum useable menu options
//================================================================================​=====

int8_t  menu0(char caption[]) {          
  const   char LSIZE=17;

  char    astr[MAXMSIZE][LSIZE+1],              // all options by all inscription strins
          buf[LSIZE+5] ="                     ", // line buffer
          lbuf[LSIZE+5]="---------------------", // blank line buffer
          more[LSIZE+5]="+ + + + + + + + + + +", // next line buffer
          bobross=0;                            // if to paint a beautiful new menu by beautiful colors ;)
        
  static  int8_t  ch=3, maxframe=8, minframe=0; // static for re-entering the menu;
  int8_t  btn, i, lch, MAXVOPT=8;

  strcpy(astr[ 0], "option  a        ");
  strcpy(astr[ 1], "option  b        ");
  strcpy(astr[ 2], "option  c        ");
  strcpy(astr[ 3], "option  d        ");
  strcpy(astr[ 4], "option  e        ");
  strcpy(astr[ 5], "option  f        ");
  strcpy(astr[ 6], "option  g        ");
  strcpy(astr[ 7], "option  h        ");
  strcpy(astr[ 8], "option  i        ");
  strcpy(astr[ 9], "option  j        ");
  strcpy(astr[10], "option  k        ");
  strcpy(astr[11], "option  l        ");
  strcpy(astr[12], "option  m        ");
  strcpy(astr[13], "option  n        ");
  strcpy(astr[14], "option  o        ");
  strcpy(astr[15], "option  last     ");

  if (ch<0) ch=0;

   myGLCD.clrScr();
  //clrscr();
  LCDWhiteRed();
  myGLCD.print(buf, 0, 0);            
  myGLCD.print(caption, (20-strlen(caption))*8/2, 0);

  LCDNormal();
  for (i=minframe; i<maxframe; ++i) {
     sprintf(buf, "%3d %s", i, astr[i]);
     myGLCD.print(buf, 0, (i+1-minframe)*10);
  }    
  if(maxframe<MAXMSIZE) myGLCD.print(more, 0, (i+1-minframe)*10);
  else myGLCD.print(lbuf, 0, (i+1-minframe)*10);

  LCDInverted();
  sprintf(buf, "%3d %s", ch, astr[ch]);
  myGLCD.print(buf, 0, (ch+1-minframe)*10);
  LCDNormal();

  do {
    lch=ch;
    btn=getbtn();      
    if ( (btn==PIN_DN ) ||  (btn==PIN_UP ) ) {      
      if (btn==PIN_DN ) {   if(ch<MAXMSIZE-1)  ch++;  else {
             ch=0;
             minframe=0;
             maxframe=MAXVOPT;
             bobross=1; goto newbob;
          }  
          if(ch>=maxframe) {maxframe++; minframe++; bobross=1; goto newbob;}      
       }  
       else
       if (btn==PIN_UP ) { if (ch > 0)  ch--;  else {
             ch=MAXMSIZE-1;
             maxframe=MAXMSIZE;
             minframe=maxframe-MAXVOPT;
             bobross=1; goto newbob;
          }
          if(ch<minframe) {maxframe--; minframe--; bobross=1; goto newbob;}
       }
   newbob:  
       LCDNormal();
       if(bobross) {
           for (i=minframe; i<maxframe; ++i) {
              sprintf(buf, "%3d %s", i, astr[i]);
              myGLCD.print(buf, 0, (i+1-minframe)*10);
           }              
           bobross=0;
       }  
       else
       {
          sprintf(buf, "%3d %s", lch, astr[lch]);
          myGLCD.print(buf, 0, (lch+1-minframe)*10);
       }
       if(maxframe<MAXMSIZE) myGLCD.print(more, 0, (i+1-minframe)*10);
       else myGLCD.print(lbuf, 0, (i+1-minframe)*10);
      
       LCDInverted();
       sprintf(buf, "%3d %s", ch, astr[ch]);
       myGLCD.print(buf, 0, (ch+1-minframe)*10);
       LCDNormal();
    }  
  } while (!( (btn== PIN_OK) || (btn== PIN_ESC) )) ;            

  if (btn==PIN_ESC) { myGLCD.clrScr();  return -1; }
  else
  if (ch==0)  {    }
  else
  if (ch==1)  {    }
  else
  if (ch==2)  {    }
  else
  if (ch==3)  {    }
  else
  if (ch==4)  {    }
  else
  if (ch==5)  {    }
  else
  if (ch==6)  {    }
  else
  if (ch==7)  {    }

  myGLCD.clrScr();
  return ch;
}                                    




//================================================================================​=====
void memtest(int ypos, char * str) {
   char     sbuf[128];  // output string
  
   char *heapend=sbrk(0);
   register char * stack_ptr asm ("sp");
   struct mallinfo mi=mallinfo();

   sprintf(sbuf,str);
   Serial.println(); Serial.println(sbuf); myGLCD.print(sbuf, 0, ypos);

   sprintf(sbuf, "Dyn.RAM used: %ld", mi.uordblks);
   Serial.println(sbuf); myGLCD.print(sbuf, 0, ypos+10);

   sprintf(sbuf, "Prg.stat.RAM used %ld", &_end - ramstart);
   Serial.println(sbuf); myGLCD.print(sbuf, 0, ypos+20);

   sprintf(sbuf, "Stack RAM used %ld", ramend - stack_ptr);
   Serial.println(sbuf); myGLCD.print(sbuf, 0, ypos+30);

   sprintf(sbuf, "Free mem: %ld", stack_ptr - heapend + mi.fordblks);
   Serial.println(sbuf); myGLCD.print(sbuf, 0, ypos+40);

}






//================================================================================​=====
//================================================================================​=====
void setup() {
   char     sbuf[128];  // output string
  
   Serial.begin(9600);

   pinMode(PIN_ESC,INPUT_PULLUP);
   pinMode(PIN_UP, INPUT_PULLUP);
   pinMode(PIN_OK, INPUT_PULLUP);
   pinMode(PIN_DN, INPUT_PULLUP);
   pinMode(PIN_LE, INPUT_PULLUP);
   pinMode(PIN_RI, INPUT_PULLUP);


   myGLCD.InitLCD();
   //LCDmaxX=myGLCD.getDisplayXSize();
   //LCDmaxY=myGLCD.getDisplayYSize();
   myGLCD.setFont(SmallFont);
   myGLCD.clrScr();

   sprintf(sbuf, "Serial ok, GLCD=%dx%d",LCDmaxX,LCDmaxY);
   Serial.println(sbuf);
   myGLCD.print  (sbuf, 0, 0);

   RSeed = ( ((analogRead(A8)+1017)%100) * (TimerMS()% LRAND_MAX ) % LRAND_MAX );
   srand(RSeed);

   // # DEBUG
   sprintf(sbuf, "Seed= %ld", RSeed);
   myGLCD.print  (sbuf, 0,10);
   sprintf(sbuf, "Rand= %ld", rand() );
   myGLCD.print  (sbuf, 100,10);

   // # DEBUG
   memtest(20, "memtest: setup");
   //myGLCD.clrScr();

}
//================================================================================​=====
//================================================================================​=====

/*******************************************************************************
*   Backpropagation-C-Implementierung:  nn.c   1.0 (C) JOHN BULLINARIA  2004   *
*   verändert und portiert auf Arduino Sketch C: HELMUT WUNDER ("HaWe") 2015   *
*******************************************************************************/

//================================================================================​=====
void ResetNet(){

   for(int i=0; i<= NUMPAT+1; ++i) {
      for(int j=0; j<= NUMIN+1; ++j) {
         Input[i][j] = 0;
      }
   }

   for(int i=0; i<= NUMPAT+1; ++i) {
      for(int j=0; j<= NUMOUT+1; ++j) {
         Target[i][j] = 0;
      }
   }


}


//================================================================================​=====

void displayPattern(int16_t  patt) {
   int16_t p,   // pattern
           i,   // input
           o;   // output

}
//================================================================================​=====

void displayMatrix() {


}


//================================================================================​=====

int16_t  CheckInputs() {
   int16_t   match=-1;  // -1 == no match
    

   return match;
}


//================================================================================​=====
void SetNetPatterns(){

    Input[1][1] = 0;
    Input[1][2] = 0;
    Input[1][3] = 0;
    Input[1][4] = 0;
    Input[1][5] = 0;
    Input[1][6] = 0;
    Target[1][1] = 0; Target[1][2] = 0; Target[1][3] = 0; Target[1][4] = 0; Target[1][5] = 0; Target[1][6] = 1;

    Input[2][1] = 0;
    Input[2][2] = 0;
    Input[2][3] = 1;
    Input[2][4] = 0;
    Input[2][5] = 0;
    Input[2][6] = 1;
    Target[2][1] = 1; Target[2][2] = 1; Target[2][3] = 0; Target[2][4] = 0; Target[2][5] = 1; Target[2][6] = 0;

    Input[3][1] = 0;
    Input[3][2] = 1;
    Input[3][3] = 0;
    Input[3][4] = 0;
    Input[3][5] = 1;
    Input[3][6] = 0;
    Target[3][1] = 1; Target[3][2] = 1; Target[3][3] = 0; Target[3][4] = 1; Target[3][5] = 0; Target[3][6] = 0;

    Input[4][1] = 0;
    Input[4][2] = 1;
    Input[4][3] = 1;
    Input[4][4] = 0;
    Input[4][5] = 1;
    Input[4][6] = 1;
    Target[4][1] = 0; Target[4][2] = 0; Target[4][3] = 0; Target[4][4] = 1; Target[4][5] = 1; Target[4][6] = 0;

    Input[5][1] = 1;
    Input[5][2] = 0;
    Input[5][3] = 0;
    Input[5][4] = 1;
    Input[5][5] = 0;
    Input[5][6] = 0;
    Target[5][1] = 0; Target[5][2] = 0; Target[5][3] = 1; Target[5][4] = 0; Target[5][5] = 0; Target[5][6] = 0;

    Input[6][1] = 1;
    Input[6][2] = 0;
    Input[6][3] = 1;
    Input[6][4] = 1;
    Input[6][5] = 0;
    Input[6][6] = 1;
    Target[6][1] = 1; Target[6][2] = 1; Target[6][3] = 1; Target[6][4] = 0; Target[6][5] = 1; Target[6][6] = 0;

    Input[7][1] = 1;
    Input[7][2] = 1;
    Input[7][3] = 0;
    Input[7][4] = 1;
    Input[7][5] = 1;
    Input[7][6] = 0;
    Target[7][1] = 1; Target[7][2] = 1; Target[7][3] = 1; Target[7][4] = 1; Target[7][5] = 0; Target[7][6] = 0;

    Input[8][1] = 1;
    Input[8][2] = 1;
    Input[8][3] = 1;
    Input[8][4] = 1;
    Input[8][5] = 1;
    Input[8][6] = 1;
    Target[8][1] = 0; Target[8][2] = 0; Target[8][3] = 1; Target[8][4] = 1; Target[8][5] = 1; Target[8][6] = 1;

}

//================================================================================​=====
uint32_t BPTime;



void DisplayNetOut(int16_t code) {
    int16_t   i, o, p;
    char     sbuf[128];  // output string
    char msg[20]="! SUCCESS !"  ;
    if (code==0) strcpy(msg,"calc.error");
    if (code==2) strcpy(msg,"user-break");

    /* print network outputs */
    Serial.println(); Serial.println();
    Serial.println(msg);
    Serial.print("Epoch ");
    sprintf(sbuf, "%-6ld:  Err= %8.6f", epoch, Error) ;      
    
    Serial.println(sbuf);  
    myGLCD.print(sbuf, 0, 20);  myGLCD.print(msg, 0, 30);
        
    sprintf(sbuf, "NET TRAINING TIME = %ld sec \n", BPTime/1000);   Serial.println(sbuf);
    
    Serial.println();
    sprintf(sbuf, "Pat   ") ; Serial.print(sbuf);
    for( i = 1 ; i <= NumInput ; i++ ) {
        sprintf(sbuf, "Inp%-3d ", i) ;  Serial.print(sbuf);
    }
    for( o = 1 ; o <= NumOutput ; o++ ) {
        sprintf(sbuf, "Targ%-3d Outp%-3d ", o, o); Serial.print(sbuf);
    }
    for(int p = 1 ; p <= NumPattern ; p++ ) {
       Serial.println();
       sprintf(sbuf, "%3d  ", p) ;  Serial.print(sbuf);
        for( i = 1 ; i <= NumInput ; i++ ) {
            sprintf(sbuf, "%5.2f  ", Input[p][i]) ; Serial.print(sbuf);
        }
        for( o = 1 ; o <= NumOutput ; o++ ) {
            sprintf(sbuf, "%5.2f   %5.2f   ", Target[p][o], Output[p][o]) ;  Serial.print(sbuf);
        }
    }
    Serial.println(); Serial.println();
    sprintf(sbuf, "BPtrained, returning to main()...!") ;  Serial.print(sbuf);
    Serial.println(); Serial.println();

}
//================================================================================​=====

void msg_userctrl() {
   char     sbuf[128];  // output string  

   Serial.println();
   LCDYellowBlue();
   sprintf(sbuf, "net training: PIN_RI(%2d)", PIN_RI);
   Serial.println(sbuf);
   myGLCD.print(sbuf, 0, LCDmaxY-20);
  
   sprintf(sbuf, "enter Menu:   PIN_OK(%2d)", PIN_OK);
   Serial.println(sbuf);
   myGLCD.print(sbuf, 0, LCDmaxY-10);
   LCDNormal();
  
}

//================================================================================​=====
//================================================================================​=====
int16_t  TrainNet() {
    int16_t  i, j, o, p, np, op, ranpat[NUMPAT+1], result=0;
    int32_t  offset=0;
    float    SumH[NUMPAT+1][NUMHID+1];
    float    SumO[NUMPAT+1][NUMOUT+1];
    float    HidOut[NUMPAT+1][NUMHID+1];
    float    DeltaO[NUMOUT+1], SumDOW[NUMHID+1], DeltaH[NUMHID+1];
    float    DeltaWeightLIn[NUMIN+1][NUMHID+1], DeltaWeightLOut[NUMHID+1][NUMOUT+1];
    float    eta = 0.5, alpha = 0.8, smallwt = 0.8;  
    char     sbuf[128];  // output string

    // # DEBUG
    memtest(70, "memtest: TrainBPNet");
    delay(1000);
  
    myGLCD.clrScr();
    Serial.println(); Serial.println();  
    sprintf(sbuf, "NET TRAINING started") ;  Serial.println(sbuf);
    Serial.println();
    myGLCD.print(sbuf, 0, 10);
  
    uint32_t TimeStamp=TimerMS();

    for( j = 1 ; j <= NumHidden ; j++ ) {    /* initialize WeightLIn and DeltaWeightLIn */
        for( i = 0 ; i <= NumInput ; i++ ) {
            DeltaWeightLIn[i][j] = 0.0 ;
            WeightLIn[i][j] = 2.0 * ( rando() - 0.5 ) * smallwt ;
        }
    }
    for( o = 1 ; o <= NumOutput ; o ++ ) {    /* initialize WeightLOut and DeltaWeightLOut */
        for( j = 0 ; j <= NumHidden ; j++ ) {
            DeltaWeightLOut[j][o] = 0.0 ;
            WeightLOut[j][o] = 2.0 * ( rando() - 0.5 ) * smallwt ;
        }
    }

    for( epoch = 0 ; epoch <= 100000 ; epoch++) {    /* iterate weight updates */
        for( p = 1 ; p <= NumPattern ; p++ ) {    /* randomize order of individuals */
            ranpat[p] = p ;
        }
        for( p = 1 ; p <= NumPattern ; p++) {
            np = p + rando() * ( NumPattern + 1 - p ) ;
            op = ranpat[p] ; ranpat[p] = ranpat[np] ; ranpat[np] = op ;
        }
        Error = 0.0 ;
        for( np = 1 ; np <= NumPattern ; np++ ) {    /* repeat for all the training patterns */
            p = ranpat[np];
            for( j = 1 ; j <= NumHidden ; j++ ) {    /* compute hidden unit activations */
                SumH[p][j] = WeightLIn[0][j] ;
                for( i = 1 ; i <= NumInput ; i++ ) {
                    SumH[p][j] += Input[p][i] * WeightLIn[i][j] ;
                }
                HidOut[p][j] = 1.0/(1.0 + exp(-SumH[p][j])) ;
            }
            for( o = 1 ; o <= NumOutput ; o++ ) {    /* compute output unit activations and errors */
                SumO[p][o] = WeightLOut[0][o] ;
                for( j = 1 ; j <= NumHidden ; j++ ) {
                    SumO[p][o] += HidOut[p][j] * WeightLOut[j][o] ;
                }
                Output[p][o] = 1.0/(1.0 + exp(-SumO[p][o])) ;   /* Sigmoidal Outputs */

                Error += 0.5 * (Target[p][o] - Output[p][o]) * (Target[p][o] - Output[p][o]) ;   /* SSE */

                DeltaO[o] = (Target[p][o] - Output[p][o]) * Output[p][o] * (1.0 - Output[p][o]) ;   /* Sigmoidal Outputs, SSE */
            }
            for( j = 1 ; j <= NumHidden ; j++ ) {    /* 'back-propagate' errors to hidden layer */
                SumDOW[j] = 0.0 ;
                for( o = 1 ; o <= NumOutput ; o++ ) {
                    SumDOW[j] += WeightLOut[j][o] * DeltaO[o] ;
                }
                DeltaH[j] = SumDOW[j] * HidOut[p][j] * (1.0 - HidOut[p][j]) ;
            }
            for( j = 1 ; j <= NumHidden ; j++ ) {     /* update weights WeightLIn */
                DeltaWeightLIn[0][j] = eta * DeltaH[j] + alpha * DeltaWeightLIn[0][j] ;
                WeightLIn[0][j] += DeltaWeightLIn[0][j] ;
              
                for( i = 1 ; i <= NumInput ; i++ ) {
                    DeltaWeightLIn[i][j] = eta * Input[p][i] * DeltaH[j] + alpha * DeltaWeightLIn[i][j];
                    WeightLIn[i][j] += DeltaWeightLIn[i][j] ;
                }
            }
            for( o = 1 ; o <= NumOutput ; o ++ ) {    /* update weights WeightLOut */
                DeltaWeightLOut[0][o] = eta * DeltaO[o] + alpha * DeltaWeightLOut[0][o] ;
                WeightLOut[0][o] += DeltaWeightLOut[0][o] ;
                for( j = 1 ; j <= NumHidden ; j++ ) {
                    DeltaWeightLOut[j][o] = eta * HidOut[p][j] * DeltaO[o] + alpha * DeltaWeightLOut[j][o] ;
                    WeightLOut[j][o] += DeltaWeightLOut[j][o] ;
                }
            }
        }
        if( epoch % 10 == 0 )
        {
           sprintf(sbuf, "%-6ld:  Err= %8.6f", epoch, Error) ;
           Serial.print("Epoch "); Serial.println(sbuf);
           myGLCD.print(sbuf, 0, 20);
        }

        if(Error < 0.002) {result=1; break;}                          // stop learning when 'near enough'
        if(pswitchon(PIN_ESC)){delay(10); while(pswitchon(PIN_ESC)); result=2; break;} // stop after Btn press-and-release
    }

    BPTime = TimerMS() - TimeStamp;
    return result ;
}

/*******************************************************************************/
/*
#define  PIN_ESC    13
#define  PIN_UP     12
#define  PIN_OK     11
#define  PIN_DN      4
#define  PIN_LE      3
#define  PIN_RI      2
*/


//================================================================================​=====
void loop() {
   int16_t  result;
   int8_t   quit=0, choice;
   char     sbuf[128];  // output string

   ResetNet();
   msg_userctrl();

   while(!quit) {
      if( pswitchon(PIN_RI) )  {
         delay(10); while( pswitchon(PIN_RI) );
         SetNetPatterns();
         result=TrainNet();
         DisplayNetOut(result);
         msg_userctrl();
      }

      CheckInputs();
    
      if( pbtn(PIN_OK) )  {
         delay(10); while( pbtn(PIN_OK) );
         choice=menu0("Main Menu 0");
         sprintf(sbuf,"Menu-choice: %d", choice);
         Serial.print (sbuf);
         myGLCD.print(sbuf, 0, 30);
         msg_userctrl();
        
      }
   }

   sprintf(sbuf, "\n\nGoodbye!\n\n") ;  Serial.print(sbuf);
   while(true);
  
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.05.2015, 16:02
Beitrag #6
RE: seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
(05.05.2015 09:44)HaWe schrieb:  dasselbe passiert übrigens bei allen beliebigen Variablen, die ich global deklariere:
Speicher voll?

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.05.2015, 16:08 (Dieser Beitrag wurde zuletzt bearbeitet: 05.05.2015 16:17 von HaWe.)
Beitrag #7
RE: seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
hatte ich auch zuerst vermutet, aber dann müsste das Programm ja komplett hängen, tut es aber nicht: Serial gibt ja fleißig Daten aus!

der Programm-interne memcheck sagt aber auch:

memtest: setup
Dyn.RAM used: 0
Prg.stat.RAM used 7380
Stack RAM used 376
Free mem: 90548

ps,
genau diese Angabe wird auch noch auf dem Display angezeigt, dann ist hier Schicht.

Anschließend sollte ein kleines Steuerungsmenü angezeigt werden, das passiert aber nur per Serial.print (zur Kontrolle), nicht mehr aber auf dem TFT Display.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.05.2015, 17:40 (Dieser Beitrag wurde zuletzt bearbeitet: 05.05.2015 17:52 von rkuehle.)
Beitrag #8
RE: seltsamer Effekt bei LCD-TFT mit GLCD-Funktion
Code:
UTFT   myGLCD(QD220A,   A2,    A1,  A5,   0,   A3);
Mal als Test anstatt 0 /A0 den Pin A4 gesetzt?
Grüße Ricardo
PS: Ich würde zum Probieren mal memtest() nicht im setup() aufrufen und gucken ob das Display weiter macht.

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Funktion mit Parameterübergabe - u8g torsten_156 8 395 22.06.2016 18:53
Letzter Beitrag: Pit
  Funktion in Loop einmalig ausführen Haustechno 4 643 09.03.2016 22:43
Letzter Beitrag: Haustechno
  Problem mit KS0108 GLCD und Libary MKnet83 8 810 13.02.2016 09:43
Letzter Beitrag: amithlon
  HC-05 Modul auf Funktion prüfen. arduinofan 2 360 03.02.2016 19:18
Letzter Beitrag: arduinofan
  Eine Funktion vorher definieren ? arduinofan 23 2.001 30.12.2015 08:42
Letzter Beitrag: amithlon
  Funktion/Methode mit mehr als einem Ausgangswert Marduino_UNO 18 1.247 20.10.2015 10:30
Letzter Beitrag: Marduino_UNO
  PulseIn-Funktion unklar alpenpower 6 1.281 24.07.2015 10:05
Letzter Beitrag: Scherheinz
  auslagern von Funktion aus der void loop? MaHaI976 19 2.862 22.06.2015 20:38
Letzter Beitrag: MaHaI976
  Funktion aus Wertepunkten erstellen- wie ? HaWe 6 1.507 05.06.2015 07:53
Letzter Beitrag: HaWe
  C-Code für eine substring-Funktion: richtig ? HaWe 1 669 27.05.2015 14:01
Letzter Beitrag: HaWe

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste