mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik VDrive probleme beim Datenspeichern über SPI


Autor: Martin Ra (rama123)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich habe ein Probelm mit dem VDrive2 Modul von Vinculum. Ich nutze einen 
PIC18F4553, mit dem ich Daten über den AD-Wandler (100Hz) messe und 
diese dann per SPI auf einen Stick im VDrive speichern möchte. Ich 
verwende den VDrive in Short Command Mode.

Mein Problem ist jetzt, dass wenn ich zu viele Daten speichern möchte, 
also die Messung zu lange laufen lasse blinkt das VDrive zwar, erstellt 
aber keine Datei. Wenn ich kürzer messe bekomme ich zwar eine Datei aber 
es fehlen Daten. Irgendwie fehlen zwischendurch genau 16 Byte.

Hier ist mein Code:

Soft SPI:
/*****************************************************************************/
/* Beschreibung:
/*   Funktion zum Schreiben in das VDrive2. Der Vorgang wird nur ausgeführt,
/*   wenn Daten im Ausgangspuffer vorhanden sind.
/*****************************************************************************/
void WriteVDrive() {          //void WriteVDrive(byte Value) {
  byte CheckTransmission = 1;
  byte Value;

  if (Flags.VDriveBufferData == 1) 
  {
    Value = VDriveBuffer[VDriveBufferPointerRead];
  
    // Sequenz einleiten
    SPI_SOFT_CLEAR_SDO();
    SPI_SOFT_CLEAR_SCLK();
    SPI_CS_VDrive();
    SPI_SOFT_SET_SDO();
    SPI_SOFT_CLOCK();
    SPI_SOFT_CLEAR_SDO();
    SPI_SOFT_CLOCK();
    
    // Daten schreiben
    SPI_SOFT_CLOCK();
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
    SPI_SOFT_CLOCK();
    Value <<= 1;
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
    SPI_SOFT_CLOCK();
    Value <<= 1;
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
    SPI_SOFT_CLOCK();
    Value <<= 1;
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
    SPI_SOFT_CLOCK();
    Value <<= 1;
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
    SPI_SOFT_CLOCK();
    Value <<= 1;
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
    SPI_SOFT_CLOCK();
    Value <<= 1;
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
    SPI_SOFT_CLOCK();
    Value <<= 1;
    if (Value & 0x80) {
      SPI_SOFT_SET_SDO();
    } else {
      SPI_SOFT_CLEAR_SDO();
    }
  
    SPI_SOFT_CLOCK();
    CheckTransmission = SPI_SOFT_SDI;
  
    // Taktzyklus warten
    SPI_SOFT_CLOCK();
    SPI_CS_None();
    SPI_SOFT_CLOCK();
    SPI_SOFT_CLOCK();

    if (CheckTransmission == 0)
    {
      // Daten erfolgreich geschrieben

      VDriveBufferPointerRead++;
      if (VDriveBufferPointerRead == VDRIVE_BUFFER_LENGTH) VDriveBufferPointerRead = 0;
      if (VDriveBufferPointerRead == VDriveBufferPointerWrite) Flags.VDriveBufferData = 0;
    }
  }
}

Funktion "AddVDriveBuffer"
/*****************************************************************************/
/* Beschreibung:
/*   Funktion zum Hinzufügen eines Wertes zum Ausgangspuffer für das VDrive.
/*
/* Parameter:
/*   Value: Wert
/*****************************************************************************/
void AddVDriveBuffer(byte Value) {
  VDriveBuffer[VDriveBufferPointerWrite] = Value;
  VDriveBufferPointerWrite++;
  if (VDriveBufferPointerWrite == VDRIVE_BUFFER_LENGTH) VDriveBufferPointerWrite = 0;
  Flags.VDriveBufferData = 1;
}

