Sperrt f16_blockwrite Interrupts?

loop
     if isSysTimerZero(SecTimer) then
       SetSysTimer(SecTimer, 2);       // 2 x 0.5 = 1 milisecond
       // put here what you want to do each milisecond
     endif;
endloop;

program test1284;

Device = mega1284P, VCC = 5;

Define_Fuses
  SPIclk         = 1000000;
  NoteBook       = A;
  COMport        = USB;
  LockBits0      = [];
  ProgMode       = SPI; // SPI, JTAG or OWD
  ProgFuses      = true; // or false – program Fuse Bits (* REV4 *)
  ProgLock       = true; // or false – program Lock Bits (* REV4 *)
  ProgFlash      = true; // or false – program Flash (* REV4 *)
  ProgEEprom     = FALSE; // or false – program Eeprom (* REV4 *)

Import SysTick, BeepPort, SPIdriver, FAT16; //, Ticktimer;
From System Import LongInt, longword, Float;

Define
  ProcClock      = 16000000;       {Hertz}
  SysTick        = 1, timer0;             {msec}

  StackSize      = 100, iData;
  FrameSize      = 200, iData;
  BeepPort       = PortB, 2;

  SPIorder       = MSB;
  SPImode        = 3;
  SPIpresc       = 3; // presc = 0..3 -> 4/16/64/128
  SPI_SS         = FALSE; // don’t use SS pin as chipselect

  FAT16          = MMC_SPI, iData;
  F16_MMCspeed   = slow;
  F16_FileHandles = 1;
  F16_DirLevels  = 2;


uses UFAT16;


Implementation

function ADC_AVERAGE : Float; Forward;

{$IDATA}
type

  //Dataset ist ein Datensatz der alle Daten enthält.
  Datasetrec     = Record  // 16 bytes
                     Time           : Word;
                     adc0, adc1     : Word;
                     ad1, ad2, ad3, ad4, ad5: Word;
                   end;

  Recdatarec     = Record
                     samples        : Word;
                     Scalemode      : Byte;
                     Tara           : Float;
                   end;

  FileCNT_Type   = Record     // Für die Datei auf der SD-Card, enthält die letzte Dateinummer
                     lastnumber     : Word;
                   end;


Var
  Tara           : Float;
  ADC0AVG, ADC1AVG     : Float;  // Mittelwerte aus gleitendem Filter
  adc0, adc1     : Word;
  Scalemode      : Byte;
  Waittime       : Byte;
  RECTIME        : Word;
  REC, RECSTOP   : Boolean;  // REC schaltet die Speicherung ein, RECSTOP wieder aus.
  fc             : File of FileCNT_Type;
  fd             : File of Byte;
  fcdata         : FileCNT_Type;
  rd             : Recdatarec;
  Recdata        : Recdatarec;
  Dataset        : Datasetrec;
  res            : Word;
  filecount      : Word;
  samples, scount      : Word;
  SDCardFound    : Boolean;

  SPIinUSE       : Boolean;
  LED1[@PORTC, 3]      : Bit;
  SD_CS[@PORTB, 1]     : Bit;
  ADCONV[@PORTD, 2]    : Bit;
{$IDATA}



function GetGSensorADC(ch : BYte) : Word;
var  w1, w2     : byte;
  ADCValue       : Word;
begin
  EXCL(ADCONV);
  udelay(1);
  INCL(ADCONV);
  udelay(1);  // Conversion time up to 4 µs*)
  EXCL(ADCONV);
  nop;
  nop;
  nop;

  if ch = 0 then
    w2:= SPIinoutbyte(%10000000);   // CH0
  else
    w2:= SPIinoutbyte(%11000000);   // CH1
  endif;

  w1:= SPIinpbyte; // 2. Byte abrufen
  INCL(ADCONV);    // Fertig

  lo(ADCValue):= w1;
  hi(ADCValue):= w2;
  
  return(ADCValue);
end;


function ADC_AVERAGE : Float;  // Gets channel 0 and 1 of the A/D and saves the result in ADC0AVG / ADC1AVG
begin
  SPIINUSE:= TRUE;
  ADC0:= GetGSensorADC(1);
  udelay(1);
  ADC1:= GetGSensorADC(0);
  SPIINUSE:= FALSE;

  ADC0AVG:=Float(ADC0);
  ADC1AVG:=Float(ADC1);
  return(ADC1AVG);
end;





Interrupt TIMER2COMPA;
begin
  if REC AND (RECTIME < samples) then
    excl(LED1);
    RECTIME:= RECTIME + 1;
    Dataset.Time:= RECTIME;      // Fill dataset with some dummy data
    Dataset.adc0:= adc0;
    Dataset.adc1:= adc1;
    f16_blockwrite(fd, @Dataset, sizeof(Dataset), res);  // write to SD Card
    incl(LED1);
  else
    if not SPIinUSE then
      ADC_AVERAGE;
    endif;
  endif;

end;


Procedure onFAT16_SS; // Chipselect  activator
begin
  if _ACCA = 0 then
    excl(SD_CS);
  else
    incl(SD_CS);
  endif;
end onFAT16_SS;


function OPENSDCARD : Boolean;
Var go: Boolean;
  i, Fileversion : Byte;
begin
  if not SPIinUSE then
  repeat until SPIinUSE = FALSE;
  endif;
 
 SPIinUSE:= true;

  go:= FALSE;
  beepsiren(0, 1);
  if f16_diskinit
  then
    f16_diskreset;
    if f16_checkdisk then
      f16_changedir('\');
      go:= true;
      if not f16_pathexist('\MOTOR') then
        go:= f16_createdir('\', 'MOTOR', 0, 0);
      endif;
      go:= f16_changedir('\MOTOR');

      beepout(1200, 100);
      if go then
        // Check if filecount file is there...
        if not f16_fileexist('', 'filecnt.dat', faanyfile) then
          filecount:= 0;
        else
          if F16_Fileassign(fc, '', 'filecnt.dat') then
            f16_filereset(fc);
            f16_blockread(fc, @fcdata, sizeof(fcdata), res);
            filecount:= fcdata.lastnumber + 1;
            f16_fileclose(fc);
          endif;
        endif;
        beepout(1000, 100);

        // Create a new file and write header data
        Recdata.samples:= samples;
        Recdata.Scalemode:= Scalemode;
        Recdata.Tara:= Tara;

        if F16_Fileassign(fd, '', 'F' + inttostr(filecount) + '.MOT')
        then
          go:= f16_filerewrite(fd, [faArchive], 0, 0);
          Fileversion:= 2;
          go:= f16_blockwrite(fd, @FileVERSION, 1, res);
          go:= f16_blockwrite(fd, @Recdata, sizeof(Recdata), res);   // Write header
          beepout(800, 100);

          go:= f16_blockwrite(fd, @Dataset, sizeof(Dataset), res);  // Write first dataset
          mdelay(10);
          RECTIME:= 0;
          REC:= true; // Start saving data in INterrupt
          SPIinUSE:= FALSE;
        endif;
        beepout(600, 100);

      endif;
    endif;
  endif;
  SPIinUSE   :           = FALSE;
  return(go);
end;




function CloseSDCard : Boolean;
Var go: Boolean;
  i, Fileversion : Byte;
begin
  if not SPIinUSE then
  repeat until SPIinUSE = FALSE;
  endif;

  if RECSTOP then
    SPIinUSE:= true;
    REC:= FALSE;
    RECSTOP:= FALSE;

    go:= f16_fileclose(fd);    // Close file
    // Write new filecount-file ...
    if F16_Fileassign(fc, '', 'filecnt.dat') then
      f16_filerewrite(fc, [], 0, 0);
      fcdata.lastnumber:= filecount;
      f16_blockwrite(fc, @fcdata, sizeof(fcdata), res);
      f16_fileclose(fc);
    endif;
    beepsiren(0, 3);
    RECTIME:= 0;

    SPIinUSE:= FALSE;
    return(go);
  endif;
end;





Procedure InitPorts;
begin
  PortA:= %11000000;   // 1 = Pullup!!  // Letzte 3 Bits sind Erkennung ob SD, Mini oder Micro
  DDRA:=  %00000000;   // 0= input, 1= Output

  PortB:= %00000010;   // 1 = Pullup!!
  DDRB:=  %11111111;   // 0= input, 1= Output

  PortC:= %00010000;
  DDRC:=  %11111100;

  PortD:= %00000000;
  DDRD:=  %11111111;

end InitPorts;


Procedure Init;
begin
  REC:= FALSE;
  RECTIME:= 0;
  Scalemode:= 100;
  samples:= 20000; // 10 Sekunden
  SPIinUSE:= FALSE;

  // Set all chiposelects to default values
  incl(ADCONV);
  incl(SD_CS);
  SDCardFound:= FALSE;

  if not SPIinUSE then
   repeat until SPIinUSE = FALSE;
  endif;

  // SD CARD TESTEN UND INIT
  // SDCARD testen?
  if f16_diskinit
  then
    f16_diskreset;
    mdelay(100);
    if f16_checkdisk then
     mdelay(100);
      // Jetzt Altimax-Ordner anlegen
      f16_changedir('\');
      if not f16_pathexist('\MOTOR') then
        f16_createdir('\', 'MOTOR', 0, 0);
      endif;
      f16_changedir('\MOTOR');
      SDCardFound:= true;
    endif;
  endif;

//TImer 2 starten
  disableints;
  TCCR2A:= %00000010;
  TCCR2B:= %00000101;  // 128 Prescaler
  OCR2A:= 62;   //124 = 1000 sps  62=2000 sps
  TIMSK2:= %00000010;
  EnableInts;


end;



begin
  InitPorts;
  EnableInts;
  INIT;
  beepout(1200, 10);
  
  if SDCardFound then
    opensdcard;  // Open the SD Card, create a file and start writing data
    REC:= true;
  else
    rec:=false;
    beepout(1000, 100);
  endif;
  
  loop
    if REC then 
      if (RECTIME >= samples)then
        TIMSK2:= %00000000;  // Stop Interrupt
        RECSTOP:= true;
        mdelay(100);  // Wait a bit..
        closesdcard;  // Close the sdcard! 
      endif;
    endif;


  endloop;
end test1284.