Spannungssignal umwandeln

OP #4947627
Lesenswert?

Hallo zusammen,

ich möchte mir gerne eine Schaltung zur Spnnungsschaltung aufbauen, mir 
fehlt jedoch die Erfahrung und somit auch die Idee zur Umsetzung...
Vielleicht könnt Ihr mir ja weiterhelfen!

Folgendes Problem:
Ich habe ein Arduinoboard so programmiert, dass es am PWM-Ausgang 0-5V 
ausgibt.
Diesel Signal soll an ein Steuergerät angeschlossen werden, an dem 
momentan ein Poti angeschlossen ist.Also:
Poti wird als Eingang an das Arduinoboard angeschlossen, Ausgang des 
Boards als Eingang des Steuergerät.
Das Steuergerät hat nun aber 3 Anschlüsse: +, GND und das 0-5V-Signal, 
das Board jedoch nur 2 Anschlüsse: + und GND.
Wie bekomme ich das Ganze ohne Spannungsverlust zusammen?
Am Steuergerät müssen alle 3 Anschlüsse belastet werden, da es sonst 
eine Fehlermeldung ausgibt.

Wer hat eine Idee?

Grüße
Yammi
#4947810
Lesenswert?

Hallo,
warum schreibst du nicht konkret, um was es geht.
Noch besser sind Links auf Datenblätter  oder Betriebsanleitungen.

> Sven B. schrieb:
> Wie bekomme ich das Ganze ohne Spannungsverlust zusammen?
> Am Steuergerät müssen alle 3 Anschlüsse belastet werden, da es sonst
> eine Fehlermeldung ausgibt.
Die Belegung "gnd - Steuereingang - +Ub" deutet schon auf einen 
Spannungeingang hin, der eigentlich problemlos durch eine externe 
Steuerspannung zwischen "gnd - Steuereingang" ersetzt werden könnte.

Warum jetzt alle Anschlüsse belastet sein müssen, ist unklar.
Bist du sicher, das es so sein muß?
Falls ja, dann belaste eben "+Ub" gegen "gnd" auch mit einem Widerstand 
in Größe des Poti-Nennwertes.

Einige Sachen sind dabei zu prüfen
"gnd" am Steuergerät muß gleich gnd am uC sein.
Falls es da unterschiedliche Potentiale gibt, muß eine Seite 
Potentialfrei gemacht werden (galvanische Trennung der Stromversorgung).

Am Steuereingang kann du das PWM-Signal legen, aber nicht direkt, 
sondern besser über einen Tiefpass, so dass die PWM zu einer 
Gleichspannung wird.
Gruß Öletronika
OP #4949131
Lesenswert?

Hallo zusammen,

erst einmal vielen Dank für die schnellen, hilfreichen Antworten!
Es geht hier in meinem Fall um ein Steuergerät meines Motorrads.
Das Poti ist der Drosselklappensensor.
Das Arduinoboard soll erst einmal provisorisch dazwischen geschaltet 
werden, Stichwort Leistungssteigerung.

Der Vorschlag mit dem digitalen Widerstand hat mir gut gefallen.
Die Frage ist nur, wie ich mein Programm auf dem Arduinoboard anpasse 
(SPI)...
Momentan habe ich es so programmiert, dass eine Spannung ausgegeben 
wird.
Ist hier jemand im Thema?


Grüße
Yammi
#4950291
Lesenswert?

Hi

Welchen Wert hat das Poti, hast Du ein gleichwertiges Digi-Poti bereits 
irgendwo ausgegraben und wenn Ja, wird Dieses per I2C oder SPI 
angesprochen?
Dann gibst Du statt des PWM-Wertes (wohl eine Zahl 0-255 oder 0-1023) 
einen Wert an das Digi-Poti und Dieses verstellt den eigenen Widerstand 
wieder so, wie Du das gerne hättest.
Netter Nebeneffekt: das Digi-Poti hat sogar direkt 3 Anschlüsse, da 
bekommt die Steuerbox gar nicht mit, daß Da nun 'wer anders' werkelt.
(zumindest waren bei meinen Suchen die Digi-Potis immer mit 3 Kontakten 
herausgeführt)

MfG
OP #4950993
Lesenswert?

Hi Patrick,

das Poti hat einen Wert von 5kOhm, das Programm für den Arduino ist 
bereits fertig und gibt am Ausgang die gewünschte Spannung aus,
allerdings als PWM-Signal (256 Schritte).
Das heißt mein Programm müsste noch auf serielle Ausgabe angepasst 
werden.
Habe mir jetzt eine fertige DigiPoti-Platine bestellt, warte noch auf 
die
Lieferung. Die Platine ist mit einem X9C103S bestückt, nicht flüchtiger 
Speicher.
Ich hoffe der passt.

Ich würde mich freuen, wenn mir jemand bei der Anpassung meines 
Programms behilflich sein könnte, da ich im Programmieren blutiger 
Anfänger bin.

Viele Grüße
Yammi
Gast #4951005
Lesenswert?

Anbei einmal das Programm:

1
// Analog input pin that the potentiometer is attached to
2
const int analogInPin = A0;  
3
// Analog output pin that the LED is attached to
4
 const int analogOutPin = 9; 
5

6
// value read from the pot
7
 int sensorValue = 0;
8
// value output to the PWM (analog out)        
9
 int outputValue = 0;        
10

11
 void setup() {
12
   
13
 }
14

15
 void loop() {
16
   // Lesen des analogen Einganssignals:                        
17
   sensorValue = analogRead(analogInPin);
18
   // Abfrage, ob Eingangsspannung > 1,8V:
19
   if (analogRead(analogInPin) > 368)
20
   //Gebe am Ausgang 0,5V aus
21
   {analogWrite (analogOutPin, 102);
22
   }
23
   // Ordne es dem Bereich des analogen Ausgangs zu:         
24
   else
25
   {outputValue = map(sensorValue, 0, 1023, 0, 255  );
26
   // Gebe es am Ausgang aus:                     
27
   analogWrite(analogOutPin, outputValue);
28
   }
29
 }

Gruß
Yammi
#4951107
Lesenswert?

Sven B. schrieb:
> Die Platine ist mit einem X9C103S bestückt, nicht flüchtiger
> Speicher.
> Ich hoffe der passt.

Naja, so wirklich ideal ist dieses Teil nicht.
Du kannst den Wiper nicht direkt auf einen Wert setzen, sondern musst 
Einzelpulse für Up/Down erzeugen.
D.h. beim Start muss das Poti erstmal ganz an einen Anschlag gefahren 
werden, und von da an sind nur relative Bewegungen möglich.
Das birgt aber auch das Risiko, dass der Potiwert vom gewünschten Wert 
abweicht, wenn mal einzelne Pulse verloren gehen oder durch Störungen 
Pulse erzeugt werden (am Motorrad recht wahrscheinlich).

Ein Bauteil mit I2C oder besser SPI Schnittstelle wäre hier besser 
geeignet.
#4951265
Lesenswert?

Hi

Das hängt dann vom Poti ab.
Deine Eingangsgröße bleibt ja so, wie Sie bereits ist.
Und dieser Wert wird dann auch nur auf's Poti angepasst und zu Diesem 
geschickt.
Wenn das Poti statt 0-1023 0-255 haben möchte, reichte :4 (2x rechts 
shiften) oder eben die Umrechnung per map.
Du wirst wohl Deinen PWM-Wert so beibehalten können, nur dann nicht als 
PWM, sondern als Wert ins Digi-Poti.

MfG
OP #4951376
Lesenswert?

So, habe den AD5160 ausgewählt, sollte passen.
Er hat einen Clock-Pin, einen SDI-Pin und einen CS-Pin (neg.).

Ich vermute, dass ich nun den gewünschten Wert, der über analogwrite 
ausgegeben werden soll, in ein serielles Datenwort umwandeln muss?!

Muss ich die Frequenz des Potis auf die Frequenz des Arduinos anpassen?

Fragen über Fragen...


Gruß
Yammi
Gast #4951965
Lesenswert?

Habe mein Programm mal angepasst...habe die Befürchtung, dass noch etwas 
fehlt..

Ich denke ich muss noch die Ausgänge für die Ansteuerung des DigiPotis 
festlegen;
das PWM-Signal würde weiterhin ausgegeben, habe ja noch einige Ausgänge 
für das DigiPoti frei.
1
int analogInPin = A0;   // Poti
2
 int analogOutPin = 9;  // PWM
3

4
 int sensorValue = 0;   // Bereich der Eingangsspannung
5
 int outputValue = 0;   // Bereich der Ausgangsspannung
6

7
 void setup() {
8

9
 }
10

11
 void loop()
12
 {
13
   // Einlesen der Eingangsspannung
14
   sensorValue = analogRead(analogInPin);
15
   // Abfrage, ob die eingelesene Spannung < 1,8V ist
16
   if (sensorValue < 368)
17
   { 
18
      //Falls ja,rechne die eingelesene Spannung um
19
      outputValue=map(sensorValue, 0, 1023, 0, 255  );
20
SPI.beginTransaction(SPISettings(150000, MSBFIRST, SPI_MODE0));
21
digitalWrite(cs_pin, 0);
22
SPI.transfer(outputValue);
23
digitalWrite(cs_pin, 1);
24
SPI.endTransaction();
25
   }
26
   else 
27
   {
28
      // Gebe 0,5V am Ausgang aus
29
      outputValue= 25;
30
   }
31
   // Gebe die Spannung am Ausgang aus                    
32
   analogWrite(analogOutPin, outputValue);
33
SPI.beginTransaction(SPISettings(150000, MSBFIRST, SPI_MODE0));
34
digitalWrite(cs_pin, 0);
35
SPI.transfer(outputValue);
36
digitalWrite(cs_pin, 1);
37
SPI.endTransaction();
38
}

Könnte mich jemand beim "Feinschliff" des Programms unterstützen?
OP #4960701
Lesenswert?

So, ich habe mein Programm nochmal erweitert.
 An das Board wird nun ein Digitales Poti vom Typ MCP4131 mit 5k zum 
Einsatz.
 Ich habe die Pins folgendermaßen verbunden:
 CS neg. an Pin A10
 SCK an Pin A13
 SDI an Pin A11
1
#include"SPI.h"
2
 int slaveSelectPin=10;
3
 int analogInPin = A0;  // Poti
4
 int analogOutPin = 9;  // PWM
5

6
 int sensorValue = 0;   // Bereich der Eingangsspannung
7
 int outputValue = 0;   // Bereich der Ausgangsspannung
8

9
 void setup() {
10
 pinMode(slaveSelectPin, OUTPUT);
11
 }
12

13
 void loop()
14
 {
15
    sensorValue = analogRead(analogInPin); // Einlesen der Eingangsspannung
16
    if (sensorValue < 368) // Abfrage, ob die eingelesene Spannung < 1,8V ist
17
    { 
18
    outputValue=map(sensorValue, 0, 1023, 0, 255  ); //Falls ja,rechne die eingelesene Spannung um
19
    }
20
    else 
21
    {
22
       outputValue= 25;  // Gebe 0,5V am Ausgang aus
23
    }                    
24
    analogWrite(analogOutPin, outputValue);  // Gebe die Spannung am Ausgang aus
25
    SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
26
    digitalWrite(slaveSelectPin, 0);
27
    SPI.transfer(outputValue);
28
    digitalWrite(slaveSelectPin, 1),
29
    SPI.endTransaction();
30
 }

Leider gibt das Poti ständig 5k aus; keine Reaktion...
Hat jemand eine Idee?
Beitrag #4960705 wurde von einem Moderator gelöscht.
#4961588
Lesenswert?

Du gibst den erwarteten Wert ja auch parallel an einem PWM Pin aus.
Stimmt denn da die Spannung mit der Potistellung überein?

Wie sieht die Beschaltung des Digitalpotis genau aus?

Hast du ein (Speicher-)Oszi mit dem du die SPI Signal mal mitschneiden 
könntest (CS & CLK, MOSI & CLK)?
OP #4961620
Lesenswert?

Die Spannung stimmt 100% überein, die Ausgabe eines Spannungssignals 
hatte ich zuerst programmiert. Anschließend die Ausgabe per SPI 
zugefügt.

Zur Beschaltung:

1= CSneg.
2= SCK
3= SDI/SDO
4= Vss
8= Vdd
8= POB
9= POW
10=POA

Leider steht mir kein Speicherossi zur Verfügung.
Beitrag #4961651 wurde von einem Moderator gelöscht.
#4961745
Lesenswert?

Ja, aber dann kannst du es ja wohl kaum so:

Sven B. schrieb:
> 1= CSneg.
> 2= SCK
> 3= SDI/SDO
> 4= Vss
> 8= Vdd
> 8= POB
> 9= POW
> 10=POA

angeschlossen haben.

Wie auch immer.
Dir ist bewusst, dass ein digitales "Potentiometer" nicht potentialfrei 
von seiner Versorgungsspannung betrieben werden kann?

D.h. eines der Enden P0A oder P0B musst du auf GND legen, und am anderen 
Ende (oder am Wiper) darf keine höhere Spannung als Vdd angelegt werden.

Auch müssen GND vom Arduino und dem Steuergerät zusammengelegt werden.

Der folgende Code sollte das Poti korrekt ansteuern:
1
#include "SPI.h"
2

3
int slaveSelectPin = 10;
4
int analogInPin    = A0; // potentiometer
5
int analogOutPin   = 9;  // PWM
6

7
int sensorValue = 0;
8
int pwmValue    = 0;
9
int potValue    = 0;
10

11
void setup() 
12
{
13
    pinMode(slaveSelectPin, OUTPUT);
14
}
15

16
void loop()
17
{
18
    sensorValue = analogRead(analogInPin);
19
    
20
    // limit input value
21
    if (sensorValue > 368) // = 1.8V
22
      sensorValue = 368;  
23
      
24
    pwmValue = map(sensorValue, 0, 1023, 0, 255);
25
    potValue = map(sensorValue, 0, 1023, 0, 128);
26
                       
27
    analogWrite(analogOutPin, pwmValue);
28
    
29
    SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
30
    digitalWrite(slaveSelectPin, 0);
31
    SPI.transfer(0x00); 
32
    SPI.transfer(potValue);
33
    digitalWrite(slaveSelectPin, 1),
34
    SPI.endTransaction(); 
35

36
    delay(1);
37
}
OP #4961911
Lesenswert?

Danke, Joe F. für den Sketch.

habs mal hochgeladen; leider keine Änderung, ich habe am Potiausgang ein 
Messgerät angeschlossen, der Wert bleibt fest bei 5k bzw. 2,5k, je nach
Anschluss des Messgeräts.

Vielleicht sollte ich mir mal ein neues DigiPoti bestellen...?

Allerdings wir die Spannung jetzt nur noch bis 1,8V ausgegeben, ohne den 
Rücksprung auf fest 0,5V.
#4962004
Lesenswert?

Sven B. schrieb:
> habs mal hochgeladen; leider keine Änderung, ich habe am Potiausgang ein
> Messgerät angeschlossen, der Wert bleibt fest bei 5k bzw. 2,5k, je nach
> Anschluss des Messgeräts.

Das Messgerät ist ein Multimeter?

Auch bei Messungen mit dem Multimeter muss ein Ende des Potentiometers 
immer mit GND verbunden sein, sonst kann das Digital-"Potentiometer" 
nicht funktionieren. Und das schwarze Messkabel des Multimeters geht 
dann auch an GND.

Mache mal bitte eine Zeichnung, wie du alles genau verschaltet hast.
Stromversorgung, Arduino, Digitalpotentiometer, Messgerät.

> Vielleicht sollte ich mir mal ein neues DigiPoti bestellen...?

Gleich 2 zu bestellen wäre vermutlich kein Fehler gewesen ;-)

> Allerdings wir die Spannung jetzt nur noch bis 1,8V ausgegeben, ohne den
> Rücksprung auf fest 0,5V.

Ja, mein Fehler.

Ersetze
1
    // limit input value
2
    if (sensorValue > 368) // = 1.8V
3
      sensorValue = 368;

durch
1
    if (sensorValue > 368) // > 1.8V?
2
      sensorValue = 102;   // 0.5V


Nachtrag:
Du könntest statt den Widerstand mit einem Messgerät zu messen auch das 
Digitalpotentiometer erstmal als Spannungsteiler verwenden.

Verbinde
P0A mit GND
P0B mit +5V

und miss dann die Spannung zwischen P0W und GND.
#4963184
Lesenswert?

Dietrich L. schrieb:
> Da fehlt noch die Verbindung zwischen GND vom Arduino/MC4131 und GND der
> Motorsteuerung!

