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
seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
25.01.2015, 14:46 (Dieser Beitrag wurde zuletzt bearbeitet: 25.01.2015 14:48 von HaWe.)
Beitrag #9
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
die NKawu-lib ist leider ziemlich schlecht und sehr langsam.
Die Karlsen-lib ist da schon viel besser.
Dummerweise ist cpp code lesen nicht meine Stärke Sad
Wenn man jetzt aber die TFT-Ausgabe der Karlsen-Lib durch echtes Hardware-SPI um den Faktor 100-1000 beschleunigen könnte (zumindest auf dem Due), dann wäre tatsächlich schon sehr viel gewonnen...!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.01.2015, 15:57
Beitrag #10
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
Zitat:Wenn man jetzt aber die TFT-Ausgabe der Karlsen-Lib durch echtes Hardware-SPI um den Faktor 100-1000 beschleunigen könnte (zumindest auf dem Due), dann wäre tatsächlich schon sehr viel gewonnen...!
Bei solchen Aussagen frage ich mich allerdings was du mit dem Display eigentlich machen möchtest? Alle Blitz der Welt in Echtzeit darstellenBig Grin
Ne, im Ernst:
Die "Performance" des Arduino-SPI-Datenverkehrs kann ja über SPI.setClockDivider() gesetzt werden. Das ist ein Teiler zur Systemfrequenz.
Standardwert ist hier 4. Außer beim Due 21. Ergo kommen immer 4 MHz raus. Vorteil beim Due ist, dass du den Divider zwischen 1 und 255 stepweise setzen kannst. Die Frage ist nur ob die Libs das dann mitmachen. Der ILI-Controller sollte recht weit mitspielen, anders sieht es schon wieder beim LCD selbst aus (die sind an sich ja recht träge in der Darstellung).
Da bleibt nur testen.
Grüße RK

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.01.2015, 17:32 (Dieser Beitrag wurde zuletzt bearbeitet: 25.01.2015 17:33 von HaWe.)
Beitrag #11
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
es sind vorwiegend 2 Dinge, an denen ich arbeite:
1.) PixyCam: hier sollen die erkannten BLOBS auf dem Display dargestellt werden, ohne die PixyCam und die Objekterkennung auszubremsen.
Z.B. wie hier, ntl. nur die Rechtecke mit Beschriftung:
[Bild: cc_zps767834e4.jpg]

2.) arbeite ich schon lange mit lernfähigen neuronalen Netzen zur Robotersteuerung. Hier sollen die Neuronen-Aktivierungen in Echtzeit auf dem Schirm dargestellt werden, ohne dass die Neuronen-Berechnung durch die Schirmausgabe ausgebremst wird.
https://www.youtube.com/watch?v=2LWqN2NCnfU
(s.z.B. dies hier ab 1:47)


geplant sind bei mir ca. 200-300 Sensor-Neuronen...

Es wäre dabei nicht schlimm, wenn die Visualisierung langsamer ist als die Rechen-Tasks, z.B. dass die Daten schnell in den Screen-Buffer geschrieben (und überschrieben) werden (wie z.B. bei NXT und EV3), aber es darf auf keinen Fall sein, dass sie 1/2 sec den Arduino ausbremsen, bis sie endlich mit der Screen-Ausgabe fertig sind. Aber 10x / sek müssen sie schon 1 Bildschirmseite komplett mit Grafik und Text schreiben und wieder löschen können, wie hier in diesen Benchmarks:
http://www.mindstormsforum.de/viewtopic....095#p64772
wie man sieht, brauchen bei den Arduinos manche Tests 40-240 Sekunden, während sie bei Lego NXT und EV3 gerademal 50-200 MILLIsekunden brauchen.


die grundlegende Frage für mich ist dabei aber:
(25.01.2015 11:56)HaWe schrieb:  Frage:
wenn man es auch die SPI-Pins 50-53(Mega) bzw. 74-76(Due) legt:
wird es dann automatisch zu Hardware -SPI?

denn nur dann könnte man ja theoretisch über den SPI.setClockDivider() die SPI-Geschwindigkeit erhöhen (x4 beim Mega, x21 beim Due)

bei dem Link
http://arduino.cc/en/pmwiki.php?n=Refere...ockDivider

wird von einem SS Pin gesprochen - der ist in der Lib ja auch gar nicht definiert (nur MISO, CLK, CS, RS, RST)

mit ersatzweise CS-Pin 41
SPI.setClockDivider(41, SPI_CLOCK_DIV4); // 41=CS

gibts da keine Probleme, aber auch keine Änderung.

Was ist denn ggf. sonst SS in dieser TFT- Lib? (es heißt doch sonst auch immer CS/SS wimni)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.01.2015, 18:06
Beitrag #12
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
Ja klar,
der SPI Bus ist in der Hardware drin und wird benutzt sobald du die SPI-Lib einbindest und deren Funktionen benutzt.
Der CS-Pin auf dem Display wird mit dem SS-Pin des Arduino verbunden.
Was es damit auf sich hat steht ua. hier: https://learn.sparkfun.com/tutorials/ser...-select-ss

Ob das ganze letztlich schnell genug wird kannst du mit einem einfachen Sketch probieren in dem du über eine Schleife in einer Schleife die x,y-Koordinaten der Pixel setzt, die Pixel ausgibst und die Zeiten zwischen Start und Ende über serial ausgibst. Dabei solltest du die Zeitwerte in ein Array schreiben und erst am Schluss gemeinsam ausgeben.

Grüße RK

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
25.01.2015, 18:22 (Dieser Beitrag wurde zuletzt bearbeitet: 25.01.2015 18:27 von HaWe.)
Beitrag #13
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
ich dache, genau so hätte ich es gemacht, mit diesem Benchmark-Test (Due-Version):
Code:
// hw brickbench
// version 1.08.0022

#include "SPI.h"
#include "UTFT.h"

// Declare which fonts we will be using
extern uint8_t SmallFont[];

//UTFT myGLCD(Model,SDA,SCL,CS,RST,RS)
//QD220A is for QDtech 2.2inch SPI LCD Module,Driver IC:ILI9225

//-----TFT Pin---|----Arduino Pin-----| -------------------Note--------------------|-DPIN/SPI--
//------LED------|---------A0--Vc-----|---Backlight Control,Hight level Enable-----|---Vc------
//------CLK------|---------A1---------|-----Serial Interface Clock Signal----------|---38(76)--
//------SDI------|---------A2---------|-----------Serial Input Signal--------------|---39(75)--
//------RS-------|---------A3---------|------Command or Parameter Sellect----------|---40------
//------RST------|---------A4/RESET---|---------------Reset Signal-----------------|---RESET---
//------CS-------|---------A5/GND-----|----------Chip Sellect Signal---------------|---41/GND--
//VCC:5V DC.
//GND:Ground.
//How to save IO pin(see the notes below):
//note1:LED A0 is also can be connected to 3.3V or 5V,So that Backlight will be always on.
//note2:RST A4 can be connected to MCU reset pin,to save a IO pin.
//note3:CS  A5 can be connected to GND,So that Chip Sellect will be always Enable.

//original:
//UTFT myGLCD(QD220A,A2,A1,A5,A4,A3);   // Remember to change the model parameter to suit your display module!

// variant CLK_A1 SDI_A2 RS_A3;  (A0)LED=Vc  (A4)RST=CPURESET  (A5)CS=GND
//UTFT myGLCD(QD220A,A2,A1, 0, 0,A3);   //

// vaiant dPin SDI=39 CLK=38 RS=40;  LED=Vc  RST=CPURESET  CS=41
//UTFT myGLCD(QD220A,39,38,41, 0,40);   //

// vaiant dSPI MOSI_75 SCK_76 RS_40;  LED=Vc  RST=CPURESET  CS=41
UTFT myGLCD(QD220A,75,76,41, 0,40);   //


#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<5000;++y) {
     s*=sqrt(s);
     s=sin(s);
     s*=cos(10.5*s);
     s=sqrt(s);
     s=exp(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);
  
  
}


int32_t test_TextOut(){
  int  y;
  char buf[120];

  for(y=0;y<20;++y) {  
    myGLCD.clrScr();
    sprintf (buf, "%3d %9d  int_Add",    y, 1000);  myGLCD.print(buf, 0,10);
    sprintf (buf, "%3d %9d  int_Mult",   0, 1010);  myGLCD.print(buf, 0,20);
    sprintf (buf, "%3d %9d  float_op",   0, 1020);  myGLCD.print(buf, 0,30);
    sprintf (buf, "%3d %9d  randomize",  0, 1030);  myGLCD.print(buf, 0,40);
    sprintf (buf, "%3d %9d  matrx_algb", 0, 1040);  myGLCD.print(buf, 0,50);
    sprintf (buf, "%3d %9d  arr_sort",   0, 1050);  myGLCD.print(buf, 0,60);
    sprintf (buf, "%3d %9d  displ_txt",  0, 1060);  myGLCD.print(buf, 0,70);
    sprintf (buf, "%3d %9d  testing...", 0, 1070);  myGLCD.print(buf, 0,80);

  }
  return 66;
}


int32_t test_graphics(){
  int y;
  char buf[120];
  
  
  for(y=0;y<100;++y) {
    myGLCD.clrScr();
    sprintf (buf, "%3d", y);  myGLCD.print(buf, 0,80); // outcomment for downwards compatibility

    myGLCD.drawCircle(50, 40, 10);
    myGLCD.fillCircle(30, 24, 10);
    myGLCD.drawLine(10, 10, 60, 60);
    myGLCD.drawLine(50, 20, 90, 70);
    myGLCD.drawRect(20, 20, 40, 40);
    myGLCD.fillRect(65, 25, 20, 30);
    //myGLCD.drawEclipse(70, 30, 15, 20); //  original test
    myGLCD.drawCircle(70, 30, 15); // alternatively, just if no drawEclipse is avaiable in the Arduino graph libs!

  }
  return 77;
}



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;
  }


  // LcdClearDisplay();

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

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

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

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

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


  time0=TimerMS();
  s=test_Sort();
  runtime[5]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  arr_sort",   5, runtime[5]); Serial.println( buf);
  myGLCD.print(buf, 0,60);

  // lcd display text / graphs

  time0=TimerMS();
  s=test_TextOut();
  runtime[6]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  TextOut", 6, runtime[6]); Serial.println( buf);
  myGLCD.print(buf, 0,70);

  time0=TimerMS();
  s=test_graphics();
  runtime[7]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  Graphics", 7, runtime[7]); Serial.println( buf);
  myGLCD.print(buf, 0,80);


  Serial.println();

  y = 0;
  for (x = 0; x < 8; ++x) {
      y += runtime[x];
  }

  displayValues();

  sprintf (buf, "gesamt ms: %9ld ", y);
  Serial.println( buf);
  myGLCD.print(buf, 0,110);

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

  return 1;

}



void setup() {

  Serial.begin(9600);  
  SPI.setClockDivider(41, 1); // default = 21
  
  // Setup the LCD
  myGLCD.InitLCD();
  myGLCD.setFont(SmallFont);
  myGLCD.setColor(255, 255, 255);
  
}

void loop() {
  char  buf[120];
  test();

  sprintf (buf, "Ende HaWe brickbench");  
  Serial.println( buf);
  myGLCD.print(buf, 0, 140);

  while(1);
}

aber egal, welchen SPI-Devider ich in setup() verwende: die Geschwindigkeit der Display-Tests bleibt immer exakt dieselbe!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.01.2015, 19:15
Beitrag #14
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
Moin,

