Raspberry Pi ADC Interrupt

[ADC19191 (Gast)]

Hallo,

ich bin momentan dabei mit einem Raspberry Pi sowie einem ADC MCP3208 
und mit Hilfe der wiringPi-Bib Signale einzulesen. Ziel ist es 
irgendwann einen FIR-Filter zu implementieren. Da ist aber noch 
Zukunftsmusik :D
Momentan gebe ich über einen Signalgenerator einen Takt vor, welcher 
wiederum den Interrupt auslöst. In der ISR wird der ADC getartet, 
welcher über SPI die Daten an den Raspberry Pi sendet.
Das Problem: Am Signalgenerator stelle ich 40 kHz ein. Somit müsste ja 
der Interrupt alle 25 µs ausgelöst werden. Um das ganze zu überprüfen 
habe ich in der ISR einen Testpin so konfiguriert, dass er bei jedem 
Aufruf des ISR den Zustand wechselt. Sprich von LOW auf HIGH und von 
HIGH auf LOW wechselt. Diesen Pin messe ich mit dem Oszi. Auf dem Oszi 
sind lese ich jedoch eine Frequenz von 17 kHz ab. Weiß eventuell jemand 
wie das zustande kommt?

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

#include <wiringPi.h>
#include <wiringPiSPI.h>

#define CS_MCP3208  8       // BCM_GPIO8

#define BUTTON_PIN 3
#define DG_OUT 7
#define CHANNEL_BIT_MASK 0x07
#define BYTE_I_MASK 0x06
#define BYTE_II_MASK 0x00
#define BYTE_II_RCV_MASK 0x0F
#define SPI_CHANNEL 0
#define SPI_SPEED   2000000 // !! Start low here and if all works try to increase if needed on a breadboard I could go upto about 750000 

int toggle = 1;
int start, end;
  
int read_mcp3208_adc(unsigned char adcChannel);


void myInterrupt(void) {
  int adc1Channel = 0;
  int adc1Value   = 0;
  
  start = micros();
  toggle ^= 1;
  digitalWrite(DG_OUT, toggle); 
  adc1Value = read_mcp3208_adc(adc1Channel);
  adc1Value = (3.3/4096) * adc1Value;
  end = micros();

  //printf("\n int: 0 %d \n", end - start);
}


int main (void)
{
  //int adc1Channel = 0;
  //int adc1Value   = 0;

   
  if(wiringPiSetup() == -1)
  {
    fprintf (stdout, "Unable to start wiringPi: %s\n", strerror(errno));
    return 1 ;
  }

  wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED);
  
    if ( wiringPiISR (BUTTON_PIN, INT_EDGE_RISING, &myInterrupt) < 0 ) {
      fprintf (stderr, "Unable to setup ISR: %s\n", strerror (errno));
      return 1;
  }

  pinMode(CS_MCP3208, OUTPUT);
  pinMode(DG_OUT, OUTPUT);

  while(1)
  {
    //system("clear");
    //printf("\n\nMCP3208 channel output.\n\n");
    //adc1Value = read_mcp3208_adc(adc1Channel);
    //printf("adc0 Value = %04u", adc1Value);
    //printf("\tVoltage = %.6f\n", ((3.3/4096) * adc1Value));

    usleep(1000000);
    //printf("\n int: 0 %d \n", end - start);
    //waitForInterrupt(BUTTON_PIN,1);

  
  }
  return 0;
}



int read_mcp3208_adc(unsigned char adcChannel)
{
  unsigned char buff[3];
  int adcValue = 0;
  


  buff[0] = BYTE_I_MASK | ((adcChannel & CHANNEL_BIT_MASK) >> 2);
  buff[1] = ((adcChannel & CHANNEL_BIT_MASK) << 6);
  buff[2] = BYTE_II_MASK;

  digitalWrite(CS_MCP3208, 0);  // Low : CS Active

  wiringPiSPIDataRW(SPI_CHANNEL, buff, 3);

  buff[1] = BYTE_II_RCV_MASK & buff[1];
  adcValue = ( buff[1] << 8) | buff[2];

  digitalWrite(CS_MCP3208, 1);  // High : CS Inactive
  


  return adcValue;
}

[Alex G. (dragongamer)]

Hmm, entweder ist einfach zu viel Code im ISR - diese sollten ja 
normalerweise sehr kurz sein - oder das digitalWrite ist zu langsam da 
es immer noch durch eine Treiberschicht durch muss, auf dem Raspi.

Versuch dahingehend zu debuggen.
Erstmal in die ISR nur einen double incrementieren und nach Separat nach 
z.B. 5s anhalten und den Wert ausgeben.
Damit kannst du prüfen ob die ISR erfolgreich mit 40khz feuert.

Dann bau das Auslesen des ADC hinzu und prüfe erneut.

Zuletzt lass das ADC Zeug raus und mach nur den Toggle und miss die 
Frequenz.

[Wolfgang (Gast)]

ADC19191 schrieb:
> Momentan gebe ich über einen Signalgenerator einen Takt vor, welcher
> wiederum den Interrupt auslöst. In der ISR wird der ADC getartet,
> welcher über SPI die Daten an den Raspberry Pi sendet.

Damit taucht der Jitter der Interrupt Latenz als Abtastjitter auf und du 
versaust dir bei höheren Abtastraten deine Zeitserie vom ADC.

[PittyJ (Gast)]

Ist der Raspi der richtige Rechner für dein Vorhaben?
Wenn ich exaktes Timing brauche, dann nehme ich einen Rechner ohne OS, 
welches mir meine Seiten auslagern könnte.

Nichts gegen Raspi, ich selbst habe mehrere, doch für Echtzeit ist der 
nicht der richtige.

[Alex G. (dragongamer)]

Das stimmt auch wieder..
Die Möglichkeit ISRs einzusetzen hat zwar einiges an interesanten 
Einsatzgebieten eröffnet (z.B. den Takt von Hallsensoren an üblichen 
Motoren auszuwerten), aber z.B. ein sinnvolles Oszilloskop kann man 
damit trotzdem nicht bauen.

[Wolfgang (Gast)]

PittyJ schrieb:
> Nichts gegen Raspi, ich selbst habe mehrere, doch für Echtzeit ist der
> nicht der richtige.

Das kommt drauf an, wie "Echtzeit" spezifiziert ist. Für einen 
Datenlogger, der im deutlichen Sub-Hz-Bereich abtastet und dessen 
Eingangssignal frequenzmäßig vernünftig begrenzt ist, wird es vermutlich 
reichen.