Ein kleines Beispiel wie ihr mit dem Monster Motor Shield 2 Motoren ansteuern könnt:

[code]
/*
 * Das Monster Motor Shield kann mit diesem Sketch über den Seriellen Monitor gesteuert werden.
 * Einfach den Speed und die Richtung durch ein Komma getrennt eingeben.
 * Beispiel: 100,1
 * Dann drehen die Motoren mit der Geschwindigkeit 100 von 255 gegen den Uhrzeigersinn
 * Mögliche Werte:
 * Speed – 0 bis 255 (0 = Stop, 255 = volle Geschwindigkeit)
 * Richtung(Dir) – 0 bis 3 (0 = im Uhrzeigersinn, 1 = gegen den Uhrzeigersinn, 2 = Motoren drehen gegeneinander,
 * 3 = Motoren drehen umgekehrt gegeneinander)
 * Bei einem Fahrzeug mit 2 Motoren wäre das dann:
 * 0 = Vorwärts
 * 1 = Rückwärts
 * 2 = nach links drehen
 * 3 = nach rechts drehen
 *
 * VNH2SP30 pin definitions
 * inApin[2] = {7, 4};  // INA: Clockwise input
 * inBpin[2] = {8, 9}; // INB: Counter-clockwise input
 * pwmpin[2] = {5, 6}; // PWM input
 * cspin[2] = {2, 3}; // CS: Current sense ANALOG input
 * enpin[2] = {0, 1}; // EN: Status of switches output (Analog pin)
 *
 * http://arduinoinc.blogspot.de/
 */

#define CS_THRESHOLD 15   // Der max Strom der durch den Treiber auf Dauer unterstützt wird

int inApin[2] = {7, 4}; // IN-A: Im Uhrzeigersinn drehen, Motor0 and Motor1 (Check:”1.2 Hardware Monster Motor Shield”).
int inBpin[2] = {8, 9}; // IN-B: Gegen den Uhrzeigersinn drehen, Motor0 and Motor1 (Check: “1.2 Hardware Monster Motor Shield”).
int pwmpin[2] = {5, 6};            // PWM’s input
int cspin[2] = {2, 3};              // Strom (A) Sensoren Motor 1/2

int statpin = 13;

int i=0;
int speedon = 0;
int speedaktuell = 0;
int dir = 0;
int diraktuell = 0;

void setup()                        
{
  Serial.begin(9600);
  Serial.println(“Ready to start – Speed,Dir”);
 
  pinMode(statpin, OUTPUT);
 
  for (int i=0; i<2; i++)
      {
        pinMode(inApin[i], OUTPUT);
        pinMode(inBpin[i], OUTPUT);
        pinMode(pwmpin[i], OUTPUT);
      }
     
  for (int i=0; i<2; i++)
      {
        digitalWrite(inApin[i], LOW);
        digitalWrite(inBpin[i], LOW);
      }
}

// **************************************************************

void loop()                         
{

  // Serielle Schnittstelle auslesen
  if (Serial.available() > 0)
  {
      // nach durch “,” getrennte Werte lesen
      speedon = Serial.parseInt();
      dir = Serial.parseInt();
     
      if (Serial.read() == ‘n’)     // nach dem Ende der Zeile schauen
      {
        // Die Werte auf bestimmte Bereiche beschränken
        speedon = constrain(speedon, 0, 255);
        dir = constrain(dir, 0, 3);
      }
     
      Serial.println(“Start”);
      Serial.print(“SpeedOn = “);
      Serial.println(speedon, DEC);
      Serial.print(“Dir = “);
      Serial.println(dir, DEC);
  }
       
 
 
  beschleunigen(speedon, dir);
 
 
 
 
 
  // Auf neue Werte/Anweisungen warten und Überprüfen ob der motor nicht blockiert ist
 
  while(i!=0)
  {                                     
      if (Serial.available() > 0)
      {
        speedon = Serial.parseInt();
        dir = Serial.parseInt();
       
        if (Serial.read() == ‘n’)
        {
            speedon = constrain(speedon, 0, 255);
            dir = constrain(dir, 0, 3);
        }
       
        Serial.print(“SpeedOn = “);
        Serial.println(speedon, DEC);
        Serial.print(“Dir = “);
        Serial.println(dir, DEC);
      }
         
      if (dir != diraktuell) beschleunigen(1, diraktuell);
     
      if (speedaktuell != speedon) beschleunigen(speedon, dir);
     
      motorGo(dir, speedon);
     
      if (analogRead(cspin[0]) > CS_THRESHOLD)        
      {
        motorOff();
      }
     
  }
       
}
// **************************************************************

void beschleunigen(int endspeed, int dirx)
{
  // Beschleunigen des Motors auf “speedon”
  if (endspeed != 0)
  {
      if (endspeed > speedaktuell)  // Wenn die neue Geschwindigkeit größer ist, dann beschleunigen
      {
     
        Serial.println(“beschleunigen”);

        i = speedaktuell;
       
        while(i<endspeed)
        {
          motorGo(dirx, i);   // Den Motorspeed immer um 1/255 erhöhen     
          delay(50);                        
          i++;
                                  
          if (analogRead(cspin[0]) > CS_THRESHOLD) // Ist der Motor blockiert und der Strom wird zuhoch, abschalten.
          {
            motorOff();
          }
         
          digitalWrite(statpin, LOW);
     
        }
      }

      if (endspeed < speedaktuell)  // Wenn die neue Geschwindigkeit kleiner ist, dann entschleunigen
      {
     
        i = speedaktuell;
       
        Serial.println(“entschleunigen”);
       
        while(i>endspeed)
        {
          motorGo(dirx, i);   // Den Motorspeed immer um 1/255 erhöhen     
          delay(50);                        
          i–;
                                  
          if (analogRead(cspin[0]) > CS_THRESHOLD) // Ist der Motor blockiert und der Strom wird zuhoch, abschalten.
          {
            motorOff();
          }
         
          digitalWrite(statpin, LOW);
     
        }
      }
      Serial.println(“Speed erreicht”);
      diraktuell = dir;
      speedaktuell = endspeed;
      i=1;
  }
}

void motorOff()
{

  for (int i=0; i<2; i++)
  {
    digitalWrite(inApin[i], LOW);
    digitalWrite(inBpin[i], LOW);
  }
 
  analogWrite(pwmpin[0], 0);
  analogWrite(pwmpin[1], 0);
 
  i=0;
 
  digitalWrite(13, HIGH);
 
  Serial.println(“Motor Locked”);
 
  delay(1000);
}

void motorGo(uint8_t direct, uint8_t pwm)
{
    if (direct <=4)
    {
      if (direct == 0) // Go forward
      {
        digitalWrite(inBpin[0], LOW);
        digitalWrite(inBpin[1], LOW);
        digitalWrite(inApin[0], HIGH);
        digitalWrite(inApin[1], HIGH);
      }
         
      if (direct == 1)  // Go backward
      {
        digitalWrite(inApin[0], LOW);
        digitalWrite(inApin[1], LOW);
        digitalWrite(inBpin[0], HIGH);
        digitalWrite(inBpin[1], HIGH);
      }
 
      if (direct == 2)  // Go left
      {
        digitalWrite(inApin[0], LOW);
        digitalWrite(inBpin[1], LOW);
        digitalWrite(inBpin[0], HIGH);
        digitalWrite(inApin[1], HIGH);
      }
     
      if (direct == 3)  // Go right
      {
        digitalWrite(inBpin[0], LOW);
        digitalWrite(inApin[1], LOW);
        digitalWrite(inApin[0], HIGH);
        digitalWrite(inBpin[1], HIGH);
      }
       
      analogWrite(pwmpin[0], pwm);
      analogWrite(pwmpin[1], pwm);
    }
}
[/code]

In diesem kleinen Post möchte ich mein Wissen zum bau eines kleinen GPS Moduls weitergeben. Ich musste selbe etwas aufwendiger suchen, um alle Informationen zu finden, die es mir dann recht schnell ermöglicht haben den GPS Receiver “HOLUX GM-210”, mit dem NMEA 0183 Protokoll,
 die für mich interessanten Daten zu entlocken.

Was für Materialien hab ich benutzt?

  • GPS Receiver HOLUX GM-210
  • LCD 1602 (Idealer Weise mit UT-LCDmenueSensor Board)Wir
  • ARDUINO Nano
Die Verdrahten des ARDUINOS mit dem GPS Receiver ist denkbar einfach, wenn man die richtigen Informationen hat. Wichtig ist es das man die TTL Datenanschlüsse (5V Signalpegel) benutzt und nicht die RS232 (12V Signalpegel) Anschlüsse.
 
 
 
 
 

Wir verbinden also den PIN2 vom GM-210 5V VDC mit den 5V Ausgang und den PIN4 Ground mit dem GND (Ground) am ARDUINO.

Jetzt noch den PIN3 Tx(TTL) mit einem Seriellen RxPin und den PIN5 Rx(TTL) mit dem TxPIN an dem ARDUINO.

So einfach ist die Hardware installiert.

Jetzt kommen wir zu der etwas größeren Aufgabe. Das Auslesen der Daten die uns das GPS sendet, und dann natürlich das Auswerten der Daten.
Denn wir wollen ja wissen wo wir sind, wie schnell wir sind und in welche Richtung wir uns bewegen.

 

Es stehen natürlich noch einige Daten mehr zu der Verfügung, aber die kann sich dann nach dem gleichen Prinzip jeder so anpassen wie er es gerne hätte.

Die Erklärung hab ich noch nicht ganz fertig, aber hier schon mal der Code:

*************************************************************

 #include <string.h>
 #include <ctype.h>

 #include <LiquidCrystal.h>
  // initialize the library with the numbers of the interface pins
  LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 
 #include <SoftwareSerial.h>
  SoftwareSerial GPSserial(7, 6); // RX | TX

String inputString = “”;         // a string to hold incoming data
boolean stringComplete = false;  // whether the string is complete

 void setup()
{

// initialize serial:
  Serial.begin(9600);
  GPSserial.begin(4800);
  // reserve 200 bytes for the inputString:
  inputString.reserve(200);

  lcd.begin(16, 2);
 
  lcd.print(“GPS Modul”);
  delay(2000);
 
}

 void loop()
 {
      serialEvent(); // Zeile einlesen
     
  // print the string when a newline arrives:
  if (stringComplete)
    {
      Serial.println(inputString);

      // you can also look for a substring in the middle of a string:
      // Ausgabe auf dem LCD
      if (inputString.substring(1,6) == “GPRMC”)
        {
          Serial.println(“Yes”);
          String ausgabe = (inputString.substring(20, 29));
         
          lcd.clear();
         
          lcd.setCursor(0, 0);
          lcd.print(“L:”);
          lcd.setCursor(0, 1);
          lcd.print(“B:”);
         
          lcd.setCursor(3, 0);
          lcd.print(ausgabe);
          ausgabe = “”;
          ausgabe = (inputString.substring(30, 31));
          lcd.setCursor(12, 0);
          lcd.print(ausgabe);
          ausgabe = “”;
          ausgabe = (inputString.substring(32, 42));
          lcd.setCursor(3, 1);
          lcd.print(ausgabe);
          ausgabe = “”;
          ausgabe = (inputString.substring(43, 44));
          lcd.setCursor(13, 1);
          lcd.print(ausgabe);
          ausgabe = “”;
         
          delay(1000);
         
          int kommaS = inputString.indexOf(‘,’, 46);
          ausgabe = (inputString.substring(45, kommaS – 1));
          float kmh = ausgabe.toFloat();
          kmh = kmh*1.852;

          lcd.clear();
         
          lcd.setCursor(0, 0);
          lcd.print(“S:”);
          lcd.setCursor(0, 1);
          lcd.print(“W:”);
 
          lcd.setCursor(3, 0);
          lcd.print(kmh, 6);
          ausgabe = “”;
          int kommaW = inputString.indexOf(‘,’, kommaS + 1);
          ausgabe = (inputString.substring(kommaS + 1, kommaW));
          lcd.setCursor(3, 1);
          lcd.print(ausgabe);
          ausgabe = “”;
          delay(1000);
        }
     
      // clear the string:
      inputString = “”;
      stringComplete = false;
    }
 }

 void serialEvent() {
  while (GPSserial.available())
    {
    // get the new byte:
    char inChar = (char)GPSserial.read();
   
    // add it to the inputString:
    inputString += inChar;
   
    // if the incoming character is a newline, set a flag
    // so the main loop can do something about it:
    if (inChar == ‘n’)
      {
        stringComplete = true;
      }
  }
}

 

 

Wie mein kleiner Laser-Plotter entstanden ist

Das Thema Laserplotter scheint im Internet und unter den E-Bastlern sehr verbreitet zu sein. Was mich aber nicht wunder, da es mich auch schnell gepackt hat und ich dem Fieber verfallen bin.

Also machte ich mich als erstes auf die Suche nach Informationen über Laser und über Schrittmotoren.

Was nicht ganz einfach war. Es gibt zwar viel im Netz, aber entweder ist es für Menschen die sich schon ausreichend mit der Technik auskennen geschrieben, oder mit nur sehr wenigen Informationen zu den Details.

 

 

Was ich hier versuchen möchte ist viele nützliche Informationen zusammen zu tragen und zu verlinken.

 

Der ARDUINO mit dem AFmotor Shield (L293D), 2 Stepper und ein Servo läuft ganz gut mit der Firmeware GcodeCNCdemo und zum senden der Daten (GCODE) teste ich gerade GcodeSender, auch von MarginallyClever.
 

 

 
 

 

 

Ausschneiden aus Kunststoff 

 
 
 

Da es immer noch Probleme mit der Einstellung von Stepps pro Millimeter gibt, muss eine neue Steuerung her.

 
Jetzt mit einem easyDriver Set und der GRBL Software. 

 

 

 

 

 

 

 

 

 

 

Für die nächste Ausbaustufe habe ich schon mal Material bestellt bei: www.alu-Profil-Technik.de
Superservice und gute Preise.

 

 

 

 

 
 

 

 

 
 
 
 
 
 
 
 

 

 

 

Informationen zum HC-SR04 (Robosoftsystem)

************************************************************************************
Start Quellcode
************************************************************************************
// Prozesortaktfrequent festlegen
#define F_CPU 16000000UL

// Baudrate
#define BAUD 19200UL

// Baudratenberechnung
#define UBRR_VAL ((F_CPU+BAUD*8) / (BAUD*16)-1)

// CR ist Zeilenumbruch
#define CR 0x0D

// Benötigte Bibliotheken hinzufügen
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>

// Variablen deklarieren
uint16_t rising, falling;     // Zum speichern der Timerwerte bei steigender und fallender Flanke
int counts;                         // Die Differenz der beiden Timerwerte (Signallänge in TimerTakten)
float dist;                          // Der berechnete Abstand in cm mit bis zu 6 Kommastellen
uint16_t us_per_count;    // Die Länge eines TimerTaktes in us

// ********************************************************************************************************************************************
// ****************************************************** Serielle Übertragung ****************************************************************
// UART-Init ATmega328P

void uart_init(void)
{
    // Baudrate einstellen
    UBRR0H = (unsigned char)(UBRR_VAL>>8);
    UBRR0L = (unsigned char)UBRR_VAL;
   
    // Receiver und Transmitter einschalten
    UCSR0B = (1<<RXEN0)|(1<<TXEN0);
   
    // Frame Format: Asynchron 8N1
    UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
}

// Charakter schreiben (Ein Zeichen senden als ASCII)
void uart_putChar(unsigned char c)
{
    // Warten bis Sendepuffer leer ist
    while (!(UCSR0A & (1<<UDRE0)));
   
    // Daten in den Puffer schreiben und senden
    UDR0 = c;
}

// String senden (Einen Zeichenfolge in einzelne Zeichen zerlegen und an uart_putChar zum senden übergeben)
void uart_putStr(unsigned char *s)
{
    while (*s)
    {  
        // so lange *s != ‘�’ also ungleich dem “String-Endezeichen(Terminator)”
        uart_putChar(*s);
        s++;
    }
}
// ********************************************************************************************************************************************

// ********************************************************************************************************************************************
// ************************************************* ISP **************************************************************************************

// Int. wenn die sich verändernde Flanke (von “1 nach 0 – fallende” oder von “0 nach 1 – steigende”) erkannt wird. (An PIN PB0 (ARDUINO PIN 8))
ISR(TIMER1_CAPT_vect)
{
    if (TCCR1B & (1<<ICES1))     // (Wenn das Bit ICES1 im register TCCR1B = 1 ist, also einen steigende Flanke erkennt)
    {
        TCCR1B &= ~(1<<ICES1);     // (Erkennung umschalten auf fallende Flanke (Bit ICES1 im register TCCR1B = 0))
        rising = ICR1;                           // (Den beim auslösen des Int. im Register ICR1 gespeicherten Timer/Counter Wert in die Variable “rising” speichern)

    }
    else // (Wenn das Bit ICES1 im register TCCR1B = 0 ist, also einen fallende Flanke erkennt)
    {
        TCCR1B |= (1<<ICES1);     // (Erkennung umschalten auf steigende Flanke (Bit ICES1 im register TCCR1B = 1))
        falling = ICR1;                      // (Den beim auslösen des Int. im Register ICR1 gespeicherten Timer/Counter Wert in die Variable “falling” speichern)
        counts = falling – rising;        // die Differenz zwischen tEnd und tStart berechnen (z.B.: Steigende Flanke erkannt bei tStart=120, fallenden Flanke erkannt bei tEnd=670 – 670-120=tPuls=550)

        dist = (float)us_per_count * counts * 10 / 580;     // (Laufzeit Schall in Weg “cm” umrechnen)
    }
}

// Is triggered on timer match of OCR1A (Int. wenn der Vergleichswert in OCR1A erreicht ist)
ISR(TIMER1_COMPA_vect)
{
    // Generate a 12us pulse to trigger the HR-SR04
    PORTB ^= (1<<PIN2);
    _delay_us(12);
    PORTB ^= (1<<PIN2);
}
// ********************************************************************************************************************************************

int main(void)
{
    // Uart Init
    uart_init();
   
    unsigned char str[10];
   
    DDRB |= (1<<PIN2);      // PORTB PIN 2 as output
    DDRB |= (1<<PIN5);      // PORTB PIN 5 as output
   
   
   
    // ********************************************************************************************************************************************
    // *************************************************************** TIMER1 INIT ****************************************************************

    TCCR1B |= (1<<ICNC1) | (1<<CS10) | (1<<CS11) | (1<<WGM12);      //ICNC1:Rauschunterdrückung, CS10 and CS11: Prescale (Teiler) auf 64, WGM12: CTC-Modus auswählen
    TIMSK1 |= (1<<ICIE1) | (1<<OCIE1A);      // Int. auslösen bei: Erreichen von TOP, bei steigender bzw. fallender Flanke
    TCCR1B |= (1<<ICES1);      // Int. auslösen bei steigender Flanke
   
    // TOP berechnen (70ms Laufzeit für einene Cyclus): 16MHz/64 = 250000count/sek = 250000/1000 = 25000count/us / 100 * 70 = 17500 count/70ms

    OCR1A = 17500;

      
    // CPU-Takt / Prescale = Takte/Sek. 1Sek / Takt/Sek = 4 ( t = 4us/Takt)
    us_per_count = 4;

    sei();     //Interrupt global aktivieren

    // Endlosschleife
    while (1)
    {
        if (dist < 300)     // Wenn die Distanz innerhalb des Messbereiches (max. 300cm) liegt, …
        {
            uart_putStr(dtostrf(dist, 1, 2, str));     // … dann Ausgabe der Distanz mit 2 Stellen hinter dem Komma per Seriell
            uart_putStr(” cm”);      // schreibe hinter dem Wert ein “cm”
            uart_putStr(“r”);     // gehe zurück zum Anfang der Zeile
        }
        else     // Wenn nicht, …
        {
            uart_putStr(“ERROR”);     // … schreibe “ERROR” in dei Ausgabe
            uart_putStr(“r”);    
// gehe zurück zum Anfang der Zeile 
        }
       
       
        _delay_ms(250);
    }
}


**********************************************************************************
Ende Quellcode
**********************************************************************************

Diese Seiten habne mir geholfen das Projekt umzusetzen:

ATmega168/328-Arduino Pin Mapping
CONVERTWORLD.COM – Umrechnen von Einheiten ganz einfach

 

Vielen Dank!
 
 

Hallo zusammen,

Ich möchte in diesem Block meine persönlichen Erfahrungen in der Programmierung von Mikrocontrollern mit Euch teilen.

Ich werde diesen Blog Stück für Stück aufbauen und mit meinem Quellcode so wie mit interessanten Link versehen.

Wenn Ihr Ideen zu Projekten habt, lass mich das bitte wissen. Wenn Zeit und Muße stimmen, werde ich mich gerne daran beteiligen.

Geplante Versuche:

  • Serielle Ausgabe UART
  • ADC – Einen analogen Eingang nutzen
  • Thermesensor
  • PWM
  • Ein Servo steuern
  • LCD – ansteuern und benutzen
  • ICP – Zeitmessung und Signalauswertung
  • Ultraschall Modul HC-SR04
  • Photodiode
  • Funkmodul 433MHz

 

Hallo

Heute hab ich mich etwas mit dem Thema WMI beschäftigt.

Ich möchte ein Beispiel, eine Funktion vorstellen, die sich sehr einfach anpassen lässt.
An die Funktion wird ein String als Wert übergeben (z.B. der Hostname) und die ausgelesenen Werte werden als List<string> zurück gegeben, die man dann z.B. an ein Dataset übergeben kann.


————————————————————————————————————
        // Funktion:  — WMINetworkAdapterConfigurationIP() —
        // Ruft folgende Komponenten aus dem NetworkAdapterConfiguration ab, wo IP=Enable ist:
        // Description, IP-Add, MAC-Add, Gateway, SubnetMask
        // Übergabewert ist der Hostname von dem die Werte abgerufen werden sollen
        // Rückgabewert ist ein Array mit X Feldern, die die ausgelesenen Werte in der Oben angegebenen Reihenfolge enthalten
        public List<string> WMINetworkAdapterConfigurationIP(string hname)
        {

          ConnectionOptions options = new ConnectionOptions();
          options.Username = “username”;
          options.Password = “password”;

          ManagementScope scope = new ManagementScope(“\\” + hname + “\root\cimv2”, options);

         scope.Connect();


            // NetworkAdapterConfig auslesen
            SelectQuery selectQuery = new SelectQuery(“Select * from Win32_NetworkAdapterConfiguration where IPEnabled=TRUE”);

            ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, selectQuery);


            string[] sqlname = { “Description”, “IPAddress”, “MACAddress”, “DefaultIPGateway”, “IPSubnet” };


            List<string> zurueck = new List<string>();


            foreach (ManagementObject disk in searcher.Get())

            {
                for (int i = 0; i < sqlname.Count(); i++)
                {
                    if (disk[sqlname[i]] == null)
                    {
                        zurueck.Add(“–“);
                    }
                    else if (disk[sqlname[i]].ToString() == “System.String[]”)
                    {
                        string[] arrIP = (string[])(disk[sqlname[i]]);
                        zurueck.Add(arrIP[0]);
                    }
                    else
                    {
                        zurueck.Add(disk[sqlname[i]].ToString());
                    }
                }
            }
            return zurueck;
        }
————————————————————————————————————

Nur die gelb markierten Bereichen müssen verändert werden um die Abfrage an individuelle Bedürfnisse anzupassen.


Der Aufruf der Funktion könnte wir folgt aussehen:
————————————————————————————————————

 
          // ************************************************
            // Die “LISTEN” für das table “NETWORK” anlegen
            List<string> ColNameNetwork = new List<string>();
            List<string> RoValueNetwork = new List<string>();

            // NetworkAdapterConfiguration Daten abrufen
            List<string> NetAdaptConf = new List<string>();
            NetAdaptConf = WMINetworkAdapterConfigurationIP(hostn);
            RoValueNetwork.AddRange(NetAdaptConf);
            string[] colnameAdaptConf = { “DESCRIPTION”, “IP”, “MACADD”, “GATEWAY”, “SUBNETADD” };
            foreach (string colheadname in colnameAdaptConf)
            {
                ColNameNetwork.Add(colheadname);
            }


// *******************************************************************************
// ***** Daten in das DataSet “DS_MWS” übergeben mit dem Table “NETWORK” *****
//*****************************************************************************

            // Das DataTable “Network” anlegen

            DataTable DaTaNetwork = new DataTable(“Network”);

            for (int x = 0; x < ColNameNetwork.Count; x++)
            {
                DaTaNetwork.Columns.Add(ColNameNetwork[x], typeof(System.String));
            }

            // Eine neue Zeile in der Table erzeugen
            DataRow DaRoNetwork = DaTaNetwork.NewRow();

            // Den Spalten der neuen Zeile Werte zuweisen
            for (int y = 0; y < RoValueNetwork.Count; y++)
            {
                DaRoNetwork[y] = RoValueNetwork[y];
            }

            // Die neue Zeile mit allen Daten in das DataTable schreiben

            DaTaNetwork.Rows.Add(DaRoNetwork);


            // *********************************
            // Ein neues DataSet DS_MWS erzeugen
            // *********************************

            DataSet DaSe = new DataSet(“DS_MWS”);


            // Das Table NETWORK in das DataSet schreiben

            DaSe.Tables.Add(DaTaNetwork);



————————————————————————————————————

Zum Schluss möchte ich das DataSet noch in eine XML-Datei schreiben.

————————————————————————————————————

 
                // *************************
            // DataSet als XML speichern
            // *************************
            string XMLpath = @”C:tempUT-MWS-Inventary”;
 
            if (Directory.Exists(XMLpath) == false)
            {
                Directory.CreateDirectory(XMLpath);
            }
 
            DaSe.WriteXml(XMLpath + “MWS-Inventary.xml”);
 
————————————————————————————————————
 
 

Vielleicht hat Euch mein kleines Beispiel gefallen.
Der Code ist noch nicht optimal. Ich denke man kann ihn aber nutzen und auf seine Bedürfnisse anpassen.

Hab Ihr noch Fragen oder findet Ihr Fehler, dann schreib doch einfach etwas Nettes im Anschluss an diesen Post.

Viele Grüße
Thomas


Mein erstes Projekt, wie bei so Vielen, ist der Versuch einen Temperaturfühler an den RaspPi anzuschließen und die Daten aufzuzeichnen.
Bei meiner Suche im Internet bin ich dann auf den DS18B20 W1 gestoßen. Dieser lässt sich sehr einfach verarbeiten, da es ein Eindraht-Bus-Sensor ist. Das bedeutet, so hab ich es verstanden, das dieser Fühler über nur einen Kontakt alle wichtigen Daten liefert.
 
Zum Beispiel:

 

  • Seine eindeutige Kennung

 

  • Die aktuelle Temperatur mit 5 Stellen hinter dem Komma bei einer Genauigkeit von +/-0,5°C

 

 
Die Fühler bekommt Ihr bei EBAY, 10 Stück für ca. 11,00€.
 
 
 
Also ist die erste Frage die ich mir stellte, wie soll ich die Dinger jetzt anschließen. Zu meinem Erstaunen, war das viel einfacher als gedacht.

 

 
 
Mit nur wenigen Handgriffen war der Sensor angeschlossen und konnte benutzt werden. Alles was ich noch brauchte war ein Wiederstand von 4,7K Ohm. Also mal schnell das Steckbrett aus der Ecke gekramt und eine kleine Schaltung zusammengesteckt.
 
 
 
Wenn nur alles im Leben nur so einfach wäre. 🙂
 
Rot – 3,3V
Blau – GND
Grün – DatenBus (GPIO 4)
 
 —————————————————————————————————————-