beim Überfliegen des Sketches ist mir aufgefallen, dass du so ziemlich alles misst, aber nicht die Ausgabegeschwindigkeit des Displays. Was du hier misst sind die Laufzeiten der verschiedenen Mathe-Routinen.
Was auch die Ausgaben runterziehen dürfte sind die serial.print()-Aufrufe.
Es ging dir doch (anfänglich Huh ) um die Ausgabegeschwindigkeit des Displays, oder?
Grüße RK

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
30.01.2015, 14:33 (Dieser Beitrag wurde zuletzt bearbeitet: 30.01.2015 14:35 von HaWe.)
Beitrag #15
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
hallo,
2x nein: Wink
1.) ist es mein kompletter benchmark test, der u.a. AUCH die Display-Geschwindigkeit misst (die 2 letzten Tests). ich hatte keine Lust, ihn zu zerpflücken, da ich auch sonst alle tests nur im Zusammenhang verwende - beim Display-Teil brechen die Arduinos allerdings gewaltig ein (1000x so langsam wie NXT/EV3, obwohl die Rechen-benchmarks durchaus vergleichbar sind)
2.) zieht serial.print nichts runter, weil es vor und nach der gestoppten Zeit (also außerhalb der Testroutinen) aufgerufen wird. Gemessen wird nur der Teil, der auf dem Display ausgegeben wird, d.h. erst Schrift, dann Grafik.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
31.01.2015, 18:04
Beitrag #16
RE: seltsame analog-pin-Steuerung für SPI-TFT LCD auf SPI umschreiben?
Hallo HaWe,
ich bin mir ziemlich sicher, dass ein Ablauf wie diese:
Code:
// LcdClearDisplay();
   time0= TimerMS();;
   s=test_Int_Add();
   runtime[0]=TimerMS()-time0;
   sprintf (buf, "%3d %9ld  int_Add",    0, runtime[0]); Serial.println( buf);
   myGLCD.print(buf, 0,10);
dir nicht sagt wie schnell das Display ein ClearScreen macht, sondern wie lange die Routine test_Int_add() braucht. Sinnvoller wäre aus meiner Sicht:
Code:
// LcdClearDisplay();
   time0= TimerMS();;
   myGLCD.clrScr();
   runtime[0]=TimerMS()-time0;
   sprintf (buf, "%3d %9ld  int_Add",    0, runtime[0]); Serial.println( buf);
   myGLCD.print(buf, 0,10);
Dann sollte in buf der Wert stehen, den das Display für ClearScreen braucht.
Grüße RK
PS: Interessant wäre die Werte für beide Varianten zu sehen.

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
  Bluetooth-Steuerung mit elegoo uno funktioniert nicht Matthias_Arduino 0 156 01.11.2016 19:47
Letzter Beitrag: Matthias_Arduino
  Steuerung eines Schrittmotor und eines Lüfters auf einem Shield phischmi 7 284 18.08.2016 20:58
Letzter Beitrag: phischmi
  Garagentor,- und Beleuchtungs - Steuerung ardu1n1x 2 453 13.07.2016 16:17
Letzter Beitrag: ardu1n1x
  Android App für RGB Steuerung heino_m 5 398 08.05.2016 10:20
Letzter Beitrag: hotsystems
  Motorshield analoge Steuerung -cosmo- 8 1.244 11.02.2016 22:07
Letzter Beitrag: -cosmo-
  Steuerung Motor 12V 20A Maxi290997 2 1.034 13.09.2015 00:13
Letzter Beitrag: Maxi290997
  Shild-Wahl für Servo-Steuerung SkyFox 9 1.122 23.07.2015 12:49
Letzter Beitrag: SkyFox
  wer hat Erfahrung mit analog-Joysticks für Platinen? HaWe 0 654 11.07.2015 22:03
Letzter Beitrag: HaWe
  I2C analog ADC Multiplexer wie PCF8591 aber 8x - welchen? HaWe 0 629 23.06.2015 15:33
Letzter Beitrag: HaWe
  Keys KY-013 Analog Temperature Sensor Pit 0 740 21.03.2015 20:17
Letzter Beitrag: Pit

Gehe zu:


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