Show Posts
Pages: 1 ... 42 43 [44] 45 46 ... 190
646  International / Deutsch / Re: Hilfe, Leonardo kaputt? Led 13 fadet? on: March 16, 2014, 12:32:08 pm
ich bin gerade etwas verwirrt, ich habe meinen Arduino Leonardo mit embedXcode programmiert. Normalerweise geht es ganz gut. Seit dem letzten flashen blinkt die lede l (13). Es ist weniger ein blinken als ein Faden. Kennt einer diesen Feher? Ich kann den Arduino leider auch an keinem Port mehr am macbook finden.

Wenn Du befürchtest, dass Du Dein Board mit einem Kurzschluss gekillt hast, mache doch erstmal einen ganz groben Test:

Sämtliche äußere Beschaltung vom Board entfernen.
USB ausstöpseln.
10 Minuten warten.
USB einstöpseln.

Wird das nackte Board dann wieder mit seinem Port am Rechner erkannt?
647  International / Deutsch / Re: Frage zu SD Byteweise auslesen on: March 16, 2014, 11:21:37 am
wenn Ich  char zelle1 = readLineFromFile();
bekomme Ich folgende Fehlermeldung

sketch_mar16a.ino: In function 'int Stundenaufsdlesen()':
sketch_mar16a:7: error: too few arguments to function 'char* readLineFromFile(File)'
sketch_mar16a:52: error: at this point in file

Na dann ist ja alles in bester Ordnung!

Du rufst die Funktion OHNE PARAMETER auf:
  char zelle1 = readLineFromFile();

Aber die Funktionsdeklaration besagt, dass Du das FILEHANDLE ALS PARAMETER an die Funktion übergeben sollst:
char* readLineFromFile(File  myFile)

Richtigerweise lautet die Fehlermeldung daher:
> too few arguments to function 'char* readLineFromFile(File)'

Exakter und genauer geht es bei so einer offensichtlich provozierten Fehlermeldung nun wirklich nicht!
648  International / Deutsch / Re: PWM Zeitversätzt nach Start ansprechen on: March 16, 2014, 06:48:24 am
wobei mir das mit dem Sortiertem Array am besten gefallen tut, da ich hier die nicht die Befürchtung habe das x Abfragen jedes mal bei jedem Loop abgefragt werden müssen :-)

