-         

Ergebnis 1 bis 5 von 5

Thema: Raspi mit Arduino per USB verbinden

  1. #1
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.452

    Raspi mit Arduino per USB verbinden

    Anzeige

    hey,
    wie angekündigt... @mxt u.a.:
    wie gesagt, das mit USB musst du mir mal erklären...

    Bisher verwende ich diesen UART-Verbindungscode, es wäre genial, wenn ich den von UART-Ports auf USB umswitchen könnte...

    http://www.mindstormsforum.de/viewto...tart=15#p67830

    Code:
    /*     Tx master 
     *     Raspberry Pi 
     
           ver 0006.3       
     */
     
    // (C) Helmut Wunder (HaWe) 2015
    // freie Verwendung für private Zwecke
    // für kommerzielle Zwecke nur nach Genehmigung durch den Autor.
    // Programming language: GCC  C/C++, Geany IDE
    // protected under the friendly Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
    // http://creativecommons.org/licenses/by-nc-sa/3.0/
     
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <math.h>
    #include <fcntl.h>
    #include <string.h>
    #include <sys/ioctl.h>
    #include <stdint.h>
    #include <time.h>
    #include <sys/time.h>
    #include <errno.h>
    #include <pthread.h>
    
    #include "VG/openvg.h"
    #include "VG/vgu.h"
    #include "fontinfo.h"
    #include "shapes.h"
    
    
    #include <wiringPi.h>
    #include <wiringSerial.h>
    
    #define  byte  uint8_t
    
    char   * UART  =  "/dev/ttyAMA0";
    int    Serial1;
    
     
    //=====================================================================================
    //  timer
    // millis() and micros() by wiringPi lib!
    
    
    //=====================================================================================
    // openvg + shapes_plus
    
    int _scrwidth_, _scrheight_;
    
    #define vgHidewindow  HideWindow
    #define vgShowwindow  End
    #define vgcls()       ClearWindowRGB(_scrwidth_, _scrheight_, 0, 0, 0);   
    #define vgStart       Start
    #define vgInit        init
    #define vgCleanup     finish
    #define vgFonttype    Fontinfo
    
    int      _fontsize_ = 10;
    Fontinfo _font_     = MonoTypeface;
    
    
    inline void setfontsize(int size) { _fontsize_ = size; }
    
    inline void setfonttype(Fontinfo myfont) { _font_ = myfont; }
    
    inline void lcdprintxytop(float x, float y, char * buf) {
       Text(x, _scrheight_-y, buf, _font_ , _fontsize_);
    }
    
    inline void lcdprintxy(float x, float y, char * buf) {
       Text(x, y, buf, _font_ , _fontsize_);
    }
    
    
    void vgInitgraph() {
       vgInit(& _scrwidth_, & _scrheight_);       // Graphics initialization
    
        vgStart(_scrwidth_, _scrheight_);   // Start the picture
        vgcls();   
       
        Stroke(255, 255, 255, 1);  // Set these at the start, no need to   
        Fill(255,255,255, 1);      // keep calling them if colour hasn't changed
        setfonttype(MonoTypeface);   
        setfontsize(20);
    }
    
    
    
    //=====================================================================================
    // debug monitor
    
    void displayvalues(int line, char * caption, uint8_t array[]) {
      int cnt;
      char sbuf[128];
     
      sprintf(sbuf, "%s cks=%-4d", caption, array[1]);
      //lcdprintxy(0, line, sbuf);
      printf(sbuf); printf("\n");
      for(cnt=0; cnt<8; ++cnt) {
        sprintf(sbuf, "%3d ", array[cnt]);      // print on TFT
        lcdprintxy(cnt*3*8, line+10, sbuf);
        printf(sbuf);
      }   
      printf("\n");
     
    }
    
    //=====================================================================================
    //=====================================================================================
    // serial com
    
    
    const    uint8_t  MSGSIZE=32;
    uint8_t  bsync=255;
    uint8_t  sendbuf[MSGSIZE];
    uint8_t  recvbuf[MSGSIZE];
    
    
    uint8_t calcchecksum(uint8_t array[]) {
      int32_t  sum=0;
      for(int i=2; i<MSGSIZE; ++i) sum+=(array[i]);
      return (sum & 0x00ff);
    }
    
    bool checksumOK(uint8_t array[]){
    return (calcchecksum(array)==array[1]);
    }
    
    // ================================================================
    // addToBuffer and receive function courtesy of chucktodd
    
    bool addToBuffer( uint8_t buf[], uint8_t *cnt, uint16_t timeout){
    bool inSync = *cnt>0;
    unsigned long start=millis();
    while((*cnt<MSGSIZE)&&(millis()-start<timeout)){
      if( serialDataAvail( Serial1 ) ) { // grab new char, test for sync char, if so start adding to buffer
        buf[*cnt] = (uint8_t)serialGetchar( Serial1 );
        if(inSync) *cnt += 1;  // my origional *cnt++ was updating the pointer address, not
                               // the pointed to sendbuffer
        else{
         if(buf[*cnt]==0xFF){
           inSync = true;
           *cnt +=1;
           }
         }
        }
      }
    return (*cnt==MSGSIZE);
    }
    
    
    //=====================================================================================
    
    bool receive(uint8_t * buf, uint16_t timeout, uint8_t *cnt){ // by passing cnt in and out,
    // i can timeout and still save a partial buffer, so a resync costs less (less data lost)
    
    bool inSync=false;
    unsigned long start=millis();
    uint8_t * p;  // pointer into buf for reSync operation
    bool done=false;
    
    do{
      done = addToBuffer(buf,cnt,timeout); // if this return false, a timeout has occured, and the while will exit.
      if(done){                         // do checksumOK test of buffer;
        done=checksumOK(buf);
        if(!done){                      // checksumOK failed, scan buffer for next sync char
           p = (uint8_t*)memchr((buf+1),0xff,(MSGSIZE-1)); //forgot to skip the current sync at 0
           
           
           if(p){ // found next sync char, shift buffer content, refill buffer
             *cnt = MSGSIZE -(p-buf); // count of characters to salvage from this failure
             memcpy(buf,p,*cnt); //cnt is now where the next character from Serial is stored!
             }
           else *cnt=0; // whole buffer is garbage
           }
        }
       
      } while(!done&&(millis()-start<timeout));
    
    return done; // if done then buf[] contains a sendbufid buffer, else a timeout occurred
    }
    
    //=====================================================================================
    
    
    void loop()
    {
      char     sbuf[128],  resOK;   
      static   uint8_t cnt=0;
      uint8_t  cbuf[MSGSIZE], chk;
    
     
      //   send to Rx slave Arduino
     
      //Serial.println();
      sendbuf[0]=bsync;
      sendbuf[1]=calcchecksum(sendbuf);
     
      for(uint8_t i=0; i<MSGSIZE; i++) {                     // better use write() ?
         serialPutchar( Serial1, sendbuf[i]);                // Send values to the Rx Arduino       
      }       
      //serialFlush( Serial1 );                              // clear output buffer
     
      //displayvalues(20, "Transmitted...: ", sendbuf);
      sprintf(sbuf, "%4d %4d", sendbuf[4], sendbuf[6]);
      //lcdprintxy(0, 20, sbuf);
      printf(sbuf); printf("\n");
    
     
      //     Receive from Rx slave Arduino
    
      memset(cbuf, 0, sizeof(cbuf));
       
      resOK = receive ( cbuf, 10000,&cnt);
     
      if( resOK ) {                         // byte 0 == syncbyte ?
        cnt=0;
    
        //displayvalues(60, "Received...:", cbuf);
         chk=(byte)calcchecksum(cbuf);     
         memcpy(recvbuf, cbuf, sizeof(cbuf));
     
            // change values to send back!
            memcpy(sendbuf, recvbuf, sizeof(sendbuf));         // copy inbuf to outbuf
            sendbuf[4]+=1;                                     // change [4] to send back
           
           
      }
     
    }
    
    
    //=====================================================================================
    
     
    int main() {
        unsigned long timesav;
        char  sbuf[128];
        char  instr[128];
         
        printf("initializing..."); printf("\n");
       
        // UART Serial com port
        Serial1 = serialOpen (uart, 115200); // for Arduino code compatibility reasons
       
        while(1) { loop(); } 
       
        serialClose( Serial1);
       
        exit(0);
    }
    
    //=====================================================================================
    //=====================================================================================
    Code:
    /*     Rx slave     
           Arduino Due
    
           ver 0006
           IDE 1.6.5
     */
     
    // (C) Helmut Wunder (HaWe) 2015
    // freie Verwendung für private Zwecke
    // für kommerzielle Zwecke nur nach Genehmigung durch den Autor.
    // Programming language: Arduino Sketch C/C++ (IDE 1.6.1 - 1.6.5)
    // protected under the friendly Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
    // http://creativecommons.org/licenses/by-nc-sa/3.0/
    
    
     
    #include <SPI.h>
    #include <SD.h>
    #include <UTFTQD.h>  // wie UTFT, aber gepatcht für ILI9225 China-TFT
    #include <Adafruit_GFX.h>
    #include <Adafruit_ILI9340.h>
    
    
    #define  clock()  millis()
    
    
    //=====================================================================================
    // TFT LCD
    //=====================================================================================
    #define   UTFT_SmallFont     8 // UTFT 8x10
    #define   UTFT_MediumFont   12 // UTFT ++
    #define   UTFT_BigFont      18 // UTFT +++
    #define   _SmallFont_        1 // 9341 6x9
    #define   _MediumFont_       2 // 9341 12x16
    #define   _BigFont_          3 // 9341 18x23
    
    int16_t  LCDmaxX , LCDmaxY ;                // display size
    int16_t  _curx_, _cury_,                    // last x,y cursor pos on TFT screen
             _maxx_, _maxy_;                    // max. x,y cursor pos on TFT screen       
    char     wspace[128];                       // line of white space
    
    
    // set LCD TFT type
    int16_t  LCDTYPE   =   -1;
    
    #define  _LCD1602_    1  // LCD1602  Hitachi HD44780 driver <LiquidCrystal.h>
                               // http://www.arduino.cc/en/Tutorial/LiquidCrystal   //
    #define  _SERLCD_     2  // Sparkfun serLCD 16x2 
                               // http://playground.arduino.cc/Code/SerLCD   //
    #define  _UTFT_       4  // Henning Karlsen UTFT 2.2-2.4" 220x176 - 320x240 lib
                               // http://henningkarlsen.com/electronics/library.php?id=51   //
    #define _ILI9341_     8  // https://github.com/adafruit/Adafruit_ILI9340
                               // https://github.com/adafruit/Adafruit-GFX-Library //
                               
                               
    //--------------------------------------------------------------------------------------------------
    #define  UTFT_cs      52    // <<<<<<<< adjust!
    
    //UTFT   qdUTFT(Model, SDA=MOSI,  SCL, CS,       RESET,  RS)    // Due: 3 exposed SS pins: 4,10,52
      UTFT   qdUTFT(QD220A,   A2,     A1,  A5,       A4,     A3);   // adjust model parameter and pins!
    //UTFT   qdUTFT(QD220A,   50,     49,  UTFT_cs,  0,     51);   // A0->Vc (LED), A4->BoardReset
     extern  uint8_t SmallFont[];
    //--------------------------------------------------------------------------------------------------
    #define    tft_cs     50
    #define    tft_dc     49
    #define    tft_rst     0
    Adafruit_ILI9340   tft = Adafruit_ILI9340(tft_cs, tft_dc, tft_rst);
    
    //--------------------------------------------------------------------------------------------------
    
    int16_t  fontwi= 8;  // default
    int16_t  fonthi=10;  // default
    
    
    void putfonttype(uint8_t fsize) {
      if(LCDTYPE==_UTFT_)  { fontwi= qdUTFT.getFontXsize(); fonthi=qdUTFT.getFontYsize(); }
      else
      if(fsize==_SmallFont_)     { fontwi= 6; fonthi=9; }  // 5x7 + overhead ?
      else
      if(fsize==_MediumFont_)    { fontwi=12; fonthi=16; } // ?
      else
      if(fsize==_BigFont_)       { fontwi=18; fonthi=23; } // ?
     
      _maxx_ = LCDmaxX / fontwi;    // max number of letters x>>
      _maxy_ = LCDmaxY / fonthi;    // max number of letters y^^
      memset(wspace, ' ', _maxx_);  // line of white space
      wspace[_maxx_]='\0';
    }
    
    
    
    void setlcdorient(int8_t orient) {
      if(LCDTYPE==_ILI9341_) {
          tft.setRotation(orient);
          LCDmaxX=tft.width();
          LCDmaxY=tft.height();       
       }
    }
    
    void lcdcls()  {                                                         
       if(LCDTYPE==_UTFT_)      { qdUTFT.clrScr();                } 
       if(LCDTYPE==_ILI9341_)   { tft.fillScreen(ILI9340_BLACK);  }
       _curx_ =0;  _cury_ =0;
    }
    
    void curlf()   {                                                       
       _curx_=0;
       if( _cury_ <=(LCDmaxY-10) ) _cury_+=fonthi;
       else _cury_=0;   
       if(LCDTYPE==_ILI9341_)   {tft.setCursor(0, _cury_); } 
    }
    
    
    
    void curxy(int16_t  x,  int16_t  y) {
       _curx_ = x;
       _cury_ = y;
       if(LCDTYPE==_ILI9341_)   {tft.setCursor(x, y); }
    }
    
    
    void lcdprintxy(int16_t x, int16_t y, char * str) {
       if(LCDTYPE==_UTFT_)     { qdUTFT.print(str,x,y); _curx_=x+strlen(str)*fontwi; _cury_=y; }
       else if(LCDTYPE==_ILI9341_)  {
          tft.setCursor(x,y);  tft.print(str);
          _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
       }
    }
    
    
    void lcdprint(char * str) {
        if(LCDTYPE==_UTFT_)     { qdUTFT.print(str, _curx_, _cury_); _curx_=_curx_+strlen(str)*fontwi; }
        else if(LCDTYPE==_ILI9341_)  {
           tft.setCursor(_curx_, _cury_); tft.print(str);
           _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
        }
    }
    
    
    void initlcd(uint8_t orient) { // 0,2==Portrait  1,3==Landscape
       if(LCDTYPE==_UTFT_) {
          qdUTFT.InitLCD();
          LCDmaxX=qdUTFT.getDisplayXSize();
          LCDmaxY=qdUTFT.getDisplayYSize();
          qdUTFT.setFont(SmallFont);
          putfonttype(UTFT_SmallFont);
          fontwi=qdUTFT.getFontXsize();
          fonthi=qdUTFT.getFontYsize();
       }
       else
       if(LCDTYPE==_ILI9341_) {
          tft.begin();
          setlcdorient(orient);       
          tft.setTextSize(_SmallFont_);
          putfonttype(_SmallFont_);
       }   
    } 
    
    
    
    //=====================================================================================
    //=====================================================================================
    
    const    uint8_t  MSGSIZE=32;
    uint8_t  bsync=255;
    uint8_t  sendbuf[MSGSIZE];
    uint8_t  recvbuf[MSGSIZE];
    
    
    //=====================================================================================
    const uint32_t UARTclock = 115200;
    
    void setup() {
       char sbuf[128];   
       int32_t  i=0;
             
       // Serial
       Serial.begin(115200);   // USB terminal
     
       Serial1.begin(UARTclock);                    // RX-TX UART
       while(Serial1.available())  Serial1.read();  // clear output buffer
    
         
       // TFT LCD
       Serial.println();
       LCDTYPE = _UTFT_;
       Serial.print("init LCD...");
       initlcd(1);   
       Serial.println(" done.");   lcdcls();
       sprintf(sbuf, "LCD=%d wi%d x hi%d",LCDTYPE,LCDmaxX,LCDmaxY);
       Serial.println(sbuf);
       Serial.println();
       lcdcls(); lcdprint(sbuf);
       
       sprintf(sbuf, "setup(): done.");
       Serial.println(); Serial.println(sbuf);   
       curlf(); curlf(); lcdprint(sbuf);
    
       lcdcls();
       
       sprintf(sbuf, "Rx slave, BAUD= %ld", UARTclock );;
       lcdprintxy(0, 0, sbuf);
    
    
    }
    
    
    
    //=====================================================================================
    //=====================================================================================
    
    void displayvalues(int line, char * caption, uint8_t array[]) {
      int cnt;
      char sbuf[128];
     
      sprintf(sbuf, "%s cks=%-4d", caption, array[1]);
      lcdprintxy(0, line, sbuf); 
      //Serial.println(sbuf);
      for(cnt=0; cnt<8; ++cnt) {
        sprintf(sbuf, "%3d ", array[cnt]);      // print on TFT
        lcdprintxy(cnt*3*8, line+10, sbuf);
        //Serial.print(sbuf);                      // Print sendbufue to the Serial Monitor
      }   
      //Serial.println(); 
     
    } 
    
    // ================================================================
    
    uint8_t calcchecksum(uint8_t array[]) {
      int32_t  sum=0;
      for(int i=2; i<MSGSIZE; ++i) sum+=(array[i]);
      return (sum & 0x00ff);
    }
    
    bool checksumOK(uint8_t array[]){
    return (calcchecksum(array)==array[1]);
    }
    
    // ================================================================
    // addToBuffer and receive function courtesy of chucktodd
    
    bool addToBuffer( uint8_t buf[], uint8_t *cnt, uint16_t timeout){
    bool inSync = *cnt>0;
    unsigned long start=millis();
    while((*cnt<MSGSIZE)&&(millis()-start<timeout)){
      if(Serial1.available()){ // grab new char, test for sync char, if so start adding to buffer
        buf[*cnt] = (uint8_t)Serial1.read();
        if(inSync) *cnt += 1;  // my origional *cnt++ was updating the pointer address, not
                               // the pointed to sendbufue
        else{
         if(buf[*cnt]==0xFF){
           inSync = true;
           *cnt +=1;
           }
         }
        }
      }
    return (*cnt==MSGSIZE);
    }
    
    
    //=====================================================================================
    
    bool receive(uint8_t * buf, uint16_t timeout, uint8_t *cnt){ // by passing cnt in and out,
    // i can timeout and still save a partial buffer, so a resync costs less (less data lost)
    
    bool inSync=false;
    unsigned long start=millis();
    uint8_t * p;  // pointer into buf for reSync operation
    bool done=false;
    
    do{
      done = addToBuffer(buf,cnt,timeout); // if this return false, a timeout has occured, and the while will exit.
      if(done){ // do checksumOK test of buffer;
        done=checksumOK(buf);
        if(!done){// checksumOK failed, scan buffer for next sync char
           p = (uint8_t*)memchr((buf+1),0xff,(MSGSIZE-1)); //forgot to skip the current sync at 0
           
           
           if(p){ // found next sync char, shift buffer content, refill buffer
             *cnt = MSGSIZE -(p-buf); // count of characters to salvage from this failure
             memcpy(buf,p,*cnt); //cnt is now where the next character from Serial is stored!
             }
           else *cnt=0; // whole buffer is garbage
           }
        }
       
      }while(!done&&(millis()-start<timeout));
    
    return done; // if done then buf[] contains a sendbufid buffer, else a timeout occurred
    }
    
    //=====================================================================================
    //=====================================================================================
    
    void loop()
    { 
      char     sbuf[128],  resOK;   
      static   uint8_t cnt=0; 
      uint8_t  cbuf[MSGSIZE], chk;
      uint32_t xtime;
     
    
      //     Receive fromTx master Arduino
    
      memset(cbuf, 0, sizeof(cbuf)); 
       
      resOK = receive ( cbuf, 10000,&cnt);
     
      if( resOK ) {                                      // byte 0 == syncbyte ?
        cnt=0;
    
        //displayvalues(60, "Received...:", cbuf);
         chk=(byte)calcchecksum(cbuf);     
         memcpy(recvbuf, cbuf, sizeof(cbuf));
     
            // change values to send back!
            memcpy(sendbuf, recvbuf, sizeof(sendbuf));   // copy inbuf to outbuf
            sendbuf[4]+=1;                               // change [6] to send back 
            sendbuf[6]+=1;                               // change [6] to send back       
           
      }
    
    
     
      //   send to Tx master Arduino
     
      //Serial.println(); 
      sendbuf[0]=bsync;
      sendbuf[1]=calcchecksum(sendbuf);
      for(uint8_t i=0; i<MSGSIZE; i++) {       
         Serial1.write(sendbuf[i]);                      // Send value to the Rx Arduino       
      }       
      //Serial1.flush();                                 // clear output buffer
      //displayvalues(20, "Transmitted...: ", sendbuf);
      sprintf(sbuf, "%4d %4d", sendbuf[4], sendbuf[6]);
      lcdprintxy(0, 20, sbuf);
    
     
     
     
    }
    
    
    //=====================================================================================
    //=====================================================================================
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  2. #2
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    599
    Hallo,

    alles ganz einfach.

    UART ist UART, er hat nur einen anderen Namen. Bisher verwendest Du /dev/ttyAMA0.

    Um den Namen des Arduino Ports herauszufinden, lässt Du den erst mal ab und öffnest eine Linux Konsole.
    So, dann stecktst Du den Arduino ein und tippst anschliessend in der Konsole
    dmesg | tail
    Da kommt dann allerlei Zeug, darunter irgendwas mit
    new full-speed USB device ...
    ...
    cdc_acm ...: ttyACM0: USB ACM device
    usbcore: registered new interface driver cdc_acm
    Will heißen, der Arduino hängt an einem virtuellen UART mit dem Namen /dev/ttyACM0.

    Sonst ist nix zu ändern. Kompliziert wird es nur, wenn man mehrere serielle Geräte am USB hat. Kann nicht beschwören, dass die bei jedem Einschalten gleich numeriert werden. Da bietet sich eine "wer bist du ?" Funktion im seriellen Protokoll an.

  3. #3
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.452
    Danke!
    und was muss ich am Arduino ändern, wenn die Signale jetzt über USB rein und rausgehen?
    (Statt bisher Serial1 ?)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  4. #4
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    599
    Na, das ist Serial. Die normale Schnittstelle, mit der alle Arduinos mit dem PC sprechen und programmiert werden.

    Das ganze ist übrigens unabhängig von Arduino und Raspi. Alle USB-Geräte die als serielle Schnittstelle angesprochen werden erscheinen unter Linux so. In der Arduino IDE stehen die Portnamen doch im Menu, da wo unter Windows die COM... Nummern stehen ...

  5. #5
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.452
    ach so, das ist dann beim Arduino statt der seriellen Konsole, pins 0+1... na klar...!
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

Ähnliche Themen

  1. Antworten: 25
    Letzter Beitrag: 15.08.2016, 20:45
  2. Zwei Arduino´s drahtlos verbinden ??
    Von Benny1989 im Forum Arduino -Plattform
    Antworten: 88
    Letzter Beitrag: 18.07.2016, 11:56
  3. 2 Arduino-Boards via RS232 verbinden
    Von probot32 im Forum Arduino -Plattform
    Antworten: 3
    Letzter Beitrag: 23.10.2015, 19:21
  4. Blue Tooth Shield V1.2 für Arduino mit Android verbinden
    Von ultimate80563 im Forum Vorstellung+Bilder+Ideen zu geplanten eigenen Projekten/Bots
    Antworten: 4
    Letzter Beitrag: 19.11.2014, 17:11
  5. Bascom-Board mit Arduino-Board per I2C verbinden
    Von Serie_9 im Forum Allgemeines zum Thema Roboter / Modellbau
    Antworten: 0
    Letzter Beitrag: 18.07.2013, 20:00

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •