Frage zu (digitalen) Potentiometern und Rheostats

[xxxmicroxxx]

Guten Morgen allerseits,
Ich hätte mal eine eher allgemeinere Frage zu Potentiometern und Rheostats und erhoffe mir hier zu einer Erklärung zu gelangen. Google konnnte mir auf meine Frage leider keine Antwort liefern.

Wie ein Poti und Rheostat grundsätzlich funktioniert weiß ich aber wie sieht das bei den Digitalen aus. Bei einem digitalen Poti klemm ich den an den Arduino(oder einen anderen Microcontroller) und der Arduino ersetzt wenn man das so sagen kann das Drehrädchen. :)
Wie sieht das jetzt aber bei einem digitalen Rheostat aus. Der Arduino fungiert wieder als Signalgeber und stellt den Wiederstand ein aber wo ist jetzt der Unterschied bis auf die Anzahl der Beine?

Der Grund für meine Frage ist ein Projekt bei welchem ich eine Funke über den Arduine ansprechen will. Hierfür Ist mein Ansatz die Potis der Fernsteuerung mit digitalen Potis die an den Arduino gklemmt sind zu ersetzen. Nun ist die Frage geht das auch mit einem digitalen Rheostat?

Danke schonmal für eure Hile;)

[Peter(TOO)]

Hallo,

Wie ein Poti und Rheostat grundsätzlich funktioniert weiß ich aber wie sieht das bei den Digitalen aus.
Ein Rheostat ist meistens ein Poti mit hoher Verlustleistung.

Das Problem beim Rheostaten ist, dass er sich nicht miniaturisieren lässt, der erzeugt jede Menge Abwärme. Zudem ist es auch unwirtschaftlich, nicht benötigte Leistung einfach zu verheizen.

Heute hat man die Rheostaen z.B. durch PWM ersetzt. Die bekannten Dimmer funktionieren auch als PWM, früher hatte man z.B. für eine Saalbeleuchtung Rheosten, meist über einen Motor angetrieben.

Eine andere Variante des Rheostaten ist ein hochpräzises Potentiometer.
So etwas findet man heute noch z.B. beim Kalibrieren von Messgeräten. z.B. als Widerstandsdekade oder als PT100-Simulator.
https://www.google.ch/search?q=widerstandsdekade&biw=1364&bih=907&tbm=isch&tbo=u&source=univ&sa=X&ei=dBTjVInIJ8vePeC1gegO&sqi=2&ved=0CC4QsAQ
https://www.google.ch/search?q=widerstandsdekade&biw=1364&bih=907&tbm=isch&tbo=u&source=univ&sa=X&ei=dBTjVInIJ8vePeC1gegO&sqi=2&ved=0CC4QsAQ#tbm=isch&q=PT100+simulator

MfG Peter(TOO)

[xxxmicroxxx]

Hallo Peter und danke für die schnelle Antwort

Das Problem beim Rheostaten ist, dass er sich nicht miniaturisieren lässt
Ich habe jetzt so einen erworben. es steht zwar digitalpotentiometer drauf. Die Bezeichnung sagt aber es ist ein Rheostat.

Ein Rheostat ist meistens ein Poti mit hoher Verlustleistung
Das heißt im Klartext das ich den Rheostat problemlos für mein Vorhaben verwenden kann wenn ich das richtig sehe oder?
Da es sich nur um ein paar wenige Volt handelt denke ich dass sich der Verlust in grenzen halten wird.

[Peter(TOO)]

Hallo,

Ich habe keine Ahnung was du vor hast.

Da andere Problem ist, dass man seit etwa 40 Jahren keine Rheostaten für Leistung mehr verwendet. Die Jungen Leute hier, kennen den Begriff gar nicht mehr.

MfG Peter(TOO)

[xxxmicroxxx]

Tja die Jugend von heute tsss. Nein Spaß bei Seite.
Das Problem welches ich habe bzw mich verwirrt ist folgendes:
Ich habe mir einen MCP4132 bestellt welcher als digitaler Poti gekennzeichnet war. Nach kurzem Blick in das Datenblatt sieht man aber dass der MCP4132 kein Poti sondern ein Rheostat ist. Datebblatt: http://ww1.microchip.com/downloads/en/DeviceDoc/22060b.pdf
Und jetzt ist mir nicht klar ob ich den digitalen Rheostat als einen digitalen Poti verwenden kann.

[Geistesblitz]

Kannst du schon, an sich finde ich aber dein Vorhaben generell ein wenig ungünstig. Du wandelst digitale Signale in analoge Signale (mittels des Potis), welche dann von deiner Fernsteuerung wiederum in digitale übersetzt und gesendet werden. Da wäre es eigentlich günstiger zu gucken, ob man nicht gleich an den Sender der Funkfernbedienung rankommt und den dann direkt mit Signalen vom Controller füttert.

[xxxmicroxxx]

Hallo,
Ja an sich hast du recht. Man könnte das Signal direkt in das HF-Modul einspeißen. Man müsste hierfür ein PPM Signal erzeugen, was mir schlichtweg nicht gelungen ist. Ausßerdem gehen mir auf diesem Weg funktionen wie zb das Trimmen und generell alle anderen Funktionen der Fernsteuerung verloren.
Mein erster Ansatz war dass ich die Potis aus der Fernsteuerung auf Servos geklebt habe und dann die Servos angesprochen habe. Ich habe allerdings relativ schnell gemerkt dass das Murks ist. Sicher geht mir auf diese Weiße ein Stückchen an Qualtität und Geschwindigkeit verloren aber ich denke das ist Verkraftbar. Wird das erheblich auf Kosten der Geschwindigkeit der Übertragenen Daten gehen?

[avr_racer]

Hallo,


Der Arduino fungiert wieder als Signalgeber und stellt den Wiederstand ein aber wo ist jetzt der Unterschied bis auf die Anzahl der Beine?
an der Funktion ändert sich nichts, nur um das normale digitale Poti als Rheostat zu nutzen mit einem Transistor(Verstärker) erweitert werden muss um mehr Leistung zu steuern.
siehe 8.3 Fig 8.5


