Mein Vorschlag sieht folgendermaßem aus.
Ich nutze diesen Filter bei einem Absolutdrucksensor und beim Lambda auslesen in meinem Auto. (Ich hatte genau den gleichen Fehler)
Zitat aus meinem Post aus einem anderen Thread:

Das Problem könnte auch noch ein anders sein uns zwar wäre es wahrscheinlich mit einem Filter vorteilhafter das man die akutellen gelesenen Werten etwas "niedriger" bewertet damit auch eventuelle Fehlerwerte oder große Sprünge nicht sofort zu 100% auf die regelung "durchschlagen". Wir machen das bei Analogwerten in der SPS genauso ich habe das auch in einem meiner Programme genutzt sieher hier:

Code:

Code:

int LDlast;  // ist global deklaiert !!!!



int get_LD(){                                // Funktion Einlesen Ladedruck
  int LDY;
  int LDX;
  int LDact;
  int LDdis;
  LDact=analogRead(LDin);                    // Einlesen des Ladedruckistwertes
  LDX=LDact*0.1;              // Filter neue Lesewert einfluß ca 10% pro Zyklus
  LDY=LDlast*0.9;             // Filter alter Wert hat einen einfluss von 90%
  LDdis=LDX+LDY;             // Alter + neuer wert ist gefilterter neuer wert
  LDlast=LDdis;                 // "neuer wert ist dann der alte wert für die nächste Runde
  return LDdis;
 

Bei diesem Filter "dauert" es ca 18-20 Zyklen (Waren bei mit ca 10ms) bis der neue gelesene wert 99,99999% Integriert ist. passt du jetzt die multiplikatoren noch an, also den neuen gelesenen Wert etwas höher "bewerten"  dann sind es weniger Zyklen also die integration ist schneller bis du zu einem Schönen ergebniss kommst. Wichtig die Summe beider Multiplikationsfaktoren muss 1 Sein also 100%.  

Das Problem könnte auch noch ein anders sein uns zwar wäre es wahrscheinlich mit einem Filter vorteilhafter das man die akutellen gelesenen Werten etwas "niedriger" bewertet damit auch eventuelle Fehlerwerte oder große Sprünge nicht sofort zu 100% auf die regelung "durchschlagen". Wir machen das bei Analogwerten in der SPS genauso ich habe das auch in einem meiner Programme genutzt sieher hier:

Code:

int get_LD(){                                // Funktion Einlesen Ladedruck
  int LDY;
  int LDX;
  int LDact;
  int LDdis;
  LDact=analogRead(LDin);                    // Einlesen des Ladedruckistwertes
  LDX=LDact*0.1;              // Filter neue Lesewert einfluß ca 10% pro Zyklus
  LDY=LDlast*0.9;             // Filter alter Wert hat einen einfluss von 90%
  LDdis=LDX+LDY;             // Alter + neuer wert ist gefilterter neuer wert
  LDlast=LDdis;                 // "neuer wert ist dann der alte wert für die nächste Runde
  return LDdis;

!!!! Achtung der LDlast ist global deklaiert !!!!

Bei diesem Filter "dauert" es ca 18-20 Zyklen (Waren bei mit ca 10ms) bis der neue gelesene wert 99,99999% Integriert ist. passt du jetzt die multiplikatoren noch an, also den neuen gelesenen Wert etwas höher "bewerten"  dann sind es weniger Zyklen also die integration ist schneller bis du zu einem Schönen ergebniss kommst. Wichtig die Summe beider Multiplikationsfaktoren muss 1 Sein also 100%.  

So ich bin zur Lösung meines Problems gekommen. Ich werde einfach eine Analogspannung nehmen und auf eine TL494 geben der Vorteil jede beliebige PWM Base Frequenz + variable ontime. Ist zwar ein Bauteil extra aber dann habe ich keine extremen aufwand auf meinem Microp

das wäre ne Lösung aber wie speise ich den Timer2 mit dem Timer1 den 0er brauche ich da ich die SPI schnittstelle verwende und das Nokia 3310 Lcd Shield. Ich muss wohl auf den Mega gehen den ich hier sowieso liegen habe. Kannst du das mit näher erlautern mit dem verknüpfen der beiden timer?

Danke

Ich habe ein Problem mit dem Timing bzw der Zykluszeit des Arduinos. Bei mir läuft ein Code zur Generierung eines 30Hz PWM Signals. Ich kann nicht den Prescaler runtersetzen um den "normalen" OCR ausgang zu nutzten da ich auf die micros() und millis() angewisen bin.  Ich habe bei meinen 10kB Programm eine Zyluszeit von 10ms mit Serial print und 8ms ohne. Dadurch habe ich keine möglichkeit meine eigene LOW_PWM laufen zu lassen
 Das Problem ist dann folgendes ich kann mit meine Funktion keine Ontime(dutycyle) oberhalöb von 70% generiesen. kann ich jetzt mit dem Befehl ==>
  noInterrupts();
  // critical, time-sensitive code here

dann meine eigne Funktion ausführen lassen ohne unterbrechung laufen lassen weil die dann mit hoher Prio läuft.
Meine Funtion sieht so aus. Die Aktion muss man dann klar in die Loop aufnehmen. Ich will nur so mal ein denkfehler ausschließen

Code:

unsigned long pmicros;
int nextCall=HIGH;
int val=0;


void setup(){
  pinMode(13,OUTPUT);
 pinMode(12,OUTPUT);
 }

void loop(){
val=analogRead(0);
val=map(val,0,1023,1,100);
  Low_PWM(12,30,val);
  }

void Low_PWM(int Pin, int Fre, int Value){
long time;
long ontime;
time=1000000/Fre;
  ontime=time/100*Value;
  if (micros() - pmicros > time && nextCall==HIGH) {
    digitalWrite(Pin,HIGH);
    pmicros=micros();
    nextCall=LOW;
  }
  if (micros() - pmicros > ontime&& nextCall==LOW){
    digitalWrite(Pin,LOW);
    nextCall=HIGH;  
  }
}

Kommt jetzt auf die Perfomance deines Programmes an:

Code:

unsigned long pmicros;
int nextCall=HIGH;

void setup(){
  pinMode(13,OUTPUT);
 }

void loop(){
Low_PWM(13,30,75);    //erster Wert AusgangsPin,Base Frequenz,Ontime 0-100%
}

void Low_PWM(int Pin, int Fre, int Value){
long time;
long ontime;
time=1000000/Fre;
  ontime=time/100*Value;
  if (micros() - pmicros > time && nextCall==HIGH) {
    digitalWrite(Pin,HIGH);
    pmicros=micros();
    nextCall=LOW;
  }
  if (micros() - pmicros > ontime&& nextCall==LOW){
    digitalWrite(Pin,LOW);
    nextCall=HIGH;
  }
}
 

Versuch es mal mit dem int Fre auf 15000 ob es funktioniert

Ich würde mal sagen für einen weitern Experten zu lasch ausgedrückt. Wobei ich mir sicher bin das die meisten verstehen was damit ausgedrückt werden sollte ohne tief in die Materie einzutauchen.
So würde ich sagen ist alles ausgibig erklärt.
 

SSR haben iom Normalfall eine Schutzbeschaltung die es zuläst einige wenige mA fließem zu lassen z.B. wenn du dann eine kleine Relais dahinten hast dies fänght dann an zu brummen und wenn es vorher angeschaltet war fällt dieses dann auch niohct zuverlässig ab. Schaltest du größere Lasten u.a. auch größere Induktivitäten dann ist dies kein Probelm mehr. Die Schutzbeschaltung kann auch "messen" nimm ein Multimeter und miss mal bei ausgeschaltetem SSR offenen Lastkreis die Lastseite und du misst die vollen 220V die du auch "spüren"   kannst. Beruflich bedingt habe ich oft mit diesen Dingern zu tun und es gibt eine Interressante Phänomäne mit diesen Dingern.  
Vlg
Daniel


Zum testen kann man ja mal einen 2K2 Wiederstand über den Eingang hängen

Zuerstmal wirst du bis 5A bei den Solids keine Temparatur Probleme haben. Den SSR brauchst du nicht über den ULN ANzusteruern die Eingangsseite ist galvanisch gegenüber der Schaltseite getrennt. Die GND packst du auf "-" des Eingangs den Ausgang packst du dann auf "+". SSR brauchen Minimallast und bekommen nur dann Probleme wenn du auf der Ausgangseite keine Last hast. Bei 125 Watt hast du laut Ohmesches Gesetz mindesten 0,5A bei den der SSR auf jeden Fall löscht.

Ja dann mal ein herzliches Wilkommen

http://www.datasheetarchive.com/pdf-datasheets/Datasheets-15/DSA-294484.pdf

Auf der Seite 3&4 ist die Funktion ausgezeichnet dokumentiert. Du schaltest halt über einen BCD-Code die jeweiligen Anlaogeingänge des Chips auf des 1 Ausgang
Im Playgound ist ein Code mit einem CD4051 der ist ein 8 in 1 MUX
http://www.arduino.cc/playground/Learning/4051
den Code erweitern dann hast du dein Ziel

Meine Idee wäre ein
RAMTORN FM24C64-G ist über I2C anzusteuern könnte man dann über die lokale Schnittstelle schreiben.

Es gibt bei funkmodul.com interressant Module unter der Rubirk tranceiver
z.B.
den RT433F5
10-Kanal-FM-Transceivermodul zur Eigenentwicklung von bidirektionalen mehrkanaligen Funksystemen. Versorgung 3V DC;
Ansteuerung und Datenübertragung über serielle Schnittstelle!
Kein eigenes Funkprotokoll erforderlich!
Pin- und nahezu funktionskompatibel zum RT433F4-Modul. Die Unterschiede sind im Datenblatt aufgeführt.
Den werde ich mir mal über meine Firma bestellen zu diversen Tests

Ich habe mir von Watterott das Serial 2.0 Board gekauft um mir mal zur Abwechslung mal ein Arduino komplett selber zu bauen. Komplett bestückt und dann mit dem folgenden Tutorial den Bootloader gebrannt wobei es wohl einfacher ist die Signale vom ICSP Port zu nehmen (ausser dem Reset) einfach 1:1 durchverbinden die drei LED an Pin7 8 9
für Comm Fail Heartbeat und dann den Bootloader mit dem 018 IDE draufgespielt und siehe da läuft!
http://arduino.cc/en/Tutorial/ArduinoISP

Du hast recht da ist ein = zuviel ich habe aber so einen "Aufzähler"in einem andern Projekt bei mir der funktioniert Mit dem debounce ist natuerlich ein noch besserer ansatz