Hauptprogramm in dem ich messe
void ProcessIO(void)
{
int I;
dword TempDWord;

  // VDrive auslesen
  VDriveData vdrive;
    
      vdrive.Status = 0;
      while (vdrive.Status == 0) {
        vdrive = ReadVDrive();
      }

  // Vorhandene Daten ins VDrive schreiben
INTCONbits.GIE = 0;      // Interrupt off
  for (I=1; I<=16; I++)
  { 
    WriteVDrive();
  }
INTCONbits.GIE = 1;      // Interrupt on

  if((SWITCH_Start_Pressed())&&(Flags.CheckMeasurementDone == 0))
  {
    if (Flags.MeasurementActive  ==  0)
    {
      LED_Measurement_On();

      //Start der Messung aktivieren
      Flags.MeasurementActive = 1;
      Ticks = 0;
      T0CONbits.TMR0ON = 1;
      Flags.WriteUSB = 1;
      Flags.WriteDataStart = 1;
  
      // VDrive Kommandomodus auf "Short Command Set" setzen
      AddVDriveBuffer(0x10);
      AddVDriveBuffer(0x0D);
      Flags.VDriveBufferData = 1;
  
      // Befehle zum öffnen einer Datei auf dem Stick ins SRAM speichern
      TempDWord = GetVDriveDateFromClock();
      AddVDriveBuffer(0x09); AddVDriveBuffer(0x20); AddVDriveBuffer(0x4D); AddVDriveBuffer(0x45);
      AddVDriveBuffer(0x41); AddVDriveBuffer(0x53); AddVDriveBuffer(0x55); AddVDriveBuffer(0x52);
      AddVDriveBuffer(0x45); AddVDriveBuffer(0x2E); AddVDriveBuffer(0x4E); AddVDriveBuffer(0x50);
      AddVDriveBuffer(0x47); AddVDriveBuffer(0x0D);
    }
    // Messung durchführen
    if (Flags.MeasurementActive && Flags.MeasurementGetData) 
    {
      Flags.MeasurementGetData = 0;
      if (Ticks <= 200) 
      {
        // Analogspannungen einlesen
        ANALOG_CS_Spannung();
        while (!ANALOG_MEASUREMENT_DONE) {}
        Spannung = ADRESH;
        ANALOG_CS_Strom();
        while (!ANALOG_MEASUREMENT_DONE) {}
        Strom = ADRESH;

        AddVDriveBuffer(0x08); AddVDriveBuffer(0x20); AddVDriveBuffer(0x00); AddVDriveBuffer(0x00);
        AddVDriveBuffer(0x00); AddVDriveBuffer(0x01); AddVDriveBuffer(0x0d);
        AddVDriveBuffer(Ticks);
      
      if (Ticks >200)
      {
        // File auf dem VDrive schließen
        AddVDriveBuffer(0x0A); AddVDriveBuffer(0x20); AddVDriveBuffer(0x4D); AddVDriveBuffer(0x45);
        AddVDriveBuffer(0x41); AddVDriveBuffer(0x53); AddVDriveBuffer(0x55); AddVDriveBuffer(0x52);
        AddVDriveBuffer(0x45); AddVDriveBuffer(0x2E); AddVDriveBuffer(0x4E); AddVDriveBuffer(0x50);
        AddVDriveBuffer(0x47); AddVDriveBuffer(0x0D);

        // Messung beendet
        LED_Measurement_Off();
        Flags.MeasurementActive = 0; 
        T0CONbits.TMR0ON = 0;
        Flags.CheckMeasurementDone = 1;    //Messung beendet
        Flags.ButtonPress = 0;        
      }

    }
  }
  if (!SWITCH_Start_Pressed())
  {  
    LED_Measurement_Off();

    // Messung beendet
    Flags.MeasurementActive = 0; 
    T0CONbits.TMR0ON = 0;
    Flags.CheckMeasurementDone = 0;    // Neue Messung kann gestartet werden
    Flags.ButtonPress = 0;        
  }

}

Ich hoffe es kann mir jemand helfen.
Gruß Martin

Autor: Matthias K. (matthiask)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hier findest Du SPI-Routinen für den Vinculum USB Host:
http://www.mikrocontroller.net/articles/USB-Stick_...

Ich vermute, es gibt einen Bufferüberlauf beim schnellen senden. Wenn 
ich es richtig überflogen habe, wertest Du nur das Statusbit aus, ob ein 
Byte akzepiert wurde oder nicht. Das reicht nicht aus, der Buffer kann 
trotzdem überlaufen.

Werte also noch zusätzlich das Status-BYTE aus. Darin ist ein Bit 
RECEIVE-BUFFER voll (RXF#). Details in den Projektarchiv im Artikel 
oben.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.