Arduino mit 2 Shields - Motorsteuerung + SD-Karte

Hallo zusammen,

ich baue gerade, als mein erstes Arduinoprojekt, eine Steuerung zur Belüftung meines Kellers.

Komponenten:
1 Ardunio Uno R3
1 Arduinio Motor Shield http://arduino.cc/en/Main/ArduinoMotorShieldR3
1 Zukauf SD-Shield mit Uhr SD Card Shield Plus for Arduino (Read/Write Data)
2 DHT22 Temperatur- Luftfeuchtesensoren
2 Conrad Getriebemotoren %product-title% kaufen

Funktionsprinzip:

  • ein Temp./LF Sensor im Keller ('kurzes Kabel')
  • ein Temp./LF Sensor draußen ('langes Kabel')
  • anhand vom Taupunkt (draußen) und der Temperatur im Keller sollen meine Kellerfenster geschlossen/geöffnet werden
  • zusätzlich sollen die Messwerte auf der SD-Karte geloggt werden
  • Fenster öffnen --> zeitgesteuert = z.B. 15s in eine Richtung laufen lassen
  • Fenster schliessen --> Motorstromgesteuert: so lange in andere Richtung laufen lassen bis Motorstrom Grenzwert übersteigt

was bisher funktioniert:
Ich habe bisher diese Teilaufgaben anhand verschiedener Beispiele/Vorlagen einzeln getest, alles beim voll zusammen gesteckten (Ardunio+2 Shields) und verkabelten Arduino.

läuft: - Temp.+LF beider Sensoren auslesen (Ausgabe über Serial.println)
läuft: - Taupunkt berechnen (Ausgabe über Serial.println)
läuft: - Messwerte mit Semikolon getrennt in txt-Datei auf SD-Karte speichern
läuft: - Messwerte + Datumsstempel und mit Semikolon getrennt in txt-Datei auf SD-Karte speichern
läuft (wie gesagt, wenn ich es einzeln teste): - Motor auf Kanal A (Richtung: PIN 12, Brake: PIN 9, PWM: PIN3), in beide Richtungen mit beliebiger Geschwindigkeit laufen lassen
läuft (wie gesagt, wenn ich es einzeln teste): - Motor auf Kanal A laufen lassen und Motorstrom auslesen

noch nicht getestet habe ich das für Kanal B, bzw. A+B parallel - ich gehe aber fest davon aus, dass das geht, das Shield sollte das ja hergeben...

was nicht funktioniert:
ich wollte jetzt die Motorsteuerung (für Anfang erstmal 3s ein Richtung drehen lassen, Pause, 3s andere Richtung drehen lassen) in mein bestehendes Programm (Stand: Messwerte + Datumsstempel und mit Semikolon getrennt in txt-Datei auf SD-Karte speichern) integrieren, allerdings ändert sich dabei die Drehrichtung vom Motor (PIN12 high oder low) nicht...

ich denke es hängt mit irgendwie mit dem i2c-Bus und dem Datalogger zusammen, die PINs 11, 12, 13 werden ja von beiden genutzt.
Pinbelegung: http://s14.directupload.net/file/d/3105/o9c22eij_jpg.htm

Und hier der Quellcode (sicher etwas hemdsärmlich, aber es ist wie gesagt das erstemal, dass ich mit dieser Programmiersprache arbeite): siehe nächster Post.

Ich hoffe es gibt eine (programmiertechnische) Lösung für mein Problem.

Viele Grüße, Hannes

// Taupunktberechnung
// k = kurzer Sensor
// l = langer Sensor

#include "DHT.h"    //Temperatur- + Luftfeuchtesensoren
#include "math.h"   //Taupunktberechnung
#include "SD.h"     //SD-Card
// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 10;  //SD-Card

#include "Wire.h"  //Uhrzeit
#define DS1307_I2C_ADDRESS 0x68  // This is the I2C address

//Temperatur- + Luftfeuchtesensoren
#define DHTPINk 2     // D2 PIN2 für kurzen Sensor
#define DHTPINl 4     // D4 PIN4 für langen Sensor
#define DHTTYPE DHT22   // DHT 22  (AM2302)
// Connect pin 1 (on the left) of the sensor to +5V
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
DHT dhtk(DHTPINk, DHTTYPE);
DHT dhtl(DHTPINl, DHTTYPE);

