Arduino Nano / Uno - Program (Sketch) läuft auf dem Uno auf dem Nano nicht

**piggituX** · 30.12.2017, 22:46

Hi,

ich muss mich mal einklinken. Ich lese einen 10DOF Gryo / Acc / Mag Sensor aus. Auf einem Uno R3 funktioniert das.. Ich nutze das für einen Balancer mit Stepper Motoren. da ich dort gerade Probleme habe die Stepper richtig laufen zu lassen, dachte ich mir ich bau das Ganze nochmal auf.

Da hab ich nun einen Nano V3 und bei diesem läuft das Program nicht durch, bzw. er hängt sich auf... Ursache ist der Timer1 den ich setze.. lasse ich die Routine weg läufts..

https://www.arduino.cc/en/Products/Compare dort kann man sehen das die UNO/NANO gleich sind was die Frequenz angeht.

Ich nutze die Arduino IDE und lese an der Serial Konsole mit.

Jemand schon mal ähnliches festgestellt, normal hab ich keine Probleme Programme auf beiden µC laufen zu lassen.

**j0k3r** · 31.12.2017, 08:29

HI piggituX

Ich bin noch neu im Arduino/Elektronikbereich aber ich denke auch erfahrene Programmierer werden ohne deinen Code nicht weiterhelfen können.
Aber wenn es auf dem UNO lief, dann sollte es eigentlich auch auf dem Nano laufen.
Hast du beim neuaufbau alles richtig angeschlossen, bzw anpassungen im Code vorgenommen um die anschlüsse von UNO auf Nano zu legen?

Gruß j0k3r

**piggituX** · 31.12.2017, 12:08

Hi,

ich habe nun heute nacht noch bissel getestet, es liegt garnicht am Timer1 sondern eher in der Berechnung des Neigungswinkels, da kommt der Nano leicht aus dem Tritt und ich weiss noch nicht warum, vllt habe ich einen billigen China Clone gerade erwischt, der eine höhrere Toleranz aufweisst. ich Suche mir mal noch nen anderen µC in meinen Schubladen und teste erneut.

Danke für die Antwort j0k3r. Pins habe ich sicherheitshalber nochmal überprüft.

**Rabenauge** · 01.01.2018, 12:06

In der Vergleichstabelle steht aber auch, dass es zwei verschiedene Prozessoren auf dem Nano gibt- einer der beiden hat weniger Hauptspeicher als ein UNO.
Vielleicht reicht der ganz einfach nicht? Bissel komplex sind die Berechnungen ja schon.
Hast du den mit dem 168 oder den mit dem 328p?

**piggituX** · 08.01.2018, 11:16

moin,

ja ich habe den 328P habe auch noch einen Mini Pro als Vergleich herangezogen. und da habe ich natürlich auch den 328p mit 5V

. Danke für den Hinweis.

HaWe · 08.01.2018, 11:46

Ich nutze die Arduino IDE und lese an der Serial Konsole mit.

auf wieviel baud ist dein Serial.begin() samt Serial Konsole eingestellt? 115200?

**piggituX** · 08.01.2018, 16:05

Zitat von piggituX

Hi,

ich habe nun heute nacht noch bissel getestet, es liegt garnicht am Timer1 sondern eher in der Berechnung des Neigungswinkels, da kommt der Nano leicht aus dem Tritt und ich weiss noch nicht warum, vllt habe ich einen billigen China Clone gerade erwischt, der eine höhrere Toleranz aufweisst.

siehe .... Es liegt nicht am Timer1, ich muss das Prog nochmal überdenken...

HaWe · 08.01.2018, 17:30

Zitat von piggituX

siehe .... Es liegt nicht am Timer1, ich muss das Prog nochmal überdenken...

du schriebst erst etwas über "sich aufhängen" und dass es läuft, wenn du die Routine weg lässt...
was passiert denn jetzt genau, und wie sieht die Berechnung aus?
Stammt die Berechnung von dir selber oder ist sie aus einer Lib?
Hängt sie sich wirklich auf oder ist sie anscheinend nur sehr langsam?

- - - Aktualisiert - - -

lass doch mal diesen abgespeckten Benchmark Test laufen - wenn deine CPU wirklich zu langsam ist oder fehlerhaft rechnet, dann wird es sich hiermit zeigen:

Code:

// HaWe Brickbench
// benchmark test for NXT/EV3 and similar Micro Controllers
// Autor: (C) Helmut Wunder 2013,2014
// ported to Arduino Sketch/Wiring by Helmut Wunder
// freie Verwendung für private Zwecke
// für kommerzielle Zwecke nur nach schriftlicher Genehmigung durch den Autor.
// protected under the friendly Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// http://creativecommons.org/licenses/by-nc-sa/3.0/
//
// version 1.09.1.0022-noDisplay-noSort


#define TimerMS() millis()

