[beagleboard] BBB Libpruio Analog Data

[Ritesh Bhatt]

Hello! I'm a graduate student working with a BBB trying to collect analog 
data from some sensors through the onboard PRUs (we need high sampling rate 
on the order of 20kHz since it's a frequency based experiment). I'm working 
with code from previous students that worked on this project and they used 
Libpruio to accomplish this. Specifically, they are collecting the data 
using Ring Buffer mode and saving it to a text file to be processed further 
for some feature extraction and further analysis.

What I'm trying to understand is this: how does Ring Buffer sampling 
actually work? As in, if I'm reading data using two analog inputs and 
saving it to a text file, what order are the values in? How do I parse them 
into meaningful sensor values? I've attached the C code I'm working with, 
and greatly appreciate any help or pointers!

-- 
For more options, visit http://beagleboard.org/discuss
--- 
You received this message because you are subscribed to the Google Groups 
"BeagleBoard" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to beagleboard+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/beagleboard/a2fe783e-6b1f-44df-a8ca-92e7a5114747n%40googlegroups.com.

/** \file rb_file.c
\brief Example: fetch ADC samples in a ring buffer and save to file.
This file contains an example on how to use the ring buffer mode of
libpruio. A fixed step mask of AIN-0, AIN-1 and AIN-2 get configured
for maximum speed, sampled in to the ring buffer and from there saved
as raw data to some files. Find a functional description in section
\ref sSecExaRbFile.
Licence: GPLv3, Copyright 2014-\Year by \Mail
Thanks for C code translation: Nils Kohrs <nils.ko...@gmail.com>
Compile by: `gcc -Wall -o readTwoADCChannel readTwoADCChannel.c -lpruio`
\since 0.4.0
*/

#include "unistd.h"
#include "time.h"
#include "stdio.h"
#include "libpruio/pruio.h"

//! The main function.
int main(int argc, char **argv)
{
  const uint32 tSamp = (uint32) atoi(argv[1]);  //!< The number of samples in the files (per step).
  const uint32 tmr = (uint32) atoi(argv[2]);     //!< The sampling rate in ns (20000 -> 50 kHz).
  const uint32 NoStep = 2;      //!< The number of active steps (must match setStep calls and mask).
  const uint32 NoFile = 2;      //!< The number of files to write.
  const char *NamFil = "output2.%u";

  struct timespec mSec;
  mSec.tv_nsec = 1000000;

  pruIo *io = pruio_new(PRUIO_DEF_ACTIVE, 0, 0, 0); //! create new driver
  if (io->Errr){
               printf("constructor failed (%s)\n", io->Errr); return 1;}

  do {
    //Set-up the AIN-1 channel
    if (pruio_adc_setStep(io, 10, 1, 0, 0, 0)){ //          step 10, AIN-1
        printf("step 10 configuration failed: (%s)\n", io->Errr); break;}
    //Set-up the AIN-2 channel
    if (pruio_adc_setStep(io,11, 2, 0, 0, 0)){ //         step 11, AIN-2
       printf("step 11 configuration failed: (%s)\n", io->Errr); break;}

    //Define bit mask for the ADC channels (AIN-1 and AIN-2)
    uint32 mask = 6 << 9;         //!< The active steps (10 to 11) (6<<9 --> 0000110000000000)
    
    uint32 tInd = tSamp * NoStep; //!< The maximum total index.
    uint32 half = ((io->ESize >> 2) / NoStep) * NoStep; //!< The maximum index of the half ring buffer.

    if (half > tInd){ half = tInd;}  //       adapt size for small files
    uint32 samp = (half << 1) / NoStep; //!< The number of samples (per step).

    if (pruio_config(io, samp, mask, tmr, 0)){ //       configure driver
                       printf("config failed (%s)\n", io->Errr); break;}

    if (pruio_rb_start(io)){
                     printf("rb_start failed (%s)\n", io->Errr); break;}

    /* Writing the recorded values to a buffer */
    uint16 *p0 = io->Adc->Value;  //!< A pointer to the start of the ring buffer.
    uint16 *p1 = p0 + half;       //!< A pointer to the middle of the ring buffer.
    uint32 n;  //!< File counter.
    char fName[20];
    for(n = 0; n < NoFile; n++){
      sprintf(fName, NamFil, n);
      FILE *oFile = fopen(fName, "w");
      uint32 i = 0;               //!< Start index.
      while(i < tInd){
        i += half;
        if(i > tInd){         // fetch the rest(maybe no complete chunk)
          uint32 rest = tInd + half - i;
          uint32 iEnd = p1 >= p0 ? rest : rest + half;
          while(io->DRam[0] < iEnd) usleep(1000);
          //printf("  writing samples %u-%u\n", tInd -rest, tInd-1);
          fwrite(p0, sizeof(uint16), rest, oFile);
          uint16 *swap = p0;
          p0 = p1;
          p1 = swap;
          break;
        }
        if(p1 > p0) while(io->DRam[0] < half) usleep(1000);
        else        while(io->DRam[0] > half) usleep(1000);
        //printf("  writing samples %u-%u\n", i-half, i-1);
        fwrite(p0,  sizeof(uint16), half, oFile);
        uint16 *swap = p0;
        p0 = p1;
        p1 = swap;
      }
      fclose(oFile);
      //printf("Finished file %s\n", fName);
    }
  } while(0);
  pruio_destroy(io);
  return 0;
}