//Konstanten zur Taupunktberechnung #####################
const float a =   7.5;
const float b = 237.3;


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void setup() {
//Temperatur- + Luftfeuchtesensoren   ###################
  dhtk.begin();
  dhtl.begin();

//Motor   ###############################################
  //Setup Channel A
  pinMode(12, OUTPUT); //Initiates Motor Channel A pin
  pinMode(9, OUTPUT);  //Initiates Brake Channel A pin
  //Setup Channel B
  pinMode(13, OUTPUT); //Initiates Motor Channel A pin
  pinMode(8, OUTPUT);  //Initiates Brake Channel A pin

//Uhrzeit   ############################################
  Wire.begin();  //Uhrzeit
  
//SD-Card     ##########################################
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(10, OUTPUT);

  Serial.begin(9600); 
  Serial.print("Initializing SD card...");
  
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("SD-Card failed, or not present");
    // don't do anything more:
//rote LED leuchten lassen    
    return;
  }
  Serial.println("SD-Card initialized.");

//Fensterschließen lassen als Referenzierung
 
}
//Ende Void setup
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void loop() {
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float hk = dhtk.readHumidity();
  float tk = dhtk.readTemperature();
  float hl = dhtl.readHumidity();
  float tl = dhtl.readTemperature();


  // check if returns are valid, if they are NaN (not a number) then something went wrong!
  if (isnan(tk) || isnan(hk)) {
    Serial.println("Failed to read from DHTk");
//rote LED leuchten lassen
  } else {
    Serial.print("DHTk Humidity: "); 
    Serial.print(hk);
    Serial.print(" %\t");
    Serial.print("Temperature: "); 
    Serial.print(tk);
    Serial.print(" *C   ");
  }
  // check if returns are valid, if they are NaN (not a number) then something went wrong!
  if (isnan(tl) || isnan(hl)) {
    Serial.println("Failed to read from DHTl");
//rote LED leuchten lassen
  } else {
    Serial.print("DHTl Humidity: "); 
    Serial.print(hl);
    Serial.print(" %\t");
    Serial.print("Temperature: "); 
    Serial.print(tl);
    Serial.print(" *C  ");
  }
  Serial.print("Taupunkt fuer DHTk: ");
  float TPk = taupunkt(hk,tk);
  Serial.print(TPk);
  Serial.println(" *C");


//Speicherung auf SD-Karte

  // make a string for assembling the data to log:
  String dataString = "";
  //5 Stellen reservieren
  char* s = "     ";

  //append to the string:
  s = dtostrf(hk,5,1,s);
  dataString += s;
  dataString += ";";
  s = dtostrf(tk,5,1,s);
  dataString += s;
  dataString += ";";
  s = dtostrf(hl,5,1,s);
  dataString += s;
  dataString += ";";
  s = dtostrf(tl,5,1,s);
  dataString += s;
  dataString.replace('.', ',');
  //Uhrzeit vorne anfügen, nach Umwandlung von . in ,
  dataString = getDateDs1307SRTRING() + dataString;
  
    
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the serial port too:
    Serial.println(dataString);
  }  
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
//rote LED leuchten lassen    
  } 

//MOTOR-Test
Serial.println("Fenster oeffnen...");
OpenWindow();
Serial.println("warten (3s) ...");
delay(3000);
Serial.println("Fenster schliessen...");
CloseWindow();
Serial.println("warten (1s) ...");
delay(1000);
Serial.println("Ende");
}
//Ende void loop
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


//Hilfsfunktion zur Taupunktberechnung #################
float taupunkt(float h, float t)
{
  float result;
  float tstern;
  tstern = (a*t) / (b+t);
  result = (b*(log10(h) -2 + tstern)) / (a - log10(h) +2 - tstern);
  //Berechnung mit +/-2, da Humidity in % angegeben wird
  return result;
}


//Hilfsfunktion: Datum +Uhrzeit als String #############
// Gets the date and time from the ds1307 and prints result
String getDateDs1307SRTRING()
{
  char second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  String DateString = "";
  // Reset the register pointer
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0x00);
  Wire.endTransmission();
 
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
  // A few of these need masks because certain bits are control bits
  // alle müssen ausgelesen werden, auch wenn nicht weiter verwendeten werden, wg. Reihenfolge
  second     = bcdToDec(Wire.read() & 0x7F);
  minute     = bcdToDec(Wire.read());
  hour       = bcdToDec(Wire.read() & 0x3F);  // Need to change this if 12 hour am/pm
  dayOfWeek  = bcdToDec(Wire.read());
  dayOfMonth = bcdToDec(Wire.read());
  month      = bcdToDec(Wire.read());
  year       = bcdToDec(Wire.read());

  DateString += String(dayOfMonth, DEC);
  DateString += ".";
  DateString += String(month, DEC);
  DateString += ".";
  DateString += String(year, DEC);
  DateString += " ";
  DateString += String(hour, DEC);
  DateString += ":";
  DateString += String(minute, DEC);
  DateString += ";";
  return DateString;
}

//Uhrzeit ################################################
// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}

//Fenster öffnen #########################################
void OpenWindow()
{
  //MOTOR A ---- forward @ full speed
  digitalWrite(12, LOW);  //Establishes forward direction of Channel A
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  analogWrite(3, 255);    //Spins the motor on Channel A at full speed
  
  delay(3000);

  //anhalten
  digitalWrite(9, HIGH);  //Eengage the Brake for Channel A
  delay(1000);            //Verzögerung, damit Bremse noch Strom hat (min 1 s)
  analogWrite(3, 0);      //Strom für Motor abschalten --> Bremse ohne Funktion
  
}

//Fenster schliessen #####################################
void CloseWindow()
{
  //MOTOR A ---- backward @ full speed
  digitalWrite(12, HIGH); //Establishes forward direction of Channel A
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  analogWrite(3, 255);    //Spins the motor on Channel A at full speed
  
  delay(3000);

  //anhalten
  digitalWrite(9, HIGH);  //Eengage the Brake for Channel A
  delay(1000);            //Verzögerung, damit Bremse noch Strom hat (min 1 s)
  analogWrite(3, 0);      //Strom für Motor abschalten --> Bremse ohne Funktion

}

habe gerade noch ein wenig weiter gesucht und den "i2c scanner" benutzt:

I2C Scanner
Scanning...
I2C device found at address 0x50 !
I2C device found at address 0x68 !
done

vielleicht nützt das...
oder das: http://neuroelec.com/2011/02/soft-i2c-and-programmable-i2c-address/

aber das sind bei mir alles nur Vermutungen, so richtig dahinter gestiegen, wo das Problem liegt bin ich nicht

HannesKoe:
ich denke es hängt mit irgendwie mit dem i2c-Bus und dem Datalogger zusammen, die PINs 11, 12, 13 werden ja von beiden genutzt.
Pinbelegung: http://s14.directupload.net/file/d/3105/o9c22eij_jpg.htm

Nein. Der I2C Bus ist auf A4 und A5 und nicht auf D11,D12 und D13.
Daran kanns nicht liegen.
Die SD - Karte und das Arduinio Motor Shield kommen sich ins Gehege:

The shield's pins, divided by channel are shown in the table below:
Function pins per Ch. A pins per Ch. B
Direction D12 D13
PWM D3 D11
Brake D9 D8
Current A0 A1
Sensing

Die einzige Lösung die ich sehe ist einen externen Motortreiber zu verwenden.
Die Endpunkte des Fensters würde ich mit Endschaltern doppelt absichern ( einen Schalter für die Elektronik und einen zweiten als Notstop).

Grüße Uwe

Hallo Uwe,

das die beiden sich ins Gehege kommen hatte ich auch schon vermutet, es werden ja die PINs 11, 12, 13 doppelt benutzt.

Es hängt wohl eher damit zusammen: SPI - Arduino Reference

Da die beiden Shields nicht zeitgleich angesprochen werden müssen, hatte ich gedacht, dass man das so switchen kann, dass die jeweiligen Signale an den PINs immer dann anliegen, wie sie gerade gebraucht werden (Motor oder SD).
Variante a) programmiertechnische Lösung: zeitversetztes ansteuern der PINs je nach zu erfüllender Funktion

Allerdings weiß ich nicht wie das mit der SD Karte funktioniert...
Bei z.B. PIN 12 (MISO - Master Out Slave In) und 13 (SCK - Serial Clock) muss nach meinem Verständnis für den Motor je nach Richtung nur ein dauerhaftes HIGH oder LOW anliegen - evtl. kann man die Verbinder da auch trennen und über andere Ausgänge ansteuern...
Variante b) Verdrahtung ändern: PINs 11,12,13 für das Motorshield durch andere PINs des Arduino ersetzten z.B. D5, D6, D7

Ich versteh nicht, warum das Motorshield unbedingt den PIN12, wo da anscheinend ein für die Kommunikation mit anderen Shields wichtiger Taktgeber drüber läuft, nutzt, nur um ein Dauersignal LOW oder HIGH zu setzen...