Genau, denn die "Standardverkabelung" fällt ja weg.

Und diese GND Verbindung muss auch zum Testen hergestellt werden (s. 
Anhang, dicke schwarze Leitung).

Baue mal auch noch einen Serienwiderstand in die SDI/SDO Leitung rein.
Dieses schmutzige Teil "multiplext" die SDI Leitung auf eine sehr 
unkonventionelle Weise, und treibt zeitweise von der MCP4131 Seite gegen 
MOSI.

Ein 2.2K Widerstand begrenzt den Strom in diesem Fall auf unschädliche 
2mA.
Angehängte Dateien:
#4964717
Lesenswert?

Es gibt halt sehr, sehr viele möglich Fehlerquellen.
Von schlichtem "falsch angeschlossen", bis Digipot kaputt.

Gut wäre, du könntest dir irgendwie mal ein Oszilloskop besorgen.

Ansonsten, probiere doch mal aus das Digitalpotentiometer als 
Spannungsteiler zu benutzen (P0A an GND, P0B an +5V), und miss die 
Spannung am Schleifer mit einem Voltmeter.

Ausserdem wäre ein 100nF Kondensator zwischen dem Vdd und dem Vss Pin 
direkt am MCP4131 sehr zu empfehlen.

Vielleicht ist auch die Bitrate mit 1 MHz zu hoch für deinen Aufbau.
Probiere es mal 10 KHz:
1
SPI.beginTransaction(SPISettings(10000, MSBFIRST, SPI_MODE0));
2
                                 ^^^^^


Wenn du ein neues Digitalpotentiometer kaufst, nimm besser eines, bei 
dem DIN und DOUT auf getrennten Pins liegen (MCP4231).
Dann könnte man auch per Software das Potentiometer auslesen - hilft 
beim Debuggen.
Angehängte Dateien:
OP #4967769
Lesenswert?

Hallo Joe,
danke für die Unterstützung.
Der Spannungsteiler teilt zwar, aber genau in der Mitte und da bleibt er 
auch.
Frequenzänderung ändert auch nichts daran.
Werde mir die vorgeschlagenen Bauteile erst einmal beschaffen und einen 
neuen Versuch starten.
Werde das Ergebnis dann zu gegebener Zeit bekannt geben.

Grüße
Sven
#4967821
Lesenswert?

Warum meinen eigentlich immer alle fuer sowas ein Digitalpoti benutzen 
zu muessen?

Das Drosselklappenpoti erzeugt ja schon eine sich veraenderdende 
Spannung. Also hat das Steuergeraet einen Spannungseingang. Da kann man 
doch wunderbar eine Digital nach Analogwandlung per PWM machen wie er es 
am Anfang auch hatte. Also PWM vom Controller dann eine RC-Tiefpass 
hinterher damit man eine Analoge Spannung erhaelt. Dann noch einen 
Buffer mit einem OP damit die auch belastbar ist und dann ab damit ins 
Steuergeraet. Das das Steuergeraet meckert wenn es kein Poti sieht ist 
doch simpelst mittels Belastungwiderstand von rund 5 KOhm zu loesen 
zwischen den beiden Kontakten wo die Potischleifbahn angeschlossen wird.


                            |-----+
PWM -------R------+---------+ +   |
                  |         |     +--+-----Steuergeraet Schleifereingang
                  C      +--+ -   |  |
                  |      |  |-----|  |  +-- Steuergeraet Schleifbahn
                  GND    |           |  |
                         |-----------+  5KOhm
                                        |
                                        +-- Steuergeraet Schleifbahn
                                        |
                                        GND
OP #4968363
Lesenswert?

Hallo Helmut,

vielen Dank,
je einfacher, desto besser. Das war ja auch mein ursprünglicher Plan. 
Hatte mir erhofft, dass ich durch das DigPoti eine Potentialtrennung 
erreiche. Wurde hier aber eines besseren belehrt.

Könntest Du (Ihr) mir denn bei der Auslegung des RC-Glieds und der 
Auswahl eines OPs behilflich sein?

Würde gerne einen Spannungsabfall durch das RC-Glied weitestgehend 
vermeiden, da ja die Ausgangsspannung bis 1,8V 1:1 zur Eingangsspannung 
ausgegeben werden soll. Den Rest (0,5V) kann ich ja übers Programm 
anpassen.