aber wie sieht das bei den Digitalen aus
Prinzipiell sind ne Menge Widerstände in Reihe geschaltet, die durch Transistoren (Fet's) überbrückt werden um den entsprechenden Potiwert einzustellen.
siehe hier http://i.stack.imgur.com/85bor.png


Der Grund für meine Frage ist ein Projekt bei welchem ich eine Funke über den Arduine ansprechen will. Hierfür Ist mein Ansatz die Potis der Fernsteuerung mit digitalen Potis die an den Arduino geklemmt sind zu ersetzen. Nun ist die Frage geht das auch mit einem digitalen Rheostat?

erzähl mal mehr zur Funke meinst du CB-Funk???


Das heißt im Klartext das ich den Rheostat problemlos für mein Vorhaben verwenden kann wenn ich das richtig sehe oder?
Da es sich nur um ein paar wenige Volt handelt denke ich dass sich der Verlust in grenzen halten wird.

Von wieviel Volt ist denn die Rede??? Es ist bei den Dingern ganz wichtig das man hier die Grenzen nicht zu weit ausreitzt da viel digi Potis nur bis 5V arbeiten ausser gewisse Ausnahmen wie die AD5260/5262/7376 leider find ich sind die recht schwer zu beschaffen...

[Crazy Harry]

Ich vermute mal eine Fernsteuerung für Modellbau ?
Wie schauts denn mit der Master/Slave Funktion aus ? Hat deine RC sowas ?

[xxxmicroxxx]

erzähl mal mehr zur Funke meinst du CB-Funk???
Nein es handelt sich um eine Modelbau Fernsteuerung. Ziel ist es die Fernsteuerung über den Arduino anzusprechen um dann einen Quadrocopter damit zu steuern. Der Arduino bekommt seine Daten von einer Kinect. Das heißt wenn alles fertig ist soll das Ding durch Gestik fliegen.


Von wieviel Volt ist denn die Rede???
Ich hab grad mal gemessen und komme auf maximal 3.3 Volt. Das sollte also eigentlich kein Problem werden.

Ps: Die Dinger sind gerade gekommen. Jetzt werd ich gleich sehen ob alles klappt.

- - - Aktualisiert - - -


Wie schauts denn mit der Master/Slave Funktion aus ? Hat deine RC sowas ?
Ich denke du meinst soetwas wie eine Schüler Lehrer Funktion. Ja hat sie aber wie ich bereits gesagt habe habe ich das nicht auf die Reihe gekriegt. Dabei war vielweniger die Softwareseite sondern die Funke schuld. Ich habe so eine billg Noname Funke und habe leider keine passende Dokumentation bezüglich der Pinbelegung des Schüler/Lehrerports gefunden.

[xxxmicroxxx]

So ich habe die Schaltung jetzt mal wie folgt aufgebaut aber das will nicht so wie ich das Will. Es gibt keine Werte aus.
Wäre nett wenn mir jmd sagen könnte was ich falsch verkabelt habe.29853

Hier ist auch noch von dem Datenblatt:
http://ww1.microchip.com/downloads/en/DeviceDoc/22060b.pdf
MCP4132

[Geistesblitz]

Auf dem Bild kann mann ja nicht mal erkennen, wie herum die Platine liegt. Kannst du keinen Schaltplan erstellen? Das würde das einfacher machen.

[Peter(TOO)]

Hallo,

Ich habe mir einen MCP4132 bestellt welcher als digitaler Poti gekennzeichnet war. Nach kurzem Blick in das Datenblatt sieht man aber dass der MCP4132 kein Poti sondern ein Rheostat ist. Datebblatt: http://ww1.microchip.com/downloads/en/DeviceDoc/22060b.pdf
Und jetzt ist mir nicht klar ob ich den digitalen Rheostat als einen digitalen Poti verwenden kann.
Das Problem ist halt, das so Halbleiter-Widerstände recht ungenau sind, die +/-20% sind schon gut.
Da du für einen Spannungsteilereinen zweiten Widerstand brauchst, ist dann die eingestellte, ohne einen Abgleich, Spannung auch nicht genauer.

Bei einem Potentiometer haben aber beide Teilwiderstände den selben Fehler, sodass Ra/Rb konstant ist, egal wie der Absolute Widerstandswert ist.

MfG Peter(TOO)

[Geistesblitz]

Ansonsten gäbe es auch die Möglichkeit, das ganze per PWM zu lösen, die muss dann halt noch mittels Tiefpass (Widerstand und Kondensator) geglättet werden. So geht dann eine relativ genaue Analogspannung an den Pin von der Fernsteuerung, wo vorher der Mittelabgriff des Potentiometers dran war. Das geht allerdings auch nur, wenn das Potentiometer vorher als Spannungsteiler fungierte. Hab auch schon gesehen, dass bei einem Joystick die Potentiometer einfach nur als veränderlicher Widerstand fungierten, da sind die Verhältnisse natürlich ein wenig anders.

[xxxmicroxxx]

Nein man erkennt auf dem Schaltplan leider auch nichts. Ich versuchs jetzt aber mal so:
1 : 53 8: +5V
2 : 52 7: 50
3 : 51 6: Gnd
4 : Gnd 5: Output

Ich hoffe so gehts auch.

[wkrug]

Also ich würde den Ansatz mit dem Lehrer / Schüler system weiterverfolgen.
Von ACT gibt es ein drahtloses Lehrer / Schüler system. http://www.acteurope.de/html/t3e-lehrer-schuler-system.html
Die Pulsfolge ist 9 Impulse mit 500µs Länge, gefolgt von der gewünschten Servoimpulslänge - 500µs als Pause.
Also soll der impuls 1500µs ( = Servomitte ) betragen muss die Pause 1000µs sein.
Die 9 Impulse ( bei 8 zu übertragenden Kanälen ) deshalb weil bei einem Hersteller die steigenden Flanken im Lehrer Sender ausgewertet werden, bei einem anderen die fallenden.
Nach einen solchen Impulskette kommt eine 6ms lange Pause, damit der Lehrer Sender weiss, wann der erste Kanal wieder anfängt.
Die Anschlussbelegung deiner Fernsteuerung sollte sich rauskriegen lassen.
Ich hab so ein System mit nem ATMEGA 88 gebaut und es funktioniert problemlos.

/********
PC0 = Kanal 1
PC1 = Kanal 3
PC2 = Kanal 5
PC3 = Kanal 7
PD0 = Kanal 2
PD1 = Kanal 4
PD2 = Kanal 6
PD3 = Kanal 8
PB1 = Summensignalausgang
PB2 = Syncsignal startet bei Pausenbeginn
********/

#include <mega88.h>

volatile unsigned int ui_timerold[8]; //Speicherwerte für die Steigende Flanke der entsprecheden Kanäle
volatile unsigned int ui_pulslengh[8]={3000,3000,3000,3000,3000,3000,3000,3000}; //Ermittelte Pulslängen
volatile unsigned int ui_lastchange; //Letzter Impulsstart für Summensignalgenerierung
volatile unsigned char uc_oldgerade=0; //Zwischenspeicher für den alten Zustand der geraden Kanäle 2,4,6,8
volatile unsigned char uc_oldungerade=0; //Zwischenspeicher für den alten Zustand der geraden Kanäle 1,3,5,7
volatile unsigned char uc_cyclecount; //Zyklenzähler für die Impulsausgabe
#define maxcycle 17 //Maximale Zyklenzahl für die Impulsausgabe
#define minlengh 1200 //Minimal zulässige Impulslänge 600µs
#define midlengh 3000 //Servo Mittelstellung
#define maxlengh 5400 //Maximal zulässige Impulslänge 2700µs
#define interpulspause 1000 //1000 = 500µs
#define interframepause 12000 //12000 = 6ms Interframepause

//#define normal //Bestimmt ob die Impulsausgabe normal oder invers geschehen soll
//#define revers //zur Zeit noch nicht implementiert - Bedingte Assemblierung
#define portsungerade PINC //Ungerade Kanäle auf Port C
#define portsgerade PIND //Gerade Kanäle auf Port D
#define outport PORTB.1 //Summen Ausgangssignal
#define syncport PORTB.2 //Sync Signal für Oszilloskop

// Pin change 8-14 interrupt service routine Kanal 1,3,5,7
interrupt [PCINT1] void pin_change_isr1(void)
{
unsigned char uc_portungerade,uc_result,uc_low,uc_high;
unsigned int ui_timer;
uc_portungerade=portsungerade;
uc_low=TCNT1L;
uc_high=TCNT1H;
ui_timer=uc_high;
ui_timer=ui_timer<<8;
ui_timer+=uc_low;
uc_portungerade&=0x0F;
uc_result=uc_portungerade^uc_oldungerade;
if(uc_result&0x01)
{
if(uc_portungerade&0x01) //Es war ne steigende Flanke
{
ui_timerold[0]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[0]=ui_timer-ui_timerold[0];
};
}

if(uc_result&0x02)
{
if(uc_portungerade&0x02) //Es war ne steigende Flanke
{
ui_timerold[2]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[2]=ui_timer-ui_timerold[2];
};
}

if(uc_result&0x04)
{
if(uc_portungerade&0x04) //Es war ne steigende Flanke
{
ui_timerold[4]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[4]=ui_timer-ui_timerold[4];
};
}

if(uc_result&0x08)
{
if(uc_portungerade&0x08) //Es war ne steigende Flanke
{
ui_timerold[6]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[6]=ui_timer-ui_timerold[6];
};
}
uc_oldungerade=uc_portungerade;
}

// Pin change 16-23 interrupt service routine Kanal 2,4,6,8
interrupt [PCINT2] void pin_change_isr2(void)
{
unsigned char uc_portgerade,uc_result,uc_low,uc_high;
unsigned int ui_timer;
uc_portgerade=portsgerade;
uc_low=TCNT1L;
uc_high=TCNT1H;
ui_timer=uc_high;
ui_timer=ui_timer<<8;
ui_timer+=uc_low;
uc_portgerade&=0x0F;
uc_result=uc_portgerade^uc_oldgerade;
if(uc_result&0x01)
{
if(uc_portgerade&0x01) //Es war ne steigende Flanke
{
ui_timerold[1]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[1]=ui_timer-ui_timerold[1];
};
}

if(uc_result&0x02)
{
if(uc_portgerade&0x02) //Es war ne steigende Flanke
{
ui_timerold[3]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[3]=ui_timer-ui_timerold[3];
};
}

if(uc_result&0x04)
{
if(uc_portgerade&0x04) //Es war ne steigende Flanke
{
ui_timerold[5]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[5]=ui_timer-ui_timerold[5];
};
}

if(uc_result&0x08)
{
if(uc_portgerade&0x08) //Es war ne steigende Flanke
{
ui_timerold[7]=ui_timer;
}
else //Es war ne fallende Flanke
{
ui_pulslengh[7]=ui_timer-ui_timerold[7];
};
}
uc_oldgerade=uc_portgerade;
}

// Timer 1 output compare A interrupt service routine
interrupt [TIM1_COMPA] void timer1_compa_isr(void)
{
unsigned char uc_low,uc_high;
unsigned int ui_buffer;
switch(uc_cyclecount)
{
case 0: //Die Pausen
syncport=0; //Sychronosationsimpuls stoppen
outport=1;
uc_low=OCR1AL;
uc_high=OCR1AH;
ui_buffer=uc_high; //Aktuelle Werte holen
ui_buffer=(ui_buffer<<8)+uc_low;
ui_lastchange=ui_buffer;
ui_buffer+=interpulspause; //Preimpuls dazuzählen und einfügen
uc_low=ui_buffer&0x00FF;
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 1:
outport=0; //Der erste Impuls
ui_buffer=ui_lastchange+ui_pulslengh[0];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 2: //Pausen zwischen den Impulsen einfügen
case 4:
case 6:
case 8:
case 10:
case 12:
case 14:
case 16:
outport=1;
uc_low=OCR1AL;
uc_high=OCR1AH;
ui_buffer=uc_high; //Aktuelle Werte holen
ui_buffer=(ui_buffer<<8)+uc_low;
ui_lastchange=ui_buffer;
ui_buffer+=interpulspause; //Pause zwischen den Impulsen dazuzählen und einfügen
uc_low=ui_buffer&0x00FF;
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 3:
outport=0; //Der zweite Impuls
ui_buffer=ui_lastchange+ui_pulslengh[1];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 5:
outport=0; //Der dritte Impuls
ui_buffer=ui_lastchange+ui_pulslengh[2];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 7:
outport=0; //Der vierte Impuls
ui_buffer=ui_lastchange+ui_pulslengh[3];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 9:
outport=0; //Der fünfte Impuls
ui_buffer=ui_lastchange+ui_pulslengh[4];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 11:
outport=0; //Der sechste Impuls
ui_buffer=ui_lastchange+ui_pulslengh[5];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 13:
outport=0; //Der siebte Impuls
ui_buffer=ui_lastchange+ui_pulslengh[6];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 15:
outport=0; //Der achte Impuls
ui_buffer=ui_lastchange+ui_pulslengh[7];
uc_low=ui_buffer&0x00FF; //OCR Register für nächsten Interrupt vorbelegen
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

case 17:
syncport=1; //Syncpuls Starten
outport=0;
ui_buffer=OCR1AH; //Aktuelle Werte holen
ui_buffer=(ui_buffer<<8)+OCR1AL;
ui_buffer+=interframepause; //Pause zwischen den Frames also nach 8 Impulsen einfügen
uc_low=ui_buffer&0x00FF;
uc_high=(ui_buffer>>8)&0x00FF;
OCR1AH=uc_high;
OCR1AL=uc_low;
break;

}
uc_cyclecount++;
if(uc_cyclecount>maxcycle){uc_cyclecount=0;}
}

// Declare your global variables here

void main(void)
{
// Declare your local variables here
unsigned char uc_i;
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=Out Func1=Out Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=0 State0=T
PORTB=0x00;
DDRB=0x06;

// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=P State2=P State1=P State0=P
PORTC=0x0F;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=P State2=P State1=P State0=P
PORTD=0x0F;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 1000,000 kHz
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: On
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x02;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// Interrupt on any change on pins PCINT0-7: Off
// Interrupt on any change on pins PCINT8-14: On
// Interrupt on any change on pins PCINT16-23: On
EICRA=0x00;
EIMSK=0x00;
PCICR=0x06;
PCMSK1=0x0F;
PCMSK2=0x0F;
PCIFR=0x06;

// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=0x00;
// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=0x02;
// Timer/Counter 2 Interrupt(s) initialization
TIMSK2=0x00;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
ADCSRB=0x00;

while(PINC.0==0); //Warten auf Impulse
while(PINC.0>0);
// Watchdog Timer initialization
// Watchdog Timer Prescaler: OSC/128k
// Watchdog Timer interrupt: Off
#pragma optsize-
#asm("wdr")
WDTCSR=0x1E;
WDTCSR=0x0E;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Global enable interrupts
#asm("sei")

while (1)
{
#asm("wdr")
//Fehlerhafte Impulse abfangen
for (uc_i=0;uc_i<8;uc_i++)
{
if(ui_pulslengh[uc_i]<minlengh||ui_pulslengh[uc_i]>maxlengh)
{
ui_pulslengh[uc_i]=midlengh;
}
};
};
}
Der Code ist für Codevision AVR, sollte sich aber problemlos portieren lassen.
Im Prinzip brauchst Du da jetzt nur noch die Kinect an den Controller anpassen und die entsprechenden Kanäle ansprechen und es sollte laufen.

[xxxmicroxxx]

Hallo Wkrug und Danke für deine Antwort.
Nimms mir nicht übel aber ich hab mich schon ein halbes Jahr mit der Schüler Lehrer Buchse PPM Signalen und soweiter rumgeschlagen und bin ehrlich gesagt nicht sehr motiviert diesen Ansatz noch weiter zu verfolgen. Ich hab schon alles probiert von Bibliotheken und fertigen Codes bis hin zum eigenen Code. Nichts von dem allen läuft. Also wie gesagt dass ist kein "Ist mir zu kompliziert da brauch ichs eh nicht zu probieren" Kommentar. Ich denke aber wenn man sich mit einem Ansatz intensiv beschäftigt hat und kein brauchbares Ergebnis rauskommt sollte man es auch gut sein lassen können.



Jetzt aber nochmal zu dem Digital Potentiometer
Ich habe den Pin P0B an Ground geschlossen. P0W sollte dann der Ausgang sein. Ist das so richtig angeschlossen oder muss ich da noch was ändern. Bisher gibt der Digipot nur den Wert "0" aus. bzw wenn ich P0B an +5v anschließe "1023". Das heißt er schaltet den Strom direkt an den Output durch ohne den Vorgegebenen Wiederstand zu schalten.

Hier noch der Code den ich benutze um ihn anzusprechen:

#include <SPI.h>

int csPin = 53;

void setup() {
SPI.begin();
pinMode(csPin, OUTPUT);

}

void loop() {
SPI.transfer(0);
SPI.transfer(50);


}

[avr_racer]

Ich habe den Pin P0B an Ground geschlossen. P0W sollte dann der Ausgang sein. Ist das so richtig angeschlossen oder muss ich da noch was ändern.

Ja so ists richtig schau mal Seite 30 Figure 2-64, ist zwar für Wechslekomponente aber spielt keine Rolle.

und wenn du das Wiper mal änderst passiert denn auch an Pin-W was??

[xxxmicroxxx]

Hallo,
ich habs jetzt hin bekommen. Es lag an der Software. Ich stehe jetzt aber vor dem Problem dass ich drei Variablen von C# auf den Arduino bringen muss (XYZ). Mein momentaner Ansatz ist es jede Variable nacheinander zu schicken und und nacheinander abzufangen also so:
C#

port.WriteLine(wertXi.ToString());
port.WriteLine(wertYi.ToString());
port.WriteLine(wertZi.ToString());

Arduino

if (Serial.available() > 0)
{
valX = Serial.parseInt();

digitalWrite(csX, LOW);
SPI.transfer(0);
SPI.transfer(valX);
digitalWrite(csX, HIGH);

valY = Serial.parseInt();

digitalWrite(csY, LOW);
SPI.transfer(0);
SPI.transfer(valY);
digitalWrite(csY, HIGH);


valZ = Serial.parseInt();

digitalWrite(csZ, LOW);
SPI.transfer(0);
SPI.transfer(valZ);
digitalWrite(csZ, HIGH);

}

Die Variablen verschieben sich aber nach einer Zeit. Also Y kommt in X usw. Wie kann ich dem vorbeugen?