Programmierung eines ADC mit Arduino

[Moffo M. (Firma: HAWK Göttingen) (marcel2)]

Hallo,

ich arbeite gerade an einem Projekt, bei dem es darum geht, ein analoges 
Signal von einem ADC in ein digitales umwandeln zu lassen. Ich habe mir 
hier auf dem Forum ähnliche Projekte angeguckt, leider habe ich bis 
jetzt keine Lösung zu meinem Problem gefunden.

Ich habe als Mikrokontroller das Arduino Due zur Steuerung des 
AD7911/AD7921. Ich habe leider keine Erfahrung mit 
Arduino-Programmierung und möchte jetzt lernen, wie das ganze läuft.

hier ist das Datenblatt für mein 
Bauteil:http://www.analog.com/static/imported-files/data_sheets/AD7911_7921.pdf

ich möchte gern wissen, wie die SPI Kommunikation funktioniert, das 
heißt wie ich den ADC mit dem Arduino anspreche.  anschließend möchte 
ich das Ergebnis der  Umwandlung an den Arduino schicken und in ein 
Register speichern.

Ich habe erstmals den Code nur für einen Channel geschrieben, aber es 
läuft gar nichts.

über eine Antwort würde ich mich sehr freuen.

  #include<SPI.h>
 
 const int cs = 4;
 unsigned int adcValue;
 unsigned int adcValue1;
 unsigned int config1;
 int j=0;

void setup()

{
  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(cs,21);
  SPI.setDataMode(SPI_MODE0);
  Serial.begin(9600);

}


void loop()
{
  //Analog Digital Umwandlung 
  for (int i=0; i<16; i++)
  {
    digitalWrite(cs, LOW);
    setAdc(1);
  }
  digitalWrite(cs, HIGH);
  delayMicroseconds(10);
}  
 

//Analog Digital Funktion
void setAdc(int channel)
{
  int c=16;
 int feld1[c];
     config1=0010000000000000;

   byte adcValueLSB = SPI.transfer(cs,0x00);        // niederwertiges Byte zuerst, D15...D8
  byte adcValueMSB = SPI.transfer(cs,0x00);        // höherwertiges Byte zum Schluss, D7...D0
  adcValue = adcValueMSB << 8;
  adcValue = adcValue | adcValueLSB;
  adcValue1= adcValue | config1; 
  
     feld1[j] = adcValue1;
    Serial.print("analog value = ");
    Serial.println(feld1[j]);
    Serial.print('\n');

      j++;
  
  delayMicroseconds(0.25);//convertion time
 
      
}

[Hafax (Gast)]

Hi,

Erst einaml eine Grundlegende Frage: Ist ein externer ADC notwendig? 
Dein Arduino Due hat zwei ADC integriert die sich bequemer Auslesen 
lassen...

Nach einem kurzen Blick ins Datenblatt des ADCs bin ich, auf Seite 21, 
auf diesen Satzt gestoßen "Sixteen serial clock cycles
are required to perform the conversion process and to access
data from the AD7921". Wenn ich mir deinen Code ansehen könnte ich mir 
Vorstellen das der CS Pin nach jedem Byte wieder High wird und keine ADC 
Wandlung zustande kommt.
Versuch einmal die Chip Select Leitung "von Hand" zu setzen.

 CS PIn low setzten
 adcValue_high_byte = SPI.transfer(0x00)
 adcValue_low_byte = SPI.transfer(0x00)
CS Pin high setzten

Grüße

Hafax

[Moffo M. (Firma: HAWK Göttingen) (marcel2)]

Hey Hafax,
 Danke erstmal für deine schnelle Reaktion. Ich verstehe die Frage mit 
externem ADC, aber der Projektleiter will, dass ich die Umwandlung mit 
einem externen ADC  mache.

Ich versuche es und melde mich nochmal zurück.
Vielen Dank.

Marcel

[Cyblord -. (cyblord)]

Apropos HAWK: Fällt jetzt dein völlig talentloses Arduino rumgefrickel 
unter Wissenschaft oder Kunst?

[Moffo M. (Firma: HAWK Göttingen) (marcel2)]

hey ,

meintest du das?

 #include<SPI.h>

 const int cs = 4;
 unsigned int adcValue;
 unsigned int adcValue1;
 unsigned int config1;
 int j=0;

void setup()

{
  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(cs,21);
  SPI.setDataMode(SPI_MODE0);
  Serial.begin(9600);

}


void loop()
{
  //Analog Digital Umwandlung
  for (int i=0; i<16; i++)
  {
    setAdc(1);
  }
  delayMicroseconds(10);
}



//Analog Digital Funktion
void setAdc(int channel)
{
  int c=16;
 int feld1[c];
     config1=0010000000000000;
 digitalWrite(cs, LOW);
SPI.transfer(cs,config1);
   byte adcValueLSB = SPI.transfer(cs,0x00);        // niederwertiges 
Byte zuerst, D15...D8
  byte adcValueMSB = SPI.transfer(cs,0x00);        // höherwertiges Byte 
zum Schluss, D7...D0
 digitalWrite(cs, HIGH);
  adcValue = adcValueMSB << 8;
  adcValue = adcValue | adcValueLSB;
  adcValue1= adcValue | config1;

     feld1[j] = adcValue1;
    Serial.print("analog value = ");
    Serial.println(feld1[j]);
    Serial.print('\n');

      j++;

  delayMicroseconds(0.25);//convertion time


}