Gruß
Sven
#4968374
Lesenswert?

Ein Vorteil des Digitalpotentiomters ist: es reagiert schnell und 
liefert eine saubere Ausgangsspannung.

Bei PWM muss man immer einen Kompromiss zwischen 
Reaktionsgeschwindigkeit und Welligkeit der Ausgangsspannung machen.
Je "glatter" die Ausgangsspannung, desto länger dauert es, bis das 
RC-Glied die Soll-Spannung erreicht hat...

Welche PWM Frequenz willst du denn nutzen, und wie schnell muss eine 
Änderung der Potistellung am Steuergerät ankommen (maximale 
Verzögerung)?
OP #4968446
Lesenswert?

Hallo Joe,

die Frage kann ich Dir leider nicht beantworten, da ich die Eigenheiten 
des Steuergeräts nicht kenne; da hilft nur probieren.
Wobei...selbst wenn die Ausgangsspannung durch das RC-Glied niedriger 
ausfällt, wäre es ja eigentlich kein Problem, da ich ja nicht die vollen 
5V
ausschöpfe sondern nur eine Ausgangsspannung bis max. 1,8V benötige.
Das heißt ich müsste den Spannungsabfall am RC-Glied doch nur 
programmtechnisch um deren Wert kompensieren...?
Und das ist auch der Grund, warum ich auf eine Potentialtrennung einen 
hohen Wert lege...ich möchte mir das Steuergerät nicht zerstören...
Ich würde einfach mal mit PWM anfangen und wenn`s nicht funktioniert auf 
DigPoti und SPI umsteigen.
Aber wie gesagt, mir fehlt ein wenig das "elektronische 
Hintergrundwissen".


Gruß
Sven
#4968486
Lesenswert?

Sven B. schrieb:
> Das heißt ich müsste den Spannungsabfall am RC-Glied doch nur
> programmtechnisch um deren Wert kompensieren...?

Da gibt es keinen Spannungsabfall nur weniger oder mehr Ripple drauf.

Sven B. schrieb:
> Und das ist auch der Grund, warum ich auf eine Potentialtrennung einen
> hohen Wert lege.

Kannst du weder hiermit noch durch ein Digitalpoti erreichen. Das 
erfordert mehr Aufwand. Da muss dann in allen fällen ein Optokoppeler 
zwischen geschaltet werden. Da dann auf der isolierten Seite auch 
Schaltungsteile liegen, auch noch einen DCDC wandler zur versorgung 
dieser Teile.
OP #4969414
Lesenswert?

Ich glaube ich mache es mir mal ganz einfach; ich besorge mir einen 
DC/DC-Wandler sowie einem OP und schaue mal, ob die Motorsteuerung das 
Signal annimmt.
Sollte sie nicht, kann ich ja immer noch ein RC-Glied davor schalten.

Und wenn das auch nicht funktioniert, bin ich wieder bei meiner 
SPI-Schnittstelle...
#4969657
Lesenswert?

Sven B. schrieb:
> Ich glaube ich mache es mir mal ganz einfach; ich besorge mir einen
> DC/DC-Wandler sowie einem OP und schaue mal, ob die Motorsteuerung das
> Signal annimmt.

Also mindestens den DC/DC Wandler kannst du dir glaube ich sparen.
Dein Steuergerät möchte ja offenbar eh ein wenig belastet werden, um 
keine Fehlermeldung zu generieren.

Ich hätte da noch einen Vorschlag für eine galvanische Trennung der PWM 
(siehe Anhang).
Da du ja nicht den vollen 5V Bereich am Ausgang brauchst, könnte das so 
gehen. Im oberen Bereich wird es etwas unlinear, aber das ist auch 
oberhalb der 2.5V und man könnte es in Software herauskompensieren.
Für die Simulation habe ich eine 2 KHz PWM genommen.
+5V_A sind die 5V auf dem Arduinoboard.
+5V_B die 5V vom Steuergerät.
Die GNDs links und rechts der Optokoppler sind jeweils die GNDs vom 
Arduino und vom Steuergerät. Sie müssen/sollten nicht mehr zusammen 
gelegt werden.
Angehängte Dateien:

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren