Compact Flash

[xelos]

Доброго всем.
мне необходимо сделать устройство, которое снимает показания с датчика и пишет его на CompactFlash. Для простоты, думаю воспользоваться режимом Memory Card. Проблема в том, что не совсем понятно как писать/читать карточку. Если кто программировал, может откликнется?

[mig-25]

листая страници форума вижу что много людей хотят записать на compactflash и не могут прийти к верному решению Я такой-же как и Вы. Все что есть у Вас люди пришлите мне.

[xelos]

завтра на работе прогу возьму и выложу

[xelos]

прога:
cf.h

#include ‹16F877.h›

#device adc=10
#use delay(clock=4000000)
#fuses NOWDT,HS, PUT, NOPROTECT, BROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG

#byte PORTB=6
#byte PORTC=7
#byte PORTD=8
#byte PORTE=9

#byte TRISC=0x87
#byte TRISD=0x88
#byte TRISE=0x89

#byte CF_DATA=PORTD
#byte CF_ADDR=PORTE
#byte CF_CONTROL=PORTC

// flags
#define CE1 0
#define CD2 1
#define RESET 2
#define OE 3
#define WE 4
#define RDY 5

// addresses
#define DATA_REG 0
#define ERROR_REG 1
#define FEATURES_REG 1
#define SECTOR_COUNT 2
#define SECTOR_N 3
#define CYL_LOW 4
#define CYL_HIGH 5
#define HEAD 6
#define STATUS_REG 7
#define COMMAND_REG 7

// commands
#define DIAGNOSTIC 0x90
#define IDENTIFY 0xEC
#define WRITE_BLOCK 0x30
#define READ_BLOCK 0x20

//declaration de mes variables
long locadr;   //position d'ecriture dans un secteur
int sect;      //le numero du secteur pour l'ecriture
int cylL;      //LSB du numero du cylindre pour l'ecriture
int cylH;      //MSB du numero du cylinder pour l'ecriture
char NbFiles;   //Nombre de fichiers sur la carte

//declaration de fonctions
void nop();
void compactFlashInit();
void compactFlashWait();
void compactFlashWrite(char addr, char data);
char compactFlashRead(char addr);
int CardInserted();
void write_sector();
void fin_sect();
void writeMBR();

cf.c:

#include "cf.h"


//**************************************************  ****************************
// compactFlashFlashInit
//
// Initialier la carte
//**************************************************  ****************************
void compactFlashInit()
{
   set_tris_c(0b00100010);
   set_tris_d(0);
   set_tris_e(0);

   CF_CONTROL = 0b00011000;
   CF_ADDR = 0;
   bit_set(CF_CONTROL,RESET);
   nop();
   nop();
   bit_clear(CF_CONTROL,RESET);
   delay_ms(50);

}

//**************************************************  ****************************
// nop
//
// ne rien faire pendant 1 cycle
//**************************************************  ****************************
void nop()
{
   #asm
   nop
   #endasm
}

//**************************************************  ****************************
// compactFlashFlashWait
//
// Waits for the card to finish it's operation
//**************************************************  ****************************
void compactFlashWait()
{
   while((CF_CONTROL & 1 ‹‹ RDY) == 0);
}

//**************************************************  ****************************
// compactFlashFlashWrite
//
// Ecrire un registre de CompactFlash
//**************************************************  ****************************
void compactFlashWrite(char addr, char data)
{
   CF_ADDR = addr;
   CF_DATA = data;

   compactFlashWait();

   nop();

   bit_clear(CF_CONTROL, WE);

   nop();
   nop();
   nop();

   bit_set(CF_CONTROL, WE);
}

//**************************************************  ****************************
// compactFlashFlashRead
//
// Lire un registre de CompactFlash
//**************************************************  ****************************