[Moffo M. (Firma: HAWK Göttingen) (marcel2)]

Unter Wissenschaft und Kunst:)

[Hafax (Gast)]

Ok nachdem ich etwas mehr Zeit hatte mir das ganze Anzusehen mal eine 
etwas Detailiertere Antwort...

1: Du übergibst den Wert Channel machst dann aber nichts damit.

2: Du Deklarierst eine Varible

 int c=16;

 nur im die Größe des

 int feld1[c];

 Arrays zu Definieren. Das ging mit einem

#define buffer_gr 16

 schöner.

3: Die Werte in deinem Array feld1 sind nach dem Rücksprung aus der 
Funktion nicht mehr Vorhanden.

4: Versuch einheitlich einzurücken

5: Es besteht ein Unterschied zwischen

 SPI.transfer(cs,0x00);

 und

 SPI.transfer(0x00);

6: Du setzt deine Index Variable j nie zurück => Das ganze läuft einmal 
dann erst nach dem Überlauf von j. Das Aber noch viel größere Problem 
ist das du mit j auf eine Stelle im Array feld1 zugreifst. Dieses ist 
aber nur 16*Sizeof(int) lang. Ist j > 16 greifst du auf einen 
Speicherbereich zu der nicht im Array liegt. Gratuliere du hast einen 
Bufferoverflow Programmiert ;D

Sind auf die Schnelle die Gröbsten Schnitzer in der Programmierung.

Nun zum Funktionstechnischen...

Lies dich in SPI ein und wie es Funktioniert. Kleiner Tipp es werden 
bidirektional die Daten geschrieben und gelesen. SPI ist eigentlich ein 
Schieberegister...

Es müsste in etwa so aussehen.

 CS auf Low
adcValue_low_byte = SPI.transfer(config1);
adcValue_high_byte = SPI.transfer(0x00);
CS auf High

[Hafax (Gast)]

Ok um so länger ich hier schreib um so mehr fällt mir auf und ein... 
Aber ich geh jetzt erst mal Glühwein trinken :P Dir noch viel spaß beim 
Progen... Btw. ein Tutorial lesen schadet selten.

[Moffo M. (Firma: HAWK Göttingen) (marcel2)]

hey ,

vielen Dank nochmal für deine Hilfe.ich hoffe dein Glühwein hat gut 
geschmeckt.ich werde morgen mein Programm noch besser strukturieren.

[Moffo M. (Firma: HAWK Göttingen) (marcel2)]

hallo,

ich habe mich heute nochmal mit dem Projekt beschäftigt, aber dabei kam 
nichts befriedigendes raus. Trotzdem glaube ich, dass das Programm schon 
besser aussieht :) ich hätte aber gern noch Hilfe und ein Paar Fragen.

hier ist mein Code, aber ich bin noch total unsicher.

  #include<SPI.h>
  #define BUFFER_SIZE1    16


 const int cs = 4;
 unsigned int adcValue;
 unsigned int config1;
 unsigned int feld1[BUFFER_SIZE1];


void setup()

{
  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);
  SPI.begin(cs);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(cs,21);
  SPI.setDataMode(cs,SPI_MODE0);
  Serial.begin(9600);

}


void loop()
{
 for(int i=0;i<16;i++)
 {
    feld1[i] =  setAdc();                              // damit will ich 
das ergebnis in einem Array speichern ,, ist dieser Befehl richtig?
    Serial.print("analog value = ");
    Serial.println(feld1[i]);
    Serial.print('\n');
    delayMicroseconds(10);
  }
}


//Analog Digital Funktion
int setAdc()
{
  config1=00100000;
  digitalWrite(cs, LOW);
  byte adcValueLSB = SPI.transfer(cs,config1);         // niederwertiges 
Byte zuerst, D15...D8
  byte adcValueMSB = SPI.transfer(cs,0x00);         // höherwertiges 
Byte zum Schluss, D7...D0
  adcValue = adcValueMSB << 8;
  adcValue = adcValue | adcValueLSB;                //wird sommit das 
umgewandelte Signal an adcValue zugewiesen?
  delayMicroseconds(4);                           //cycle time
  digitalWrite(cs, HIGH);
  return adcValue;

}




 1) wie kann ich das Ergebnis der Umwandlung in ein Array speichern
2) wie kann ich auf das Ergebnis ohne die ersten 4 Bits 
zugreifen(convertion result).

[Moffo M. (Firma: HAWK Göttingen) (marcel2)]

sorry nochmal wenn ich blöde Fragen stelle...ich lerne gerade Arduino 
und SPI:)

[Cyblord -. (cyblord)]

Moffo Marcel schrieb:
> sorry nochmal wenn ich blöde Fragen stelle...ich lerne gerade Arduino
> und SPI:)

Werd doch lieber Gärtner. Da lernst du Bäume und Blumen. Evt. liegt dir 
das besser?