Salvataggio, importazione dati per grafico

[Pioz]

Ciao ragazzi.
Sto cercando il modo migliore per salvare dei dati su un file di testo .txt per poi poterli facilmente importare in un software che si occupi di disegnarne i relativi grafici.
In pratica i dati sono i risultati derivati dal campionamento di 32 sensori. Per problemi di velocità con Arduino non ce la faccio a creare 32 file di testo diversi in modo da salvare su ognuno i rispettivi valori per cui mi trovo costretto ad ammassare tutto in un unico file.
In pratica i campioni verrebbero organizzati così (tanto per farmi capire):
x1,x2,x3,x4...x32,x1,x2..... (una trama PCM in pratica)
So che se separo i valori con una virgola riesco facilmente ad importarli con excel ma non saprei come dividerli e creare le effettive 32 serie di dati che poi andrebbero graficate: sulle ordinate i valori dei campioni e sulle ascisse i valori di tempo che dovrei inserire io a mano tenendo conto che la frequenza di campionamento è fissa e di circa 20Hz (circa perché non avendo ancora steso il programma definitivo non so se l'arduino ci stia dietro, al massimo la abbasso a 15 o a 10Hz).
Vi chiedo quindi se separare i dati con la virgola sia il modo migliore di salvarli e vi chiedo se conoscete un buon programma con il quale smistarli e graficarli per bene
Grazie

[nand92]

Ciao!
Per smistare dei dati ordinati in questo modo potresti scriverti un semplice programma, magari in C (suppongo che tu lo conosca se usi Arduino) che prenda in input il file formattato in quel modo e lo "traduca" in altri formati.

P.S. con più informazioni sui sensori si potrebbe provare a rispondere anche ai tuoi dubbi sulla frequenza di campionamento.

Ciao

[Pioz]

Ciao Grazie intanto per la risposta.
I sensori sono delle termocoppie di tipo k...Le 32 TC sono multiplexate con un multiplexer analogico 32 canali (5bit di selezione). Il problema riguardo la frequenza di campionamento non è sui sensori ma bensì sulla velocità dell'ardunino di scrivere e salvare i dati sull'SD.

Per smistare dei dati ordinati in questo modo potresti scriverti un semplice programma, magari in C (suppongo che tu lo conosca se usi Arduino) che prenda in input il file formattato in quel modo e lo "traduca" in altri formati.

Sì a scuola ho fatto un po' di C++ ma non ho importato/esportato da documenti di testo. Vedrò intanto di informarmi; se hai qualche consiglio da darmi è bene accetto!!

Ciao

[nand92]

Ciao! A che frequenza di clock usi il bus SPI per comunicare sull'SD? Che filesystem usi? FAT o FAT32?
Normalmente dovresti metterci molto poco tempo a scrivere su file, potresti raggiungere frequenze di campionamento molto più alte!
Se non ce la fai a stare "a tempo" con la sequenza
"acquisisci campione" -> "scrivi su file"
puoi usare un buffer per minimizzare il numero di accessi al filesystem, es:
"acquisisci campione" -> "inserisci campione in buffer in RAM" -> "se buffer è pieno, scrivi su file"
secondo me con quest'ultima tecnica potresti farcela anche scrivendo un file separato per ogni sonda. ma con questa tecnica rendi leggermente "irregolare" gli intervalli di tempo, visto che quando scrivi su file inserisci un ritardo decisamente più lungo di quando ti limiti ad inserire nel buffer in RAM.

Tornando al programma per separare il file in un file per sonda, ti preparo uno schizzo e te lo posto appena ho fatto.

[nand92]

Ecco, ho un esempio di codice. Il file di input deve avere i campioni separati da un carattere a tua scelta, senza spazi, nell'ordinamento da te definito : sample1canale1,sample1canale2,sample1canale3,sample2canale1,...,sampleNcanaleM
con o senza virgola alla fine, è ininfluente.
puoi cambiare il numero di canali, il percorso del file di input, il formato dei file di output coi "define" all'inizio del codice.
Ti invito a provarlo per vedere se funziona come ti serve, così lo puoi poi personalizzare secondo le tue esigenze.
Ciao!

Codice: Seleziona tutto

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

#define NUM_CANALI 3
#define CARATTERE_SEPARATORE ','
#define FILE_INPUT "D:\\in.txt"
#define FILE_OUTPUT "D:\\out%i.txt"

int main(int argc, char ** argv)
{
    #define TEMPSTR_DIM 100
    char tempStr[TEMPSTR_DIM + 1];
    int i, ic, numCanale;
    char c;
    short fineFile;
    FILE * fIn;
    FILE * fOuts[NUM_CANALI];
    short aggiungiVirgola[NUM_CANALI];

    // Apro il file di input
    fIn = fopen(FILE_INPUT, "r");
    if (fIn == NULL)
    {
        printf("Impossibile aprire il file di input\n");
        exit(EXIT_FAILURE);
    }

    // Apro tutti i file di uscita
    for (i = 0; i < NUM_CANALI; i ++)
    {
        sprintf(tempStr, FILE_OUTPUT, i);
        fOuts[i] = fopen(tempStr, "w+");
        if (fOuts[i] == NULL)
        {
            fclose(fIn);
            printf("Impossibile aprire il file di output \"%s\"\n", tempStr);
            exit(EXIT_FAILURE);
        }
        aggiungiVirgola[i] = 0;
    }

    // Leggo il file di input carattere per carattere
    i = 0;
    tempStr[0] = '\0';
    numCanale = 0;
    fineFile = 0;

    while (! fineFile)
    {
        ic = fgetc(fIn);
        if (ic == EOF)
        {
            ic = CARATTERE_SEPARATORE;
            fineFile = 1;
        }
        c = (char)ic;

        // Se il carattere letto non è il separatore,
        // lo aggiungo ad una stringa temporanea
        if (c != CARATTERE_SEPARATORE)
        {
            if (i >= TEMPSTR_DIM)
            {
                printf("Buffer overflow. controlla il separatore dei campioni\n");
                exit(EXIT_FAILURE);
            }

            tempStr[i] = c;
            tempStr[i + 1] = '\0';
            i ++;
        }
        // Altrimenti trascrivo la stringa nel file appropriato
        else
        {
            // Verifico che ci sia effettivamente qualcosa da scrivere
            if (tempStr[0] != '\0')
            {
                if (aggiungiVirgola[numCanale])
                    fprintf(fOuts[numCanale], ",%s", tempStr);
                else
                {
                    fprintf(fOuts[numCanale], "%s", tempStr);
                    aggiungiVirgola[numCanale] = 1;
                }

                numCanale ++;
                if (numCanale >= NUM_CANALI) numCanale = 0;
            }

            i = 0;
            tempStr[0] = '\0';
        }
    }

    return EXIT_SUCCESS;
}


EDIT:
il programma lavora con stringhe, quindi non preoccuparti del formato in cui salvi i campioni: puoi scrivere qualsiasi cosa vuoi, anche "12515ao12or!$=O!°", basta che non ci metti in mezzo il carattere separatore, o che lo cambi con un altro

[Pioz]

Ciao.
Intanto grazie per le risposte e per il programma. Non l'ho ancora provato perché fino ad ora ho riprovato a scrivere su 32 file diversi campione per campione.
Sto usando lo slot uSD presente nel modulo Ethernet
Ho utilizzato la libreria SDFat che mi permette di lavorare con la velocità SPI massima (almeno mi sembra). Con la libreria SD standard invece il clock SPI è dimezzato.
La SD di fabbrica è formattata in FAT e la sto usando così...Non so se mi conviene formattarla in FAT32
Ho scritto questo codice per salvare su 32 file diversi (ho salvato solo "1024", non ho letto dati):

Codice: Seleziona tutto

#include <SdFat.h>
#include <SdFatUtil.h>

SdFat sd;
SdFile file;

const uint8_t chipSelect = 4;


int n;
long int k,m;
char *  h[32]={"1.txt","2.txt","3.txt","4.txt","5.txt","6.txt","7.txt","8.txt","9.txt","10.txt","11.txt","12.txt","13.txt","14.txt","15.txt","16.txt","17.txt","18.txt","19.txt","20.txt","21.txt","22.txt","23.txt","24.txt","25.txt","26.txt","27.txt","28.txt","29.txt","30.txt","31.txt","32.txt"};

void setup() {
  Serial.begin(9600);
  delay(1000);
 
  // Initialize SdFat or print a detailed error message and halt
  // Use half speed like the native library.
  // change to SPI_FULL_SPEED for more performance.
  if (!sd.begin(chipSelect, SPI_FULL_SPEED)) sd.initErrorHalt();

  //creazione dei 32 file di logging
  for(n=0;n<32;n++)
  {
   while (!file.open(h[n] ,O_RDWR | O_CREAT | O_AT_END))
   {
     Serial.print("Errore nell'aperura del file");
     Serial.print(n);
     Serial.print("\n");
   }
   file.close();
  }
}
void loop()
{
  k=micros(); //tempo iniziale
  for (int i=0;i<32;i++)   
  {
    file.open(h[i] , O_RDWR );
    file.write("ciao");
    file.close();
  }
  m=micros()-k; //tempo di salvataggio netto
  Serial.print(m);
  Serial.print("\n");
}



Il tempo di scrittura di tutti e 32 i file è di circa 140ms ed è abbastanza elevato per me.

Ho visto che c'è anche un altro esempio dove si dice che la velocità di logging sia molto alta ma purtroppo la mia padronanza del C non mi permette di capire, se non poco, di quello che è scritto

[nand92]

Ok, ho capito. ti consiglio di restare sul FAT, più semplice del FAT32 per un microcontrollore.
a questo punto ti conviene proprio usare un solo file e poi separarlo quando devi leggerlo!

[Pioz]

Il programma che mi hai dato funziona alla perfezione!! Grazie mille!!
Ora faccio delle prove scrivendo tutto su un solo file e poi ti faccio sapere i risultati

ti consiglio di restare sul FAT, più semplice del FAT32 per un microcontrollore

Bene, rimarrò sul FAT