char compactFlashRead(char addr)
{
   char data;

   set_tris_d(0xFF);
   CF_ADDR = addr;
   CF_DATA = 0;

   compactFlashWait();
   bit_clear(CF_CONTROL, OE);
   data = CF_DATA;

   bit_set(CF_CONTROL, OE);
   set_tris_d(0);
   return data;
}
//**************************************************  ****************************
// CardInserted
//
// Verifier si la carte est inserйe
// retourne 1 si vrai, 0 si faux
//**************************************************  ****************************

int CardInserted()
{
   if (bit_test(CF_CONTROL, CD2))
   {
      return 0;
   }
   else
   {
      return 1;
   }
}


//**************************************************  ****************************
// write_sector
//
// initialise l'ecriture sur un secteur, active le timeur
//**************************************************  ****************************

void write_sector()
{
     NbFiles++;
     writeMBR();                       //ecrire le sector 0
     compactFlashWrite(HEAD,224);      //1 def 1 LBA 1 def 0 0000 LBA 27-24 - selectionner mode LBA
     compactFlashWrite(CYL_HIGH,cylH);    //LBA 23-16
     compactFlashWrite(CYL_LOW,cylL);     //LBA 15-8
     compactFlashWrite(SECTOR_N,sect);    //LBA 7-0
     compactFlashWrite(SECTOR_COUNT,1); //Le nombre de secteurs а ecrire
     compactFlashWrite(COMMAND_REG,WRITE_BLOCK); //Commande а ecrire
     locadr=0;

//ecrire "start" au debut du secteur
     compactFlashWrite(DATA_REG,115);
     compactFlashWrite(DATA_REG,116);
     compactFlashWrite(DATA_REG,97);
     compactFlashWrite(DATA_REG,114);
     compactFlashWrite(DATA_REG,116);

     locadr=locadr+5;

//remplir le secteur par 250
     while (locadr‹512)
     {
         compactFlashWrite(DATA_REG,250);
         locadr=locadr+1;
     }

//enregistrer le nouveau secteur avec l'identification "end" a la fin
      locadr=0;
      sect=sect+1;
      if (sect›255)
      {
         cylL=cylL+1;
         sect=0;
      }
      if (cylL›255)
      {
         cylL=0;
         cylH=cylH+1;
      }
     compactFlashWrite(HEAD,224);      //1 def 1 LBA 1 def 0 0000 LBA 27-24 - selectionner mode LBA
     compactFlashWrite(CYL_HIGH,cylH);    //LBA 23-16
     compactFlashWrite(CYL_LOW,cylL);     //LBA 15-8
     compactFlashWrite(SECTOR_N,sect);    //LBA 7-0
     compactFlashWrite(SECTOR_COUNT,1); //Le nombre de secteurs а ecrire
     compactFlashWrite(COMMAND_REG,WRITE_BLOCK); //Commande а ecrire

     enable_interrupts(INT_RTCC);
}

//**************************************************  ****************************
// fin secteur
//
// finalize l'ecriture sur le secteur
//**************************************************  ****************************
void fin_sect()
{

     disable_interrupts(INT_RTCC);

//remplir le secteur en cours par 251 jusqu'а la fin
     while (locadr‹512)
     {
         compactFlashWrite(DATA_REG,251);
         locadr=locadr+1;
     }

//enregistrer le nouveau secteur avec l'identification "end" a la fin
      locadr=0;
      sect=sect+1;
      if (sect›255)
      {
         cylL=cylL+1;
         sect=0;
      }
      if (cylL›255)
      {
         cylL=0;
         cylH=cylH+1;
      }
     compactFlashWrite(HEAD,224);      //1 def 1 LBA 1 def 0 0000 LBA 27-24 - selectionner mode LBA
     compactFlashWrite(CYL_HIGH,cylH);    //LBA 23-16
     compactFlashWrite(CYL_LOW,cylL);     //LBA 15-8
     compactFlashWrite(SECTOR_N,sect);    //LBA 7-0
     compactFlashWrite(SECTOR_COUNT,1); //Le nombre de secteurs а ecrire
     compactFlashWrite(COMMAND_REG,WRITE_BLOCK); //Commande а ecrire

//ecrire "end" au debut du secteur
     compactFlashWrite(DATA_REG,101);
     compactFlashWrite(DATA_REG,110);
     compactFlashWrite(DATA_REG,100);
     locadr=locadr+3;

//remplir le secteur par 1 et 251
     while (locadr‹512)
     {
         compactFlashWrite(DATA_REG,251);
         locadr=locadr+1;
     }

      locadr=0;
      sect=sect+1;
      if (sect›255)
      {
         cylL=cylL+1;
         sect=0;
      }
      if (cylL›255)
      {
         cylL=0;
         cylH=cylH+1;
      }
     compactFlashWrite(HEAD,224);      //1 def 1 LBA 1 def 0 0000 LBA 27-24 - selectionner mode LBA
     compactFlashWrite(CYL_HIGH,cylH);    //LBA 23-16
     compactFlashWrite(CYL_LOW,cylL);     //LBA 15-8
     compactFlashWrite(SECTOR_N,sect);    //LBA 7-0
     compactFlashWrite(SECTOR_COUNT,1); //Le nombre de secteurs а ecrire
     compactFlashWrite(COMMAND_REG,WRITE_BLOCK); //Commande а ecrire


}

//**************************************************  ****************************
// rb_int
//
// Bouton appuyй
//**************************************************  ****************************

#INT_RB
void rb_int()
{
      //tester si le bouton est rb4
      if (!bit_test(PORTB,4))
      {
         bit_clear(PORTB,0);
         write_sector();
      }
      //tester si le bouton est rb5
      if (!bit_test(PORTB,5))
      {
         bit_set(PORTB,0);
         fin_sect();
      }
}

//**************************************************  ****************************
// tm0_int
//
// Interruption timeur
//**************************************************  ****************************
#INT_RTCC
void tm0_int()
{
   long b;
   disable_interrupts(GLOBAL);

   delay_us(32);

   b=read_adc();
   compactFlashWrite(DATA_REG,make8(b,1));

   compactFlashWrite(DATA_REG,make8(b,0));

   locadr=locadr+2;
   if (locadr›512)
   {
      locadr=0;
      sect=sect+1;
      if (sect›255)
      {
         cylL=cylL+1;
         sect=0;
      }
      if (cylL›255)
      {
         cylL=0;
         cylH=cylH+1;
      }
     compactFlashWrite(HEAD,224);      //1 def 1 LBA 1 def 0 0000 LBA 27-24 - selectionner mode LBA
     compactFlashWrite(CYL_HIGH,cylH);    //LBA 23-16
     compactFlashWrite(CYL_LOW,cylL);     //LBA 15-8
     compactFlashWrite(SECTOR_N,sect);    //LBA 7-0
     compactFlashWrite(SECTOR_COUNT,1); //Le nombre de secteurs а ecrire
     compactFlashWrite(COMMAND_REG,WRITE_BLOCK); //Commande а ecrire

   }
   set_timer0(99);
   enable_interrupts(GLOBAL);
}
//**************************************************  ****************************
// writeMBR
//
// Ecrire le premier secteur de la carte
//**************************************************  ****************************

void writeMBR()
{
     

     compactFlashWrite(HEAD,224);      //1 def 1 LBA 1 def 0 0000 LBA 27-24 - selectionner mode LBA
     compactFlashWrite(CYL_HIGH,0);    //LBA 23-16
     compactFlashWrite(CYL_LOW,0);     //LBA 15-8
     compactFlashWrite(SECTOR_N,0);    //LBA 7-0
     compactFlashWrite(SECTOR_COUNT,1); //Le nombre de secteurs а ecrire
     compactFlashWrite(COMMAND_REG,WRITE_BLOCK); //Commande а ecrire

     locadr=7;

     compactFlashWrite(DATA_REG,67);
     compactFlashWrite(DATA_REG,70);
     compactFlashWrite(DATA_REG,70);
     compactFlashWrite(DATA_REG,65);
     compactFlashWrite(DATA_REG,84);
     compactFlashWrite(DATA_REG,67);
     compactFlashWrite(DATA_REG,NbFiles);
     
     while (locadr‹512)
     {
         compactFlashWrite(DATA_REG,250);
         locadr++;
     }
     locadr=0;
     
}
void main()
{

   setup_adc_ports(ALL_ANALOG);
   setup_adc(ADC_CLOCK_INTERNAL);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128);

   sect=1;
   cylL=0;
   cylH=0;
   NbFiles=0;

   set_adc_channel(2);

   set_tris_b(0b11110000);
   PORTB=0xff;
   bit_clear(PORTB,1);

   set_tris_c(0x00);
   output_c(0xff);

   while (!CardInserted())
   {
   }

   bit_clear(PORTB,2);

   compactFlashInit();

   enable_interrupts(global);
   enable_interrupts(int_rb);

   while (true)
   {
      if(CardInserted())
      {
         bit_clear(PORTB,2);
         enable_interrupts(global);
      }
      else
      {
         bit_set(PORTB,2);
         disable_interrupts(global);
      };
   }

}

[IwanTorch]

Вы хоть скажите, что за прога это?

[xelos]

читаем АЦП и пишем на карточку значения в "файлы".
названия линий типа "COMMAND_REG" - из спецификации компактфлэша. Схемка не влезла в аттач.
Подробно расписывать нет времени - там целую статью можно написать. Кстати, схему я брал из статьи, которая по CF в инете валяется.

[IwanTorch]

Вот блин ктоб хоть намекнул, что там за интерфейс? Какой порядок записи чтения, а остальное не проблема, недельку вторую усё получится.

[xelos]

у CF возможно несколько режимов работы. Самый экономичный (с точки зрения расхода ног мк) - True Memory Mode.
Все операции ведутся через несколько регистров управления:

//адреса регистров
#define DATA_REG 0 
#define ERROR_REG 1 
#define FEATURES_REG 1 
#define SECTOR_COUNT 2 
#define SECTOR_N 3 
#define CYL_LOW 4 
#define CYL_HIGH 5 
#define HEAD 6 
#define STATUS_REG 7 
#define COMMAND_REG 7

адресация для записи/чтения как в хардах - C/H/S и блоками
чтобы записать данные в регистр:

void compactFlashWrite(char addr, char data) 
{ 
   CF_ADDR = addr; 
   CF_DATA = data; 

   compactFlashWait(); 

   nop(); 

   bit_clear(CF_CONTROL, WE); 

   nop(); 
   nop(); 
   nop(); 

   bit_set(CF_CONTROL, WE); 
}

выставляешь на шину адреса/данных нужные значения, в ноль сбрасываешь WE бит на шине, выждав паузу в 1 WE.
чтение регистров аналогично.

чтобы записать данные в память:

     compactFlashWrite(HEAD,224);      //1 def 1 LBA 1 def 0 0000 LBA 27-24 - выбрать режим LBA 
     compactFlashWrite(CYL_HIGH,0);    //LBA 23-16 
     compactFlashWrite(CYL_LOW,0);     //LBA 15-8 
     compactFlashWrite(SECTOR_N,0);    //LBA 7-0 
     compactFlashWrite(SECTOR_COUNT,1); //количество секторов 
     compactFlashWrite(COMMAND_REG,WRITE_BLOCK);//команда на запись блока
     compactFlashWrite(DATA_REG,67); //запись данных
     compactFlashWrite(DATA_REG,70);

устанавливаешь head/sector/cylinder, количество секторов для записи, команду на запись и вперед - писать данные. Только не забывать, что пишется посекторно - т.е. сначала заполняется буфер сектора и только потом пишется в CF. Пока буфер не заполнен - никакой записи в CF не будет!

[IwanTorch]

Воо дельный ответ. Спасибо большое.