Was neues kaufen/selber zusammenlöten wollte ich jetzt erstmal vermeiden - Strippen ziehen ist okay :wink:

Die SD Karte hat ein Enable Signal an Pin 10 und darum kann sie von den Pins 11,12, und 13 "getrennt werden".
Das Motorshield hat kein Enable und wird darum während der Ansteuerung der SD-Karte auch angesprochen.
Alternattive:
Das http://www.komputer.de/zen/index.php?main_page=product_info&cPath=22&products_id=32 Beschreibung: Neues 2A Arduino Motor Shield von DFrobot | komputer.de hat den gleichen Treiberbaustein aber an den Pin D4 bis D8 und http://www.dfrobot.com/image/data/Common/Arduino%20Shield%20Manual.pdf ab Seite 8.

Den DHT langer Sensor müßtest Du dann von D4 auf D3 versetzen.

Grüße Uwe

Hallo,

danke Uwe für den Hinweis, das alternative Shield habe ich jetzt erstmal bestellt. Ärgert mich zwar, aber ist ja noch bezahlbar, das Projekt soll ja irgendwann auch mal fertig werden.

Nichtsdesto trotz reizt es mich immer noch das programmiertechnisch zu lösen.

Ich konnte leider inzwischen nur kurz was ausprobieren.

a) ich habe folgendes vor der Fenster-öffnen/schließen-Abfolge im void loop{} mal eingefügt und ausprobiert:
digitalWrite(10, LOW);
pinMode(10, INPUT);
delay(500);
danach wieder:
pinMode(10, OUTPUT);

Das funktioniert manchmal nur zufällig, sehr misteriös - was kann ich alternativ über PIN10 senden, damit das SD-Shield getrennt wird, dann sollte das Motorshield ja wieder funktionieren??? Das ganze kann ich ja in der Loop-Schleife einbauen, so das die Shields sequentziell nacheinander angesteuert werden.

b) wenn ich die Fenster-öffnen/schließen-Abfolge im void setup{} vor SD.begin(chipSelect) einfüge dreht er richtigrum - einmal vorwärts, einmal rückwärts.

Ähnlicher Ansatz wie oben mit der sequentiellen Abfolge: ich könnte doch auch den SD.begin() Befehl in die void loop{} nach der Fenster-auf/zu-Abfolge packen. Allerdings brauch ich dann wohl noch eine Art SD.end() Befehl, damit es im nächsten Durchlauf der Schleife noch funktioniert.
Ich kann aber leider nicht in die SD.h Bibliothek reinschauen, um zu schauen, was der SD.begin Befehl macht um einen Art komplementären SD.end Befehl zu programmieren... Vielleicht hat jemand noch eine Idee dazu?

Grüße, Hannes

PS: m.M.n. muss das Motorshield nicht zwangsläufig getrennt werden, da meine ersten Versuche ja schon gezeigt haben, dass auf der SD-Karte schreiben, bei gleichzeitig angeschlossenem (nicht angesteuertem) Motor-Shield funktioniert

Das Problem ist nicht die SD karte sondern das Motorshield wenn Du Daten an die SD Karte Schickst oder davon holst. Die Daten/Steuersignale auf pin 13, 12, 11, 10 steuern den L298 auf der Motorkarte an.

digitalWrite(10, LOW);
  pinMode(10, INPUT);
  delay(500);
danach wieder:
  pinMode(10, OUTPUT);

hat keinen Sinn. Du definierst das Pin als Eingang und somit hochohmig (ohne definierten Pegel).
Pins die doppelt belegt sind und darum inkompatibel sind kannst Du nicht per Software kompatibel machen.

Grüße Uwe

Guten Abend zusammen und ein gesundes Neues!

Ich habe jetzt das neue MotorShield in Betrieb genommen und es harmoniert soweit mit dem SD-Shield.
(Bis auf das die PINs in der Beschreibung für M1 und M2 vertauscht waren)

Allerdings...scheint mir das neue Motorshield keine Strommessfunktion zu haben...
Ich wollte diese, siehe oben, nutzen, um das Schließen des Fensters zu steuern.
Ich würde diese Variante gegenüber Endschaltern bevorzugen, da so auch Verklemmungen (Laub, Äste, Mäuse :wink: etc.) auch zu einer Unterbrechung des Motors führen.
Die Endschaltern wäre für mich dann nur noch Redudanz mit zusätzlichem Kosten-, Installations- u. Verdrahtungsaufwand, den ich vermeiden würde wollen. Ich schätze die Ausfallsicherheit der Strommessung deutlich höher ein als bei den Endlagerschalter und sah da keine weiteren Vorteile oder habe ich was übersehen?

  1. Hat das Shield wirklich keine Möglichkeit zur Strommessung?

  2. Belesen habe ich mich schon mit der Shunt-Variante mit geringem Widerstand
    Arduino Forum

Den Strom muss nicht genau/absolut gemessen werden, ich will ja letzendlich bloß einen Grenzwert festlegen, den ich in Versuchen empirisch ermitteln kann.

Welche Größe des (niederohmigen) Widerstands wäre angemessen?
Ich würde gern auf mein vorhandes kleines Widerstandssortiment zurückgreifen, um mir den Weg zu Conrad zu sparen.
Wie erkenne ich, dass der Widerstand die Leistung aushält?
Mein Überschlagsrechnung ergibt 24 W (12V bei max. 2A).

grüße, Hannes

HannesKoe:
Welche Größe des (niederohmigen) Widerstands wäre angemessen?
Ich würde gern auf mein vorhandes kleines Widerstandssortiment zurückgreifen, um mir den Weg zu Conrad zu sparen.
Wie erkenne ich, dass der Widerstand die Leistung aushält?
Mein Überschlagsrechnung ergibt 24 W (12V bei max. 2A).

Bei 2 A sollen aber keine 12V am Shunt abfallen:

1 Ohm / 4 Watt wäre eine einfache Wahl: bis max 2 A geeignet, bei normaler Last (190mA lt. Datenblatt 300mA lt. Conrad) 0.2-0.3V Spannungsabfall.
Mit interner Referenzspannung von 1.1V hättest du bei 1A als Abschaltkriterium den vollen Messbereich.
Wenn du noch andere Analogmessungen hast und die Standard 5V Vref brauchst, hast du immerhin eine Auflösung von ca. 5 mA / bit.

Abend!

Wäre auch zu einfach, wenn es gleich funktionieren würde.

Die gute Nachricht, ich habe exakt die gesuchten Widerstände gehabt.
Gelötet, verdrahtet, umprogrammiert - geht nicht.

Hier eine Skizze, wie ich es verdrahtet habe.
http://s14.directupload.net/file/d/3126/hz595863_pdf.htm
Unsicher bin ich mir mit der Masse, da die jeweiligen Motor Minus glaube ich nicht direkt mit dem GND vom Shield verbunden sind, gab zumindest keinen vollständigen Durchgang..., oder täusche ich mich da?
Sinn von dem Motorshield ist es ja nicht den vollen Strom durch den Arduino zu schicken...

Mein Testprogramm: Motor vorwärts drehen, Strom messen, Motor rückwärts drehen, Pause und wieder von vorne. Nur Motor 1 zu Testzwecken.

//Arduino PWM Speed Control? 

int E1 = 5;
int M1 = 4;
int E2 = 6;
int M2 = 7;
int currentPinM1 = 1;
int currentPinM2 = 2;

// variables
float currentRaw; // the raw analogRead ranging from 0-1023

void setup()
{
  pinMode(M1, OUTPUT);
  pinMode(M2, OUTPUT);
  pinMode(E1, OUTPUT);
  pinMode(E2, OUTPUT);
  Serial.begin(9600);
}

void loop()
{ 

    digitalWrite(M1,HIGH);
//    digitalWrite(M2, HIGH);
    analogWrite(E1, 255); //PWM Speed Control 
//    analogWrite(E2, value); //PWM Speed Control 

   currentRaw = analogRead(currentPinM1);
   Serial.println(currentRaw);

    delay(1000); 

    digitalWrite(M1,LOW);
    analogWrite(E1, 255); //PWM Speed Control 
    delay(1000);

    analogWrite(E1, 0); //PWM Speed Control 
    delay(20);

}

Mit angeschlossenem A1 dreht der Motor kurz, wechselt die Richtung und dreht dann unendlich lange weiter, die USB-Verbindung zum PC bricht dabei ab.

Ohne A1 angeschlossen fkt. alles einwandfrei.
Die Analogmessung alleine (getestet mit Bsp.Prog. der AnalogRead Funktion und einer AA-Batterie) funktioniert soweit für die PINs 0 bis 5.
Ohne angelegter Spannung zweigen die PINs 4 und 5 den Wert 1023 an, die anderen zeigen einen schwankenden Wert um die 400 oder 800.