jedoch muss ich auch gestehen das ich das noch noch so ganz verstanden habe wie was gemacht werden soll,
ich habe leider jetzt am WE wenig zeit :-(
hoffe aber das ich nächste Woche da mal dazu komme mir da mehr Gedanken drüber zu machen wie das gemeint ist.

Ich habe da mal was vorbereitet:
Code:
//Ventilsteuerung by 'jurs' for German Arduino Forum

int startPin = 3; // Digitaler Pin für Start-Taster
// Art des Pull-Widerstands am startPin auf INPUT_PULLUP oder INPUT festlegen
// INPUT_PULLUP für internen PullUp oder INPUT für externen PullDown Widerstand
#define INPUT_TYPE INPUT_PULLUP 

int ventil1Pin = 12;
int ventil2Pin = 11;
int ventil3Pin = 10;
int kameraPin = 9;
int blitzPin = 8;

#define MS 1000L  // Umrechnung Millisekunden in Microsekunden

struct hardware_t{int pin;long vorlaufzeit; long dauer;};

// Vorlaufzeit und Dauer für die Hardware
hardware_t hardware[]={
  {ventil1Pin, 222*MS, 3*MS},
  {ventil1Pin, 2000*MS, 300*MS},
  {ventil1Pin, 2440*MS, 40*MS},
  {ventil2Pin, 2300*MS, 140*MS},
  {ventil1Pin, 12000*MS, 3*MS},
  {ventil2Pin, 3500*MS, 0*MS},
  {ventil3Pin, 2440*MS, 400*MS},
  {kameraPin,  2444*MS, 2*MS},
  {blitzPin,   3*MS, 2*MS},
};

#define schritte sizeof(hardware)/sizeof(hardware[0])

// Struktur einer einzelnen Schaltzeit
struct schaltzeit_t{int pin;long zeit; boolean geschaltet;};
// schaltzeiten-Array mit je einer Ein- und Ausschaltzeit pro Hardwareeintrag
schaltzeit_t schaltzeiten[2*schritte];
int anzahlSchaltzeiten; // Anzahl der tatsächlichen Schaltzeiten

long geschalteteZeit[2*schritte]; // Debug only: tatsächliche Schaltzeiten

void sortSchaltzeiten(int n)
{ // Schaltzeiten-Array chronologisch sortieren
  // n = Anzahl der Schaltzeiten im Array
  // Bubblesort-Algorithmus
  schaltzeit_t temp; // Hilfsvariable beim Tauschen von Elementen
  for(int x=0; x<n; x++)
  {
    for(int y=0; y<n-1; y++)
    {
      if (schaltzeiten[y].zeit>schaltzeiten[y+1].zeit)
      {
        temp=schaltzeiten[y+1];
        schaltzeiten[y+1]=schaltzeiten[y];
        schaltzeiten[y]=temp;
      }
    }
  }
}

void debugPrintSchaltzeiten()
// Schaltzeiten NACH Ablauf aller Schaltzeiten ausgeben
{
  char line[51];
  Serial.println("Debug-Ausgabe der Soll- und Ist-Schaltzeiten");
  snprintf(line,sizeof(line),"%3s %10s %10s %2s","Pin","Soll-Zeit","Ist-Zeit","Status");
  Serial.println(line);
  for (int i=0;i<anzahlSchaltzeiten;i++)  // tatsächliche Schaltzeiten anzeigen
  {
    snprintf(line,sizeof(line),"%3d %6ld.%03ld %6ld.%03ld %d",schaltzeiten[i].pin,schaltzeiten[i].zeit/1000,schaltzeiten[i].zeit%1000,geschalteteZeit[i]/1000,geschalteteZeit[i]%1000,schaltzeiten[i].geschaltet);
    Serial.println(line);
  }
}

unsigned long gesamtDauer;

void setup()
{
  Serial.begin(9600); // Serielle Schnittstelle mit 9600 Baud starten
  Serial.println("Ventilsteuerung by 'jurs' for German Arduino Forum");
  pinMode(startPin, INPUT_TYPE);  // Art des Eingangs setzen und ggf. internen PullUp aktivieren
  gesamtDauer=0; // Gesamtdauer des längsten Schaltschritts ermitteln
  anzahlSchaltzeiten=0;
  for (int i=0;i<schritte;i++)
  {
    pinMode(hardware[i].pin,OUTPUT); // Pin auf OUTPUT setzen
    // Nun die beiden Schaltzeiten des Eintrags ins schaltzeit-Array eintragen 
    if (hardware[i].dauer>0)  // aber nur, wenn die Schaltdauer>0 ist
    { // Jeder hardware-Eintrag führt zu einer Ein- und einer Ausschaltzeit
      schaltzeiten[anzahlSchaltzeiten].pin=hardware[i].pin;
      schaltzeiten[anzahlSchaltzeiten].zeit=hardware[i].vorlaufzeit;
      schaltzeiten[anzahlSchaltzeiten].geschaltet=true;
      anzahlSchaltzeiten++;
      schaltzeiten[anzahlSchaltzeiten].pin=hardware[i].pin;
      schaltzeiten[anzahlSchaltzeiten].zeit=hardware[i].vorlaufzeit+hardware[i].dauer;
      schaltzeiten[anzahlSchaltzeiten].geschaltet=false;
      anzahlSchaltzeiten++;
    }
  }
  sortSchaltzeiten(anzahlSchaltzeiten);
  gesamtDauer=schaltzeiten[anzahlSchaltzeiten-1].zeit; // Gesamtdauer = Zeit beim letzten Abschalten
  Serial.print("Gesamtdauer: ");
  Serial.print(gesamtDauer/1000.0,3);
  Serial.print(" Millisekunden = ");
  Serial.print(gesamtDauer);
  Serial.println(" Mikrosekunden");
  Serial.print("Warte auf Input an Pin ");
  Serial.print(startPin);
  Serial.println(" ...");


void loop() { 
  unsigned long starttime;
  unsigned long looptime;
  boolean startPinPressed=digitalRead(startPin);
  if (INPUT_TYPE==INPUT_PULLUP) startPinPressed=!startPinPressed; // invertierte Logik bei PullUp-Widerstand am Taster
  if (startPinPressed)
  {
    Serial.println("Started...");
    starttime=micros();
    for (int i=0;i<anzahlSchaltzeiten;i++)  // Alle Schaltzeiten abarbeiten
    {
      while ((looptime=micros()-starttime)<schaltzeiten[i].zeit) ; // warten
      digitalWrite(schaltzeiten[i].pin,schaltzeiten[i].geschaltet); // schalten
      geschalteteZeit[i]=looptime; // tatsächliche Schaltzeit merken
    }
    // Erst nach Durchführung aller Schaltungen die geplanten und tasächlichen Zeiten ausgeben
    debugPrintSchaltzeiten();
    Serial.println("Finished...");
  } 
}

Gegenüber der vorherigen Version sind einige Änderungen eingebaut:

1. höhere zeitliche Auflösung: Mikrosekunden statt Millisekunden
Da Du offenbar nicht nur millisekundengenau schalten möchtest, sondern auf Bruchteile von Millisekunden genau, können die Schaltzeiten nun auf Mikrosekunden genau eingetragen werden. Um mit möglicherweise vielen Nullen im Array nicht durcheinander zu kommen, kann die Multiplikation mit tausend über "*MS" direkt in der Array-Initialisierung durchgeführt werden.

2. Mehrfach-Ansteuerung derselben Hardware-Pins möglich
Durch Aufbau des Arrays "schaltzeiten" hat man eine Datenstruktur, die einer bestimmten Schaltzeit einen bestimmten Schaltvorgang zuordnet. Nach Sortierung dieses Arrays sind alle Schaltvorgänge chronologisch sortiert und können in einer Schleife abgearbeitet werden.

3. Startknopf kann mit PullUp- oder PullDown-Widerstand beschaltet werden, mit Makro im Quelltext einstellbar
Über das Makro "INPUT_TYPE" kann man den Quellcode leicht anpassen, je nachdem ob ein externer PullDown-Widerstand am Startknopf beschaltet wird oder ob der interne PullUp-Widerstand verwendet werden soll.

4. Exaktere Einhaltung der Schaltzeiten
Durch den Aufbau eines Schaltzeiten-Arrays mit Sortierung, das dann Schaltzeit für Schaltzeit in einer engen Schleife abgearbeitet wird, sind die Schaltzeiten sehr viel exakter einzuhalten. Sogar serielle Debug-Ausgaben während des Ablaufs würden die Schaltzeiten verfälschen, so dass ich zum Debuggen und Nachverfolgen die tatsächlichen Schaltzeiten während des Ablaufs im RAM-Array "geschalteteZeit" zwischenspeichere und erst NACH Ausführung aller Schaltvorgänge anzeigen lasse.

Soweit meine Tests ergeben, sind nun Einzelschaltvorgänge bis auf 4 µs (0,004ms) genau geschaltet, und nur in dem Fall, dass mehrere Schaltvorgänge zeitlich zusammenfallen, treten sehr geringe Schaltzeitabweichungen um 8, 12 oder 20 Mikrosekunden auf.
649  International / Deutsch / Re: Bei LCD 2004 Farbe der Hintergrundbeleuchtung austauschen? on: March 16, 2014, 06:02:41 am
Ich habe jetzt ein blau/weißes Display für 4,50Euro bestellt und werde das Problem mit roter Filterfolie lösen.

Ich vermute eher, Du wirst 4,50 EUR Lehrgeld bezahlen.
650  International / Deutsch / Re: Thermometer mit 4x LED-Siebensegmentanzeigen, SAA1064 u. LM35 on: March 15, 2014, 03:22:18 pm
youtube Videos gibts davon genug, nur keinen fertigen Code.

Echt nicht? Mein Google findet auch für den SAA1064 problemlos Arduino-Code:
http://tronixstuff.com/2011/07/21/tutorial-arduino-and-the-nxp-saa1064-4-digit-led-display-driver/

So mit festem Schaltpunkt, wie ich es jetzt habe, steigt die Temparatur nach dem Abschalten bei 40°C noch auf 41,5°C an, da die Heizwiderstände noch Wärme abgeben. Dieses Überschwingen ist aber nicht gewünscht  smiley-confuse
Kann mir da jemand weiterhelfen?

Heizleistung stark überdimensioniert?
Dann vielleicht eine Heizung mit etwas weniger Leistung verwenden!

Am billigsten wäre die Umrüstung per Software auf eine niedrigere Heizleistung.

Die billigste Lösung bei einer zu groß dimensionierten Heizleistung ist bei einer Zweipunkt-Regelung und Schalten mit SSR Relais: Taktung!

Für eine Taktung der Heizleistung habe ich hier mal einen kleinen Sketch für Heizungen mit SSR-Schaltung geschrieben:
http://forum.arduino.cc/index.php?topic=180102.msg1335839#msg1335839
Der Funktion wird einfach die gewünschte Heizleistung in Prozent als Parameter übergeben, das SSR Relais schaltet die Taktung dann selbständig. Um keine Schaltzeiten unter 1,0 Sekunden entstehen zu lassen ist die Regelung nur zwischen 10% und 90% Heizleistung aufs Prozent genau. Unterhalb 10% Heizanforderung wird die Heizung ausgeschaltet und über 90% Heizanforderung wird die Heizung voll eingeschaltet.

Wenn Du nun eine halb so starke Heizung haben möchtest, rufst Du (in einer "nicht blockierenden loop") auf:
heizen(50);
Und dann schaltet die Heizung immer 5 Sekunden ein, und 5 Sekunden aus.
Ergebnis: 50% Heizleistung innerhalb eines 10-Sekunden Intervalls.

Um ein Überschießen der Temperatur bei Deiner Zweipunktregelung zu vermeiden, könnte man sich auch geeignete Heizstufen überlegen mit Prozentwerten Heizleistung unter 100%, und dann eine Zwei- oder Dreipunktregelung machen. Z.B. für eine Solltemperatur von 40°C z.B. so heizen:
Isttemperatur <32°C ==> "heizen(100);"
Isttemperatur >=32 und <36°C==> "heizen(75);"
Isttemperatur >=36°C <39,5°C ==> "heizen(50);"
Isttemperatur zwischen 39,5 und 40 ==> zuletzt gesetzte Heizleistung beibehalten (Hysterese!)
Isttemperatur >= 40°C ==> "heizen(0)"

So dass im Endeffekt mit weniger Heizleistung geheizt wird, wenn man bereits nahe an der Zieltemperatur dran ist.
Bei dieser Art Regelung müßte aber die niedrigste geschaltete Heizleistung (z.B. 50%) immer noch ausreichend hoch sein, um die Zieltemperatur zu erreichen, sonst kann es Dir passieren, dass die Temperatur dauerhaft zu niedrig bleibt.
651  International / Deutsch / Re: Bei LCD 2004 Farbe der Hintergrundbeleuchtung austauschen? on: March 15, 2014, 02:07:05 pm
Wäre es möglich bei einem LCD die Beleuchtung auszutauschen. Also die blaue, weiße oder grüne LED gegen eine rote zu tauschen?

Nein, nicht so einfach.

Eine Backlight-Unit besteht aus mehr Bauteilen als nur aus einer Lichtquelle.
Unter anderem aus einer hochspeziellen Diffusor-Folie, die das Hintergrundlicht absolut gleichmäßig über den Hintergrund verteilt.  Wo willst Du denn diese hochspezielle Diffusorfolie in der benötigten Farbe herbekommen?
652  International / Deutsch / Re: Wie ° Zeichen auf Display darstellen? on: March 15, 2014, 01:23:09 pm
lcd.print("°") und lcd.print(0xDF) funktionieren nicht, letzteres ist das Hardwarezeichen vom DOGM internen Zeichensatz.

Ach?

Hast Du schon mal lcd.write(0xDF) probiert?
653  International / Deutsch / Re: shiftout Problem on: March 10, 2014, 04:17:48 pm
pinMode(button1, OUTPUT);

Bist Du sicher, dass "button1" nicht ein INPUT sein soll?
Z.B. ein manuell bedienbarer "Startknopf"?
654  International / Deutsch / Re: Grundsatzfrage "gleichzeitige Anweisungen" on: March 10, 2014, 11:56:32 am
bitte mit ein paar beispiel zeilen

http://forum.arduino.cc/index.php?topic=177359.msg1315698#msg1315698
655  International / Deutsch / Re: Komisches Verhalten von Putty on: March 09, 2014, 05:07:06 pm
Ich habe mir eine Session angelegt die ich mit einem Doppelklick starte.

Und die gezeigten Einstellungen sind die Einstellungen, wenn man nur EINMAL den Session-Eintrag anklickst und danach auf "Load"?
656  International / Deutsch / Re: Komisches Verhalten von Putty on: March 09, 2014, 04:42:09 pm
Von der Standardeinstellungen habe ich lediglich den Verbindungstyp auf Seriell umgestellt und COM5 sowie Baud 115200 ausgewählt

Du arbeitest mit einer falschen Baudrate.

Beschreibe mal ganz genau, wie Du Deine Arduino-Session mit Putty startest!

Also ob Du z.B. eine "Saved Session" doppelklickst oder ob Du gar keine "Saved Session" auswähltst oder wie Du das genau beim Starten der Putty-Session machst.

Hast Du das auf dem Arduino laufende Programm über den Arduino-Bootloader hochgeladen oder mit Programmer? Wenn Upload mit Programmer, dann wäre es mit manchen Konfigurationen auch möglich, auf einen Controller ein Programm hochzuladen, das für eine falsche Baudrate kompiliert wurde, z.B. ein für 16 MHz Systemtakt programmiertes Programm auf einen Controller, der seine Fuses für 8 MHz internen Takt gesetzt hat. Das kannst Du ausschließen?
657  International / Deutsch / Re: Eine if Schleife nur alle 5 Minuten durchlaufen on: March 09, 2014, 03:00:59 pm
ich möchte die unten gezeigte Schleife nur alle 5 Minuten 1X abarbeiten. Währen der restlichen Zeit sollte der Sketch aber auch abgearbeitet werden ein Delay scheidet als aus.
Weiß jemand eine Funktion mit der ich das bewerkstellen kann?

Mit millis() aus dem Arduino-Takt, ohne Echtzeit-Uhr?

Code:
unsigned long SecondsRunning()
// Liefert die Sekunden seit Programmstart zurück
// Diese Funktion muss in der loop laufend aufgerufen werden
{ // Sekundenzähler
  static unsigned long secondsCounted=0;
  static unsigned long prevMillis=0;
  while( millis() - prevMillis >= 1000){     
    secondsCounted++;
    prevMillis += 1000;
  }
  return secondsCounted;
}


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

unsigned long lastSeconds, thisSeconds;
int intervall=300; // Intervalldauer in Sekunden
void loop() {
  thisSeconds=SecondsRunning();
  if (thisSeconds>=lastSeconds+intervall)
  {
    lastSeconds+=intervall;
    Serial.print(intervall);Serial.println(" Sekunden sind um!");
  } 
}
658  International / Deutsch / Re: PWM Zeitversätzt nach Start ansprechen on: March 09, 2014, 05:09:47 am
irgend wann ist das wahrscheinlich auch eine Zeitfrage, wenn ich 10 bis 20 oder mehr Aktionen definiere, … oder ist das Bord so schnell das ich mir da keine Gedanken drum machen muss?

momentan gehe ich mal von mehr als 4 Aktionen pro Hardware aus, bei jedem Schuss, welchen Denkansatz würde es denn noch geben?

OK, also es können zwischen "eins" und "relativ viele" Schaltvorgänge an einem einzelnen Pin auftreten und Du hast zugleich die Befürchtung, dass die Verarbeitung immer langsamer und unexakter wird, je mehr Schaltvorgänge definiert werden.

In dem Fall würde ich vorschlagen, dass Du die Deklaration der Hardware-Schaltvorgänge so läßt wie sie sind, also einfach mehrere Zeilen mit Schaltzeiten für jeden Pin, aber das Programm baut sich intern ein "Schaltzeiten-Array" auf, von der Größe "2*schritte" und in dem Array steht dann für jeden Schaltvorgang ein Eintrag für jeden Ein- und Ausschaltvorgang:
- Pin, Zeit des Schaltvorgangs, ein oder aus
Dann sortiert man das Schaltzeiten-Array nach Schaltzeit

Und die Schaltlogik geht dann nicht mehr die Hardwareeinträge durch, sondern die Einträge im Schaltzeiten-Array.  Da das Array sortiert ist, ist die Schaltgenauigkeit dann auch vollkommen unabhängig von der Anzahl der Schaltvorgänge: Man braucht ja nicht mehr alle Einträge durchgehen, um den nächsten Schaltvorgang festzustellen, sondern man braucht immer nur auf den jeweils nächsten Eintrag zu schauen und ob die Schaltzeit erreicht ist. Wenn ja, schalten. Dann auf den nächsten Schaltvorgang warten. Bis alle 2*schritte Schaltvorgänge ausgeführt wurden.
659  International / Deutsch / Re: PWM Zeitversätzt nach Start ansprechen on: March 09, 2014, 04:14:38 am
da kann ich nicht ganz folgen ;-(

Wenn es jetzt nur um ein zweimaliges (oder max. dreimaliges) Schalten desselben Pins geht, wäre es vielleicht am einfachsten, für jeden Pin zwei Schaltzeiten zu definieren:
Code:
struct hardware_t{int pin;long vorlaufzeit; long dauer;long vorlaufzeit2; long dauer2;};
Nicht benötigte Schaltungen in der Hardwaredefinition auf null setzen. Und dann die if-Schaltlogik entsprechend ändern, dass eingeschaltet wird, wenn sich die Zeit innerhalb der ersten ODER der zweiten Schaltzeit befindet.

Falls Du aber "ganz viele" weitere Schaltungen für dieselbe Hardware benötigst, sollte man sich vielleicht eine andere Erweiterung der Schaltlogik überlegen.

Also als erstes mal kräftig überlegen: Was wird benötigt? Nur ein zweimaliges Schalten desselben Pins? Oder vielleicht doch ganz viele Schaltungen desselben Pins?
660  International / Deutsch / Re: Dallas bremst loop stark aus ? on: March 07, 2014, 12:47:15 pm
Das Programm reagiert dennoch gefühlt verzögert länger als die eine Sekunde auf Tastendruck.

Ja. Aber nur bei falscher Ansteuerung und wenn zwischen "Anforderung einer Messung" und "Abholen des Messwertes" nicht die erforderliche Messzeit liegt. Dann macht die Dallas-Library eine Zwangspause im Sketch und würgt Deine Loop gnadenlos runter.

Die einfachste Logik, falls Du nicht mehr als 30 Messungen pro Minute brauchst, geht so: Immer wenn die Sekunde wechselt, machst Du EINE Aktion:
- bei Anbruch einer geraden Sekunde: Messung anfordern
- bei Anbruch einer ungeraden Sekunde: Temperatur abholen
u.s.w.
Dann liegt selbst in der höchsten Messauflösung mindestens die notwendige Messzeit dazwischen, und die Temperatur kann stets ohne eine zusätzliche Zwangspause abgeholt werden.
Pages: 1 ... 42 43 [44] 45 46 ... 190