unsigned long runtime[8];

//int a[500], b[500], c[500], t[500];

//--------------------------------------------
// Mersenne Twister
//--------------------------------------------

unsigned long randM(void) {
   
   const int M = 7;
   const unsigned long A[2] = { 0, 0x8ebfd028 };

   static unsigned long y[25];
   static int index = 25+1;

   if (index >= 25) {
     int k;
     if (index > 25) {
        unsigned long r = 9, s = 3402;
        for (k=0 ; k<25 ; ++k) {
          r = 509845221 * r + 3;
          s *= s + 1;
          y[k] = s + (r >> 10);
        }
     }
     for (k=0 ; k<25-M ; ++k)
        y[k] = y[k+M] ^ (y[k] >> 1) ^ A[y[k] & 1];
     for (; k<25 ; ++k)
        y[k] = y[k+(M-25)] ^ (y[k] >> 1) ^ A[y[k] & 1];
     index = 0;
   }

   unsigned long e = y[index++];
   e ^= (e << 7) & 0x2b5b2500;
   e ^= (e << 15) & 0xdb8b0000;
   e ^= (e >> 16);
   return e;
}

//--------------------------------------------
// Matrix Algebra
//--------------------------------------------

// matrix * matrix multiplication (matrix product)
 
 void MatrixMatrixMult(int N, int M, int K, double *A, double *B, double *C) {
   int i, j, s;
   for (i = 0; i < N; ++i) {
      for (j = 0; j < K; ++j) {
         C[i*K+j] = 0;
         for (s = 0; s < M; ++s) {
            C[i*K+j] = C[i*K+j] + A[i*N+s] * B[s*M+j];
         }
      }
   }
}


// matrix determinant

double MatrixDet(int N, double A[]) {
   int i, j, i_count, j_count, count = 0;
   double Asub[N - 1][N - 1], det = 0;

   if (N == 1)
      return *A;
   if (N == 2)
      return ((*A) * (*(A+1+1*N)) - (*(A+1*N)) * (*(A+1)));

   for (count = 0; count < N; count++) {
      i_count = 0;
      for (i = 1; i < N; i++) {
         j_count = 0;
         for (j = 0; j < N; j++) {
            if (j == count)
               continue;
            Asub[i_count][j_count] = *(A+i+j*N);
            j_count++;
         }
         i_count++;
      }
      det += pow(-1, count) * A[0+count*N] * MatrixDet(N - 1, &Asub[0][0]);
   }
   return det;
}



//--------------------------------------------
// shell sort
//--------------------------------------------

void shellsort(int size, int* A)
{
  int i, j, increment;
  int temp;
  increment = size / 2;

  while (increment > 0) {
    for (i = increment; i < size; i++) {
      j = i;
      temp = A[i];
      while ((j >= increment) && (A[j-increment] > temp)) {
        A[j] = A[j - increment];
        j = j - increment;
      }
      A[j] = temp;
    }

    if (increment == 2)
       increment = 1;
    else
       increment = (unsigned int) (increment / 2.2);
  }
}

//--------------------------------------------
// gnu quick sort
// (0ptional)
//--------------------------------------------

int compare_int (const int *a, const int *b)
{
  int  temp = *a - *b;

  if (temp > 0)          return  1;
  else if (temp < 0)     return -1;
  else                   return  0;
}

// gnu qsort:
// void qsort (void *a , size_a count, size_a size, compare_function)
// gnu qsort call for a[500] array of int:
// qsort (a , 500, sizeof(a), compare_int)



//--------------------------------------------
// benchmark test procedures
//--------------------------------------------


int test_Int_Add() {
   int i=1, j=11, k=112, l=1111, m=11111, n=-1, o=-11, p=-111, q=-1112, r=-11111;
   int x;
   volatile long s=0;
   for(x=0;x<10000;++x) {
     s+=i; s+=j; s+=k; s+=l; s+=m; s+=n; s+=o; s+=p; s+=q; s+=r;
   }
   return s;
}



long test_Int_Mult() {
  int x,y;
  volatile long s;

  for(y=0;y<2000;++y) {
    s=1;
    for(x=1;x<=13;++x) { s*=x;}
    for(x=13;x>0;--x) { s/=x;}

  }
  return s;
}


#define PI  M_PI


double test_float_math() {

  volatile double s=PI;
  int y;

  for(y=0;y<1000;++y) {
     s*=sqrt(s);
     s=sin(s);
     s=exp(s);
     s*=s;
  }
  return s;
}


long test_rand_MT(){
  volatile unsigned long s;
  int y;

  for(y=0;y<5000;++y) {
     s=randM()%10001;
  }
  return s;
}


double test_matrix_math() {
  int x;

  double A[2][2], B[2][2], C[2][2];
  double S[3][3], T[3][3];
  unsigned long s;

  for(x=0;x<250;++x) {

    A[0][0]=1;   A[0][1]=3;
    A[1][0]=2;   A[1][1]=4;

    B[0][0]=10;  B[0][1]=30;
    B[1][0]=20;  B[1][1]=40;

    MatrixMatrixMult(2, 2, 2, A[0], B[0], C[0]); // <<<<<<<<<<<<<<<<<<<

    A[0][0]=1;   A[0][1]=3;
    A[1][0]=2;   A[1][1]=4;
    MatrixDet(2, A[0]);                          // <<<<<<<<<<<<<<<<<<<

    S[0][0]=1;   S[0][1]=4;  S[0][2]=7;
    S[1][0]=2;   S[1][1]=5;  S[1][2]=8;
    S[2][0]=3;   S[2][1]=6;  S[2][2]=9;

    MatrixDet(3, S[0]);                          // <<<<<<<<<<<<<<<<<<<

  }

  s=(S[0][0]*S[1][1]*S[2][2]);
  return s;
}



// for array copy using void *memcpy(void *dest, const void *src, size_t n);

long test_Sort(){
  unsigned long s;
  int y, i;
/*  
  int t[500];
 
  for(y=0;y<30;++y) {
    memcpy(t, a, sizeof(a));
    shellsort(500, t);
   
    memcpy(t, a, sizeof(b));
    shellsort(500, t);
   
    memcpy(t, a, sizeof(c));
    shellsort(500, t);
  }
*/
  return y;
}

inline void displayValues() {

  char buf[120];
  /*
  myGLCD.clrScr();

    sprintf (buf, "%3d %9ld  int_Add",    0, runtime[0]); myGLCD.print(buf, 0,10);
    sprintf (buf, "%3d %9ld  int_Mult",   1, runtime[1]); myGLCD.print(buf, 0,20);
    sprintf (buf, "%3d %9ld  float_op",   2, runtime[2]); myGLCD.print(buf, 0,30);
    sprintf (buf, "%3d %9ld  randomize",  3, runtime[3]); myGLCD.print(buf, 0,40);
    sprintf (buf, "%3d %9ld  matrx_algb", 4, runtime[4]); myGLCD.print(buf, 0,50);
    sprintf (buf, "%3d %9ld  arr_sort",   5, runtime[5]); myGLCD.print(buf, 0,60);
    sprintf (buf, "%3d %9ld  TextOut",    6, runtime[6]); myGLCD.print(buf, 0,70);
    sprintf (buf, "%3d %9ld  Graphics",   7, runtime[7]); myGLCD.print(buf, 0,80);
  */ 
   
}




int test(){

  unsigned long time0, x, y;
  double s;
  char  buf[120];
  int   i;
  float f;

 /*
  for(y=0;y<500;++y) {
    a[y]=randM()%30000; b[y]=randM()%30000; c[y]=randM()%30000;
  }
 */

 
  time0= TimerMS();;
  s=test_Int_Add();
  runtime[0]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  int_Add",    0, runtime[0]); Serial.println( buf);


  time0=TimerMS();
  s=test_Int_Mult();
  runtime[1]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  int_Mult",   1, runtime[1]); Serial.println( buf);


  time0=TimerMS();
  s=test_float_math();
  runtime[2]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  float_op",   2, runtime[2]); Serial.println( buf);


  time0=TimerMS();
  s=test_rand_MT();
  runtime[3]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  randomize",  3, runtime[3]); Serial.println( buf);
 

  time0=TimerMS();
  s=test_matrix_math();
  runtime[4]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  matrx_algb", 4, runtime[4]); Serial.println( buf);
 


  time0=TimerMS();
  //s=test_Sort();
  runtime[5]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  arr_sort N/A",   5, runtime[5]); Serial.println( buf);
 
 
  // lcd display text / graphs
 
  time0=TimerMS();
  //s=test_TextOut();
  runtime[6]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  TextOut N/A", 6, runtime[6]); Serial.println( buf);

 
  time0=TimerMS();
  //s=test_graphics();
  runtime[7]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  Graphics N/A", 7, runtime[7]); Serial.println( buf);
 

  Serial.println();
 
  y = 0;
  for (x = 0; x < 8; ++x) {
      y += runtime[x];
  }
 
  displayValues();
 
  sprintf (buf, "gesamt ms: %9ld ", y);
  Serial.println( buf);

 
  x=50000000.0/y;
  sprintf (buf, "benchmark: %9ld ", x);
  Serial.println( buf);


  return 1;

}



void setup() {
 
  Serial.begin(115200);
 
}

void loop() {
  char  buf[120];
  test();
 
  sprintf (buf, "Ende HaWe brickbench");   
  Serial.println( buf);

 
  while(1);
}

was gibt er aus bei Tests 0-4?
(die letzten 3 Tests 5-7 werden hier in der abgespeckten Version übersprungen, daher jew. immer 0 - N/A)