Analogmessung während Motortestprogramm funktionierte nur für die PINs 0 und 3 bis 5. Bei 1 und 2 kam es zum Abbruch der USB-Verbindung - wobei es gerade eben wieder ging...

Kann es sein, dass ich mir die A1 und A2 zerschossen habe?
Wie wird es richtig verdrahtet? Was habe ich falsch gemacht?

Wenn Du sehr viel Glück hast, hast Du den Arduino und die USb-Anschluß des PCs nicht geschrottet.

Du kannst den Shunt nicht auf den Minuspol des Motors schalten.
Wenn dieser Pol vom Motortreiber auf Masse geschaltet wird dann hast Du immernoch den Spannungsabfall des Ausgangstransistors in Serie zum Shund und die Messung ist viel zu hoch. Wenn Du die Drehrichtung umkehrst hast Du am Shund fast 12V die Du direkt am Analogeingang anlegst und somit diesen wahrscheinlich kaputtgemacht hast.

Jetzt weiß ich nicht welchen Treiberbaustein Du schlußendlich verwendest. Wenns noch der geliche ist, dann ist es ein L298. Also nachdem Du einen neuen Arduino gekauft hast schaltest Du den Shunt zwischen SEN_A bzw SEN_B gegen Masse wie im schaltbild http://arduino.cc/en/uploads/Main/arduino_MotorShield_Rev3-schematic.pdf R1 bzw R2

Falls Dein Shield keinen Widerstand vorgesehen hat mußt Du die Leiterbahn von SEN_A bzw SEN_B auf Masse unterbrechen und die beiden Strommeßwiderstände drauflöten. Ich weiß nicht ob das platzmäßig machbar ist oder ob die Leiterbahn unterbrechen kannst weil die beiden Pins nicht direkt auf die Massefläche der Platine gehen.

Grüße Uwe

Abend,
danke schonmal für die Hinweise!

Ich hab das von dir empfohlene MotorShield von DFrobot benutzt. Es hat den L298P-Chip.

Also wenn ich das richtig verstanden habe, würde ich die Beinchen 2 und 19 vom Chip die an die Platine angelötet sind mit dem Seitenschneider möglichst weit unten abtrennen, hochbiegen und da jeweils das eine Ende des Widerstand anlöten. Vielleicht gut zu erkennen hier:

Das zweite Ende kann ich dann auch gemeinsam auf die Schraubklemme (-) von PWRIN klemmen. Der Abzweig zum Anlogeingang ist dabei zwischen Chip und Widerstand, richtig?

Welches sind nun die richtigen PINs?
Okay, habe gerade gesehen, dass der Chip eine Fase an einer Ecke hat - ist das die Kennzeichnung für den Beginn der Nummerierung = PIN1 ?
Ich habe gerade noch mit dem original Arduino MotorShiled vergleichen und anscheinden sind die beiden den Anschlüssen und der Chipseite mit der Fase zugewandten PINs in zweiter Reihe jene welche gemeint sind, weil ich da die Leiterbahnen und die SMD-Widerstände 0R150 erkennen kann.

Bei dem Shield von DFrobot haben diese PINs Durchgang zu GND.

Wenn das jetzt der letzte Arbeitsschritt ist, außer dem restlichen Programmieren, wäre ich ziemlich froh :slight_smile:
Schönen Abend,
Grüße, Hannes

Hallo zusammen,

für meinen Keller möchte ich auch eine Lüftersteuerung bauen. Jedoch habe ich ein Problem mit der Berechnung des Taupunktes. Alle Formeln, die ich finde brauchen auch den Luftdruck. Hier im Thread habe ich aber folgenden Code gefunden, der die Sache recht einfach erscheinen lässt:

//Hilfsfunktion zur Taupunktberechnung #################
float taupunkt(float h, float t)
{
  float result;
  float tstern;
  tstern = (a*t) / (b+t);
  result = (b*(log10(h) -2 + tstern)) / (a - log10(h) +2 - tstern);
  //Berechnung mit +/-2, da Humidity in % angegeben wird
  return result;
}

Ist das ein übliche Vereinfachung? Muss ich dann nicht Sicherheiten einrechnen für schwankenden Lufdruck?

Ich hoffe jemand versteht mein Problem und weiß eine Antwort.

Schon mal vielen Dank