Wie mit analog Poti => Digital Poti ansteuern ?

International Deutsch
1

Hallo zusammen,

ich möchte mit einem Analog Poti (3 Draht) per Arduino UnoR3, ein DigitalPoti (AD5204, 4x100k) ansteuern

  • also nicht per Taste sondern tatsächlich per analog Poti.
    Der AD 5204 soll dabei ebenfalls als 3 Draht Poti arbeiten.

Verdrahtet (mehrfach überprüft und durchgemessen) sind Poti / Uno und AD 5204 folgendermaßen:

Analog Poti => Arduino:
ein PIN geht auf + 5V
Schleifer geht auf A0
der andere PIN geht auf GND

Digital Poti AD 5204 => Arduino:
GND => GND
CS (PIN4) => Pin 10
VDD (PIN6) => 5V
SDI (PIN8) => Pin 11
CLK (PIN9) => Pin 13
SDO (PIN10) => Pin 12

Die AD 5204 Ausgänge A1- A4, B1 - B4 und W1 - W4 sind in meinem Fall bisher noch komplett unbeschaltet.
Widerstandsänderungen müssten sich dort dann eigentlich direkt per Multimeter ohne weitere zusätzliche Beschaltungen messen lassen... ?

Allerdings bin ich mir hier nicht so ganz sicher, da im Tutorial Sketch des ansonsten baugleichen AD5206 auch folgendes steht:

Die Rennbahn:

  • Alle A-Pins des AD5206 sind mit + 5V verbunden
  • Alle B-Pins des AD5206 sind mit Masse verbunden

Das AD 5204 / 5206 Datenblatt habe ich hier mal mit angehängt.

Ich verwende für den AD 5204 allerdings diesen Sketch :

/*
  AD5204 - Arduino Example
  www.danielandrade.net - daniel spillere andrade
  https://github.com/dansku/ad5204
  June 2014  
*/

#include "SPI.h"    // SPI Library
  
const int CS = 10;    // Chip Select For the AD5204

//----[Setup]------------------------

void setup()
{
  pinMode(CS,OUTPUT);
  digitalWrite(CS,HIGH);
  SPI.begin(); // start SPI bus. 
  SPI.setBitOrder(MSBFIRST); 
}

//----[Loop]--------------------------

void loop()
{
  //Set resistance from 0% to 100% in all output
  for(int i=0;i<4;i++){
    for(int j=0;j<255;j++){
      setPot(i,j);
      delay(100);
    }
  }
}

//----[Functions]--------------------

// POT value: 0 -> 3
// LEVEL valeu: 0 -> 254 (8 bits)

void setPot(int POT, int LEVEL){ 
  digitalWrite(CS, LOW);
  SPI.transfer(POT);
  SPI.transfer(LEVEL);
  digitalWrite(CS, HIGH);
}

Mit analogRead(A0) könnte ich zwar auch meinen analog Poti Wert auslesen...
Aber wie wird daraus dann der Code den der AD 5204 an seinen Eingängen benötigt ?

Habe das Datenblatt dazu schon mehrmals "Quer" gelesen - es müssen wohl verschiedene Bits an die Eingänge CS / CLK / SDI zum AD 5204 übertragen werden.
Aber welche in abhängigkeit von meinem analogen Poti, wie genau und in welchem Format, erschließt sich mir zZ leider noch nicht... Hier benötige ich Eure Hilfe !

Meine zentrale Frage ist daher:
Was muss ich wie und wo im obigen Code ergänzen um mit meinem Analog Poti dann den AD5204 ansteuern zu können ?

würde mich sehr freuen wenn mich hier die Profis etwaserleuchten könnten !

Grüsse

AD5204_5206.pdf (302 KB)

2

Ich würde die Parameter von setPot() in byte (uint8_t) ändern, sonst ist unklar, welches Byte der int's übertragen wird. Und wenn es tatsächlich mehr als 8 Bits werden, dann muß transfer16() benutzt werden.

3

noiasca:

  1. was hat man (Sketch und Hardware)
  2. was SOLL es machen
  3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
  4. Eine Frage stellen bzw. erklären was man erwartet

vielen Dank für Eure Infos, werde das mal testen !

im Original Sketch sind die Poti Daten folgendermaßen angegeben:
// POT value: 0 -> 3
// LEVEL value: 0 -> 254 (8 bits)

Im Datenblatt steht das dass AD 5204 256 Schritte macht ? Tippfehler beim auskommentieren im Original Sketch ?
Wenn ich das richtig verstanden habe müssen insgesamt 11 Bit laut Datenblatt (Seite 15) übertragen werden,- richtig ?

uint8_t j=analogRead(A0)/4 ....

Es wird an PIN A0 gelesen, - aber welche Funktion hat dabei => /4 ?
Ist mir nicht ganz klar... steh da grade etwas auf`m Schlauch...

Grüsse

4

1023 / 4 = 255

Gruß Tommy

5

/4 nutzt aus, dass der Compiler so schlau ist, in dem Fall gar keine Division zu machen, sondern einen 10 bit Wert auf einen 8 bit Wert zu wandeln. ( >> 2 )

6

Dann wäre es doch sicherer, >>2 zu benutzen :-]

7

Tommy56:
1023 / 4 = 255

Gruß Tommy

vielen Dank, ich hatte das fast vermutet.

Mir fehlen bei so einigen Dingen als Anfänger da aber noch einige zusammenhänge und Zwischenschritte die für Euch selbstverständlich sind...-
Bräuchte da dann eine Schritt für Schritt Anleitung bezogen auf den AD 5204 Code mit erweiterung um das angesprochene analog Poti...-

uint8_t ist also die Variable die ein vorzeichenloses 8-bit Zeichen mit dem Wertebereich von 0 bis 255 speichern kann (Identisch mit byte).

uint8_t i:
iist also nur der analogPotiWert, und nicht der PIN an dem das Poti hängt ?

uint8_t j:
jgibt an das dass Poti an PIN A0 angeschlossen ist ?

Für mich wäre es zB Verständlicher und übersichtlicher i zB direkt durch den Namen analogPotiWert,
und jdurch analogPotiPIN zu ersetzen (sofern das geht), also etwa so:

Anstelle von i => uint8_t analogPotiWert // speichert den Wert des analog Potis
Anstelle vonj => uint8_t analogPotiPIN // gibt den analog PIN an andem das Poti hängt

Grüsse

8

Die andere Benennung wäre auch der bessere Weg, damit man das auch in 20 Tagen noch versteht.
Wie Du die Variablen im Quelltext bezeichnest, ist allein Deine Sache, das ist dem Compiler egal, solange die gleiche Variable immer gleich benannt ist.

Du musst halt nur konsequent die Änderungen machen. Nicht durch Suchen und Ersetzen, da könnte er zuviel ändern.

Gruß Tommy

9

Hallo,

das sind doch nur die Namen der Variablen. Diese kannst du benennen wie du lustig bist.
Was die Funktion intern macht muss dich erstmal nicht interessieren. Du musst nur wissen was die Schnittstelle wie haben möchte. Das wäre hier zuerst die Adresse bzw. Kanalnummer und dann der Wert dafür.
Bsp.

const byte pinAnalogPoti = A0;
byte kanal = 1;         // gültig von 0 bis 5

...
...
  
byte wertPoti = analogRead(pinAnalogPoti)/4;
setPoti(kanal, wertPoti);

Ich würde das bei dem AD5206 nicht unbedingt Adresse nennen sondern Kanalnummer. Dann wird das für dich vielleicht verständlicher. Weil das Teil hat 6 Digitalpotis drin die man mit der Kanalnummer anspricht bzw. adressiert. Sprich für welchen Kanal/Digipoti der Wert intern gültig sein soll.

Wenn dich das noch überfordert, dann solltest du erstmal die Grundlagen lernen. Die IDE hat genügend Beispielsketche onboard. Danach Thema Funktionen. Wie ist die aufgebaut, wie übergibt man Parameter usw. Dann kannste auch solche einfachen Bsp. lesen.

10

Tommy56:
Die andere Benennung wäre auch der bessere Weg, damit man das auch in 20 Tagen noch versteht.
Wie Du die Variablen im Quelltext bezeichnest, ist allein Deine Sache, das ist dem Compiler egal, solange die gleiche Variable immer gleich benannt ist.

Du musst halt nur konsequent die Änderungen machen. Nicht durch Suchen und Ersetzen, da könnte er zuviel ändern.

Gruß Tommy

ich würde normalerweise erstmal die Variablen im Sketch Kopf definiern wollen, - also etwa so:

int anlogPotiPin = A0; // verwendet A0 als PIN an dem das Poti angeschlossen ist
int analogPotiWert = 0; // speichert den PotiWert = 0

const int CS = 10; // verwendet PIN 10 als Chip Select für den AD5204 (PIN 4 => Arduino PIN 10)

Verständisfrage:
Mir ist nicht klar ob in der SPI Bibliothek vom AD 5204 Beispiel die beiden Variablen i und j
nicht schon fest hinterlegt sind und ich diese nicht ohne weiteres ändern kann. -

Wird die SPI Lib automatisch angepasst wenn ich diesen Variablen im Sketch einen
anderen Namen gebe ?

Ich sehe ja nicht was die Lib im Hintergrund damit macht.

...vielleicht denke ich auch gerade nur um zu viele Ecken ?

11

Die Werte der Variablen i und j werden an die Funktion übergeben. Intern benutzt die Funktion eigene Variablen, deren Namen „versteckt“ sind, d.h. nicht public.
Es ist egal, ob du die Werte als Variable i oder kanalnummer übergibst.

Besser wäre
const byte anlogPotiPin = A0;
uint16_t analogPotiWert = 0;
const byte CS = 10;

Wobei der Compiler bei const sowieso auf die ideale Breite optimiert.

12

vielen Dank für Eure Tipps !

Ich habe mal versucht den Code entsprechend zu ergänzen:
Wird auch Fehlerfrei compiliert (siehe Code), - aber:

Am AD 5204 Ausgang (in dem Fall gemessen zwischen W3 (PIN 14) un B3 (PIN 13) bleibt der Widerstand bei Änderungen am Analog Poti auf 0 Ohm... Zwischen A3 (PIN 15) und W3 (PIN 14) = unendlich...

Um Hardwaredefekte / Wackelkontakte u.ä. auszuschließen habe ich mal einen anderen Sketch aufgespielt bei dem mein analogPoti am gleichen PIN hängt = funktioniert einwandfrei.

Den AD 5204 habe ich testweise gegen ein neues Exemplar ausgetauscht. Die Messergebnisse sind die gleichen wie oben...

Irgendwas scheint immernoch zu fehlen...

BTW:

Wenn ich im Codekopf zB
const analogPotiPin = A0;
const int CS = 10;

anstelle von

const byte analogPotiPin = A0;
const byte CS = 10;

verwende, lässt sich auch nix mehr compilieren...

Hier der geänderte Code:

/*
  /*
  AD5204 - Arduino Example
  www.danielandrade.net - daniel spillere andrade
  https://github.com/dansku/ad5204
  June 2014  
*/

#include "SPI.h"    // fügt SPI Library hinzu

const byte analogPotiPin = A0;  // Globale Variable, legt A0 als PIN für das Analog Poti fest
const byte CS = 10;     // Globale Variable, setzt D10 als Chip Select (CS) für AD5204 (PIN 4 => Arduino PIN D10)

//----[Setup]------------------------

 void setup()
{
  Serial.begin(9600);// beginnt die serielle Übertragung
  
  pinMode(CS,OUTPUT); // definiert CS (PIN D10) als Output
  digitalWrite(CS,HIGH); // setzt CS (PIN 10) auf High  
  SPI.begin(); // startet den SPI bus. 
  SPI.setBitOrder(MSBFIRST); 
}

//----[Loop]--------------------------

void loop(){
  
   // Lokale Variable,deklariert den Namen als analogPotiWert und speichert den durch 4 geteilten Wert 
   uint16_t analogPotiWert = analogRead(analogPotiPin)/4;  

   // Lokale Variable,deklariert den Namen als analogPotiWertAlt und setzt diesen auf 0
   uint16_t analogPotiWertAlt = 0; 
 
   // liest den analogPotiWert an PIN A0 
   //   analogPotiWert = analogRead(A0); 

   // Vergleicht bei jedem loop die Poti Werte und gibt bei Ungleichheit am PIN 10 (CS) LOW aus
      if (analogPotiWertAlt !=  analogPotiWert) {
      digitalWrite(CS, LOW);  
          }
      
   //stellt den Widerstand an allen AD 5204 Ausgängen auf 0% bis 100% 
   
       for(int analogPotiWert=0;analogPotiWert<4;analogPotiWert++){
       for(int analogPotiPin=0;analogPotiPin<255;analogPotiPin++){
       setPot(analogPotiWert,analogPotiPin);
       delay(100);  
}
    }
  }

//----[Functions]--------------------

   // POT value: 0 -> 3
   // LEVEL value: 0 -> 254 (8 bits)

void setPot(int POT, int LEVEL){ 
     digitalWrite(CS, LOW);
     SPI.transfer(POT);
     SPI.transfer(LEVEL);
     digitalWrite(CS, HIGH);
}

Würde mich freuen wenn Ihr da nochmal einen Blick drauf werfen könntet (das Problem muss sich doch irgendwie lösen lassen)!?

Grüsse

13

noiasca:
const analogPotiPin = A0;

ist falsch, da fehlt die Definition der Variable.

const byte analogPotiPin = A0;

sollte richtig sein.

In deinem Code

setPot(analogPotiWert, analogPotiPin);

stimmt die Reihenfolge nicht überein mit

void setPot(int POT, int LEVEL)

Hi noiasca,

vielen Dank für die Info !

Ähm - Du hast aber schon gesehen das const byte analogPotiPin = A0; auch genauso schon im geänderten Code steht / stand ?

SetPot und void SetPot habe ich gerade noch geändert. Compilieren geht schonmal ohne Fehler.
Test steht noch aus.

aktueller geänderter Code:

/*
  AD5204 - Arduino Example
  www.danielandrade.net - daniel spillere andrade
  https://github.com/dansku/ad5204
  June 2014  
*/

#include "SPI.h"    // fügt SPI Library hinzu

const byte analogPotiPin = A0;  // Globale Variable, legt A0 als PIN für das Analog Poti fest
const byte CS = 10;     // Globale Variable, setzt D10 als Chip Select (CS) für AD5204 (PIN 4 => Arduino PIN D10)

//----[Setup]------------------------

 void setup()
{
  Serial.begin(9600);// beginnt die serielle Übertragung
  
  pinMode(CS,OUTPUT); // definiert CS (PIN 10) als Output
  digitalWrite(CS,HIGH); // setzt CS (PIN 10) auf High  
  SPI.begin(); // startet den SPI bus. 
  SPI.setBitOrder(MSBFIRST); 
}

//----[Loop]--------------------------

void loop(){
  
   // Lokale Variable,deklariert den Namen als analogPotiWert und setzt diesen auf 0
   uint16_t analogPotiWert = analogRead(analogPotiPin)/4;  

   // Lokale Variable,deklariert den Namen als analogPotiWertAlt und setzt diesen auf 0
   uint16_t analogPotiWertAlt = 0; 
 
   // liest den analogPotiWert an PIN A0 
      analogPotiWert = analogRead(A0); 

   // Vergleicht bei jedem loop die Poti Werte und gibt bei Ungleichheit am PIN 10 (CS) LOW aus
      if (analogPotiWertAlt !=  analogPotiWert) {
      digitalWrite(CS, LOW);  
          }
      
   //stellt den Widerstand an allen AD 5204 Ausgängen auf 0% bis 100% 
   
       for(int analogPotiWert=0;analogPotiWert<4;analogPotiWert++){
       for(int analogPotiPin=0;analogPotiPin<255;analogPotiPin++){
       setPot(analogPotiPin,analogPotiWert);
       delay(100);  
}
    }
  }

//----[Functions]--------------------

   // POT value: 0 -> 3
   // LEVEL value: 0 -> 254 (8 bits)

void setPot(int POT, int LEVEL){ 
     digitalWrite(CS, LOW);
     SPI.transfer(POT);
     SPI.transfer(LEVEL);
     digitalWrite(CS, HIGH);
}

Frage(n):
Kann ich eigentlich überhaupt so ohne weiteres per Multimeter am DigitalPoti AUSGANG direkt messen ?

Also zB A gegen Wiper, B gegen Wiper, A gegen B - ähnlich wie bei einem AnalogPoti
Oder die PIN`s gegen GND messen ?
Was sollte sich dabei messen lassen ?

DigitalPoti bei Messung Ein oder Ausgeschaltet ?

Die Fragen stellen sich da ich gehört habe das sich bei DigiPots häufig nur Zufallswerte messen lassen...

Grüsse

14

noiasca:
das wird so nicht klappen wie du dir das vorstellst.

Was denkst du kommt bei diesem Vergleich raus

if (analogPotiWertAlt != analogPotiWert) {

wenn du ein paar Zeilen oberhalb das deklariert hast?

uint16_t analogPotiWertAlt = 0;

und warum hast du das

setPot(analogPotiPin,analogPotiWert);

noch immer in den zwei For schleifen?
Wie viele Analog Potis hast du? Ich lese einen einzigen auf A0.

Zu deiner Hardware kann ich GAR NICHTS schreiben. Aber so wird das nichts.

war schon ziemlich spät gestern abend... - da sieht man ab nem bestimmten Punkt den Wald vor lauter Bäumen nicht mehr... :

setPot und die beiden for Schleifen stammen aus dem Original AD 5204 Sketch, und sollten später insgesamt auch mit 4 Analogen Potis verwendet werden... Ist dann beim auskommentieren übersehen worden...

if (analogPotiWertAlt != analogPotiWert) :
...Etwas ganz ähnliches habe ich mal mit Midi Controller Werten in einem anderen Projekt gemacht (da kommt auch diese if Schleife her...).

Dort wurden durch ein AnalogPoti (an A0) Midi CC Daten erzeugt, allerdings wurden die nur dann per Serial.Write und lcd.print ausgegeben wenn das Poti bewegt wurde = funktioniert einwandfrei !

Genau das war hier auch mit der if Schleife meine Idee...
Wahrscheinlich ist das aber im Fall des Digital Potis der völlig falsche Ansatz und überflüssig, da dieses ja schon die Speicherfunktion übernimmt... - wenn es sich denn irgendwann auch mal ansteuern lässt...

Habe uint16_t analogPotiWertAlt; sowie die for und if Schleife jetzt mal ganz rausgenommen.

aktueller compilierbarer Code:

/*
  AD5204 - Arduino Example
  www.danielandrade.net - daniel spillere andrade
  https://github.com/dansku/ad5204
  June 2014  
*/

#include "SPI.h"    // fügt SPI Library hinzu

const byte analogPotiPin = A0;  // Globale Variable, legt A0 als PIN für das Analog Poti fest
const byte CS = 10;     // Globale Variable, setzt D10 als Chip Select (CS) für AD5204 (PIN 4 => Arduino PIN D10)

//----[Setup]------------------------

 void setup()
{
  pinMode(CS,OUTPUT); // definiert CS (PIN D10) als Output
  digitalWrite(CS,HIGH); // setzt CS (PIN D10) auf High  
  SPI.begin(); // startet den SPI bus. 
  SPI.setBitOrder(MSBFIRST); 
}

//----[Loop]--------------------------

void loop()
{  
   // Lokale Variable,deklariert den Namen als analogPotiWert     
      uint16_t analogPotiWert ; 
 
   // Liest den aktuellen Wert am Analog Poti PIN A0, und rechnet den Wert geteilt durch 4 aus (= 256 Steps für AD 5204) 
      analogPotiWert = analogRead(analogPotiPin)/4;  

   // stellt den Widerstand an allen AD 5204 Ausgängen auf 0% bis 100%      
       {
       setPot(analogPotiPin,analogPotiWert);
       delay(100);  
       }
  }

//----[Functions]--------------------

   // POT value: 0 -> 3
   // LEVEL value: 0 -> 254 (8 bits)

void setPot(int POT, int LEVEL){ 
     digitalWrite(CS, LOW);
     SPI.transfer(POT);
     SPI.transfer(LEVEL);
     digitalWrite(CS, HIGH);
}

Grüsse

15

Doc_Arduino:
Hallo,

...Das wäre hier zuerst die Adresse bzw. Kanalnummer und dann der Wert dafür.
Bsp.

const byte pinAnalogPoti = A0;

byte kanal = 1;         // gültig von 0 bis 5

...
...
 
byte wertPoti = analogRead(pinAnalogPoti)/4;
setPoti(kanal, wertPoti);

Der AD 5204 hätte gerne ein serielles Datenwort mit 11 Bit laut Tabelle 6 im Datenblatt.
Die ersten 3 Bit sind die Adresse für jeweils eines der 4 Potis, der Rest die Daten für das gewählte Poti.

Für Kanal 1 müsste ich nach Tabelle 10 im Datenblatt (im Anhang)die Bits A2(MSBfirst), A1, A0(LSB), alle mit dem Wert 0, hintereinander übertragen.

Wie wäre dafür die richtige Schreibweise anstelle von byte kanal = 1; um die Daten hntereinander zu
senden ? Muss ich dafür 3 "byte" Variablen anlegen obwohl hier nur je 1 Bit übertragen werden soll,
zB ?:
byte A2 = 0;
byte A1 = 0;
byte A0 = 0;

Daten Bits:
Laut Tabelle 6 wären das B7 (MSBfirst) bis B0(LSB).
Mich wundert der B7 / D7 Wert von27 was umgerechnet 128 entspräche, - bei B0/D0 steht 20 was einer 1 entspricht.
Wie passt das zusammen wenn das Poti mit 256 Schritten angegeben ist ?

Welches Format / welche Scheibweise soll im Sketch für diese Daten verwendet werden (bitte Beispiel), Hex oder Binär ?
Das Datenblatt schweigt sich hier leider ziemlich aus (oder ich habs mehrfach übersehen)...
müssten ?

Grüsse

AD5204_5206.pdf (302 KB)

16

stingray05:
Mich wundert der B7 / D7 Wert von27 was umgerechnet 128 entspräche, - bei B0/D0 steht 20 was einer 1 entspricht.
Wie passt das zusammen wenn das Poti mit 256 Schritten angegeben ist ?

Dann zähle doch einfach mal auf einem Stück Papier (ja, sowas gibt es noch) zusammen:

20+21+...+27 und den Zustand alles 0 gibt es auch noch.

Gruß Tommy

17

... 0->255 macht GENAU 256 Schritte (die 0 ist auch ein Schritt) - was ungefähr auch 2^8 entspricht, also mit 8 Bit kann man 256 unterschiedliche Werte darstellen -> 0 bis 255.
Bei 10 Bit geht's bis 1023, was AUCH 1024 Schritte entspräche (1024 wäre 2^10)

Das wird Dir überall wieder begegnen, wo's um Bitbreiten geht.

MfG

18

Tommy56:
Dann zähle doch einfach mal auf einem Stück Papier (ja, sowas gibt es noch) zusammen:

20+21+...+27 und den Zustand alles 0 gibt es auch noch.

Gruß Tommy

OK und Danke für die Info, - muss also nur die 0 mitgezählt werden, dann passt das auch mit den
256 Schritten !

Nochmal die Frage zu den Adressbits beim AD 5204:
Wie wäre dafür die richtige Schreibweise anstelle von byte kanal = 1; um die Daten hntereinander zu
senden ?

Muss ich dafür 3 einzelne "byte" Variablen anlegen obwohl hier nur je 1 Bit übertragen werden soll,
zB so ?:
byte A2 = 0;
byte A1 = 0;
byte A0 = 0;
in dem Fall würde dann das Digital Poti 1 angesteuert.

Bei den Datenbits für die Levelwerte des AD 5204 ist mir nicht klar ob die Daten dann als Hex der Binärwert vorliegen müssen... ?!

Grüsse

19

Hallo,

hier fehlt noch viel mehr, hätte ich nur gleich richtig ins Datenblatt geschaut.

Du hast den AD5204. Demnach musste die Pinbelegung überprüfen.
/PR und /SHDN muss noch beschalten werden. Am besten erstmal fest auf 5V.
/CS, CLK und SDI (MOSI) gehen zum Arduino.

Wobei ich mir aktuell wegen der Datenübertragung nicht ganz sicher bin ob der wirklich nur 11 Bits haben möchte oder doch volle 16 also 2 Bytes. Einmal wird im Datenblatt immer von 11 Bit geschrieben und dann wieder von einem Word Format, was 2 Bytes sind. Keine vollen Bytes wäre unüblich, dann ginge nie Hardware SPI.

Zum testen ohne Hardware SPI. Der /CS Pin muss in Idle, also schon im setup auf HIGH.

nur 11 Bits

void softSPItransfer( const uint8_t address, const uint8_t value ) 
{ // rausschieben, MSB first 
  uint16_t data = 0;
  data = (data|address)<<8;
  data |= value;                    // beide Bytes verodern
  
  data = data<<5;                   // Bit 7 bis 3 rauswerfen
 
  for(uint8_t i=0; i<11; i++) {
    if (data & 0x8000) {            // nur oberstes Bit betrachten
      digitalWrite(MOSI, HIGH);     // und Datenleitung entsprechend setzen
    }
    else {
      digitalWrite(MOSI, LOW);
      
    }
    digitalWrite(CLK, HIGH);        // Takt erzeugen
    data = data<<1;                 // nächstes Bit links schieben
    digitalWrite(CLK, LOW);
  }

  digitalWrite(CS, HIGH);
}

volle 2 Bytes

void softSPItransfer( const uint8_t address, const uint8_t value ) 
{ // rausschieben, MSB first 
  uint16_t data = 0;
  data = (data|address)<<8;
  data |= value;                    // beide Bytes verodern
   
  for(uint8_t i=0; i<16; i++) {
    if (data & 0x8000) {            // nur oberstes Bit betrachten
      digitalWrite(MOSI, HIGH);     // und Datenleitung entsprechend setzen
    }
    else {
      digitalWrite(MOSI, LOW);
      
    }
    digitalWrite(CLK, HIGH);        // Takt erzeugen
    data = data<<1;                 // nächstes Bit links schieben
    digitalWrite(CLK, LOW);
  }

  digitalWrite(CS, HIGH);
}

Wegen den Bits und Bytes, spiele mit den Serial.print Optionen rum, schaue dir die Zahlenformate an, spiele auch mit dem Windows-Taschenrechner im "Programmierer" Modus. Dann weißt du auch ob Dezimal 255 gleich Hexadezimal 0xFF oder gleich 0b1111.1111 oder doch alles verschiedene Werte sind. Finde es raus.

20

Doc_Arduino:
Hallo,

hier fehlt noch viel mehr, hätte ich nur gleich richtig ins Datenblatt geschaut.

Du hast den AD5204. Demnach musste die Pinbelegung überprüfen.
/PR und /SHDN muss noch beschalten werden. Am besten erstmal fest auf 5V.
/CS, CLK und SDI (MOSI) gehen zum Arduino.

Hallo Doc_Arduino, vielen Dank für die Tipps !

Ich verwende zZ die IDE 1.86.
Verdrahtet (mehrfach überprüft und durchgemessen) sind AnalogPoti / UnoR3 und AD 5204 bisher noch folgendermaßen (PR und /SHDN werde ich noch ändern):

Analog Poti => Arduino:
ein PIN geht auf + 5V
Schleifer geht auf A0
der andere PIN geht auf GND

Digital Poti AD 5204 => Arduino:
GND => GND
CS (PIN4) => Pin 10
VDD (PIN6) => 5V
SDI (PIN8) => Pin 11
CLK (PIN9) => Pin 13
SDO (PIN10) => Pin 12

Die AD 5204 Ausgänge A1- A4, B1 - B4 und W1 - W4 sind in meinem Fall bisher noch komplett unbeschaltet da die später 4 Analog Poti ersetzen sollen. Zum testen der Ansteuerung deshalb erstmal 1 AnalogPoti und 1 Kanal vom AD 5204.

Es gibt offenbar auch 2 verschiedene Modi:
Einen als Spannungsteiler (mit zusätzlicher Beschaltung durch GND und VS) und einen als Poti.

Widerstandsänderungen müssten sich beim Poti Modus doch an obigen Ausgangs PINs eigentlich direkt per Multimeter ohne weitere zusätzliche Beschaltungen messen lassen... ? Oder dann doch gegen GND ? - Gibts dazu irgendwelche Erfahrungen?
Leider gibt das Datenblatt dazu keine konkreten Infos...

Grüsse