Sonsivri
 
*
Welcome, Guest. Please login or register.
Did you miss your activation email?
December 03, 2016, 10:34:27 10:34


Login with username, password and session length


Pages: [1]
Print
Author Topic: Interfacing MMC card with micrcontroller  (Read 4899 times)
0 Members and 1 Guest are viewing this topic.
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« on: September 03, 2007, 06:32:57 06:32 »

I am trying to design a voice recorder which uses AVR 8535 microcontroller,which compresses the voice data after A/D conversion,i have implemented speech compression ( ADPCM speech compression & Decompression ) with AVR however i am finding it difficult to interface MMC card
 Has any one interface MMC card with micrcontroller in spi mode 
Logged

regards
m.yasir
otter
V.I.P
Junior Member
*****
Offline Offline

Posts: 56

Thank You
-Given: 195
-Receive: 2


« Reply #1 on: September 04, 2007, 01:03:43 01:03 »

Yes, we used a small ARM, but it should work on an AVR just as well. I don't remember there being any problems, but it was a while ago. What problems are you having?
Regards
Otter
Logged
freddy
Newbie
*
 Muted
Offline Offline

Posts: 15

Thank You
-Given: 0
-Receive: 7


« Reply #2 on: September 04, 2007, 07:26:47 07:26 »

I am trying to design a voice recorder which uses AVR 8535 microcontroller,which compresses the voice data after A/D conversion,i have implemented speech compression ( ADPCM speech compression & Decompression ) with AVR however i am finding it difficult to interface MMC card
 Has any one interface MMC card with micrcontroller in spi mode 

You can found an application here: http://butterflymp3.sourceforge.net/
Logged
FaithNoMore
Translator
Junior Member
***
Offline Offline

Posts: 57

Thank You
-Given: 16
-Receive: 91



« Reply #3 on: September 04, 2007, 08:49:49 08:49 »

Yasir, I posted SD/MMC and CFlash 12/16 FAT File-System for AVR (CV, IAR, ICC)
here@ http://www.sonsivri.com/forum/index.php?topic=4226.0
Logged
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #4 on: September 06, 2007, 06:36:28 06:36 »

i have implemented ADPCM successfully,the problem i am having with MMC card interfacing is that
when i try to record compressed voice data on MMC card,the voice upon retrieval from the card at PC end gives a jerk after 2-3 seconds of voice play back
may be this jerk is due to sector change ,every sector comprises 512 bytes

What i am trying to design is, the ATmega8535 takes analog input data ,performs A/D conversion ,which generates 10-bit data samples at rate of 8KHz ,these data samples are then subjected to ADPCM speech compression which generates 4 bit compressed data sample from 16-bit data sample ,then it takes other uncompressed data sample and compresses it to 4-bit ADPCM compressed data sample
These two data samples are then packed in a single byte,this byte containing two ADPCM data sample is then 
written to MMC card.This is recording process
once we are done with recording ,we need to retrieve the data , For retrieval the Micrcontroller reads compressed voice data from MMC sector by sector and transmits it to PC through serial port
which is recorded on pc in binary file
this binary file is decompressed using Turbo C and then decompressed and converted to wave file through VC++ code

Logged

regards
m.yasir
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #5 on: September 26, 2007, 05:41:01 05:41 »

i have done it,there problem was due integrating speech compression algorithm in mmc read and write routine

i have implemented it without speech compression now and it is working fine

i would integrate speech compression algorithm in it

thanks to all for referring to links
Logged

regards
m.yasir
FaithNoMore
Translator
Junior Member
***
Offline Offline

Posts: 57

Thank You
-Given: 16
-Receive: 91



« Reply #6 on: September 26, 2007, 02:51:45 14:51 »

Glad you've found the problem yasir.
If you have time could you post your project here, I think many of us are interested.  Wink 
Logged
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #7 on: September 28, 2007, 08:25:23 08:25 »

ok i would

for reminder my email address is :


yasir9909@yahoo.com
Logged

regards
m.yasir
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #8 on: September 29, 2007, 05:16:00 17:16 »

here is the code for writing and reading a single sector

CODE for ATmega8535


#include <iom8535v.h>
#include <macros.h>

#define SPIDDR     DDRB
#define SPIPORT   PORTB
#define SPIPIN      PINB
#define CS           0x10


#define BinToASCII(t)((t<=9) ? (t|0x30):(t+55))
#define ASCIIToBin(t) ((t>='A'&& t<='F')?t-55:((t>='0' && t<='9') ? t-'0':0))

#define BYTELOW(v)  (*((unsigned char *) (&v)))
#define BYTEHIGH(v)   (*(((unsigned char *) (&v) + 1)))

#define BLOCK_SIZE   512   

const unsigned char   CMD0_RST_IDLE[]  ={0x40,0x00,0x00,0x00,0x00,0x95};
                                     //command 0 reset all card to idle state   
const unsigned char   CMD1_SND_OPCND[]={0x41,0x00,0x00,0x00,0x00,0xFF};
                                    //command 1 for read OPERATION CONDITION register  const unsigned char CMD16_SET_BLOCKLEN[]={0x50,0x00,0x00,0x02,0x00,0xFF};
                                 //command 16 TO SET BLOCK LENGHT=512 BYTE TO READ & WRITE
                                             //0x000200=512 & 0x00000010=16
const unsigned char   MSGF[]   ={"\rMMC CARD INTERFACE \r"};
const unsigned char   MSG0[]   ={"\rMMC CARD COMMAND 0 \r"};
const unsigned char   MSG1[]   ={"\rMMC CARD COMMAND 1 \r"};
const unsigned char   MSGB[]   ={"\rMMC CARD COMMAND BLOCK=512 \r"};
const unsigned char   MSGW[]   ={"\rMMC CARD SECTOR WRITE     \r"};
const unsigned char   MSGR[]   ={"\rMMC CARD SECTOR READ     \r"};
const unsigned char   MSG[]   ={"\nMMC CARD IS INITIALIZED SPI MODE  \n"};
const unsigned char   CSD[]   ={"\rCSD INFORMATION: \r"};   
const unsigned char   CID[]   ={"\rCID INFORMATION: \r"};
const unsigned char   WACK[]   ={"\rWRITE ACKNOLEDGE: \r"};
const unsigned char   WNFSH[]   ={"\rWRITE NOT FINISH: \r"};

unsigned char TEMP;
unsigned int iSIZE;
unsigned int iSIZE1;
unsigned char BUFFER[128];

//ICC-AVR application builder : 29/09/2005 16:23:49
// Target : M32  Crystal: 11.0592Mhz

void port_init(void)
{
  PORTA = 0x00;
  DDRA  = 0x00;
  PORTB = 0xFF;
  DDRB  = 0xFF;
  PORTC = 0x00;
  DDRC  = 0x00;
  PORTD = 0x00;
  DDRD  = 0x02;
}

//UART0 initialize
// desired baud rate: 57600
/* ************************************************************************ *\
  In the ATmega32, the UBRRL & UBRRH registers must be written separately.
  It is not possible to use the following construct:
  UBRR = BAUD_RATE_REGISTER_VALUE;
  as UBRRL & UBRRH are not in adjacent locations. See ATmega32 data sheet.
\* ************************************************************************ */

void uart0_init(void)
{
 UCSRB = 0x00; //disable while setting baud rate
 UCSRA = 0x00;
 UCSRC = BIT(URSEL) | 0x06;
// UBRRL = 7; //set baud rate lo @ 11.0592 MHZ
 UBRRL = 11; //set baud rate lo @ 14.7456 MHZ
 UBRRH = 0x00; //set baud rate hi
 UCSRB = 0x18;
}
//call this routine to initialize all peripherals
void init_devices(void)
{
  port_init();
  uart0_init();
  MCUCR = 0x00;
  GICR  = 0x00;
  TIMSK = 0x00;
}

/*
unsigned char ReceiveByte(void)
{
  while(!(UCSRA & BIT(RXC)))   ;
    return UDR;
}*/

void SEND_CHAR_UART(char ch)
{
  while(!(UCSRA & BIT(UDRE))) ;
  UDR = ch;
}

void SendStr(const char *ch)
{     while(*ch != 0x00) SEND_CHAR_UART(*ch++);}
/*------------------------------------*/
void PRINT_ASCII (unsigned char PRNT)
{
   unsigned char PRN=0;

      PRN=PRNT>>4;
      SEND_CHAR_UART(BinToASCII(PRN)); 

      PRN=PRNT&0x0F;
      SEND_CHAR_UART(BinToASCII(PRN));      

    
}
void SpiInit()
{
    DDRB  |= 0xB0;  // Set SCK, MOSI & SS as outputs
    PORTB &= 0x5F;  // clear bits MOSI, & SCK
    SPCR = 0x53;
}

/***  SpiWriteByte() writes a byte to the SPI and waits until  it has been transmitted.
This function doesn't  return any value back.**/
unsigned char CHAR_SPI(unsigned char byte)

{
    SPDR = byte;
    while (!(SPSR & 0x80));
    byte = SPDR;
return byte;   
}
//**************************************
// void Delay_1ms(void)
//**************************************
void Delay_1ms(int Del)
{
int i;
while (Del--)
     {     for (i=0;i<200;i++) WDR();     }
}

 
/*-------------------------------------------------------------  */
//--------------------------------------------
//      MMC GET RESPONSE
//--------------------------------------------
unsigned char MMC_RESPONCE(unsigned char RESPONSE )
{
      unsigned int COUNT=0xFFFF;
       unsigned  char  RESULT;

      while(COUNT!=0)
        {
            RESULT = CHAR_SPI(0xFF);
          
   // PRINT_ASCII (RESULT);    SEND_CHAR_UART('\r');   //debug

          if(RESULT==RESPONSE)
            {    break;}

          COUNT--;
         }

      if(COUNT==0)return 1;
           else   
       return 0;
   
  }
/**********************************/ 
unsigned char MMC_WAIT_FOR_WRITE_FINISH( void )
{
         unsigned char LPCNT=0xFF;
       unsigned char  RESULT = 0;
      
       /* The delay is set to maximum considering the longest data block length to handle */
         while( (RESULT == 0) && LPCNT )
              { RESULT = CHAR_SPI( 0XFF);
               LPCNT--;
              }
         
         if (LPCNT== 0 )
              return 1;                    /* Failure, loop was exited due to timeout */
           else return 0;         /* Normal, loop was exited before timeout */
}
/*--------------------------------------------------------*/ 
unsigned char  MMC_INIT()
{
//unsigned int i;
 
unsigned char LPCNT=0;

       /* start off with 80 bits of high data with card deselected */
      SPIPORT |=CS;
       for(LPCNT=0;LPCNT<10; LPCNT++)
       CHAR_SPI(0xff);
/*-----------------------------------------CMD 0------------------------------------------------*/      
       SPIPORT &= ~CS;        /* select card */
      
       CHAR_SPI( 0X40);   CHAR_SPI( 0X00);     CHAR_SPI( 0X00);
       CHAR_SPI( 0X00);   CHAR_SPI( 0X00);     CHAR_SPI( 0X95);
      
           if( (MMC_RESPONCE(0x01)) == 1 )
                {
                        SPIPORT |=CS;
                              return 1;
                              }
SendStr( MSG0);
/*----------------------------------------------------------------------------------------------------*/

     SPIPORT |= CS;
    CHAR_SPI(0xFF);
/*-------------------------------------CMD1---------------------------------------------------------*/

     SPIPORT &= ~CS;   
     LPCNT=0xFF;
      do
      {
          CHAR_SPI( 0X41);   CHAR_SPI( 0X00);     CHAR_SPI( 0X00);
           CHAR_SPI( 0X00);   CHAR_SPI( 0X00);     CHAR_SPI( 0XFF);
      
      LPCNT--;
      } while ( (MMC_RESPONCE(0x00) != 0) && (LPCNT>0) );

      if(LPCNT==0)
        {     SPIPORT |= CS;       return 1;   }
         
SendStr( MSG1);      
/*--------------------------------------------------------------------*/

     SPIPORT |= CS;
    CHAR_SPI(0xFF);
/*---------------------------------------CMD16  SET BLOCK LENGTH--------------------------*/    

       SPIPORT &= ~CS;        /* select card */
      
       CHAR_SPI( 0X50);   CHAR_SPI( 0X00);     CHAR_SPI( 0X00);
       CHAR_SPI( 0X02);   CHAR_SPI( 0X00);     CHAR_SPI( 0XFF);
      
           if( (MMC_RESPONCE(0x00)) == 1 )
                {
                        SPIPORT |=CS;
                              return 1;
                              }
SendStr( MSGB);
/*----------------------------------------------------------------------------------------------------*/
SPIPORT |= CS;
 CHAR_SPI(0xFF);
return 0;
}   
/*------------------------------------------------------------*/
//unsigned char  MMC_WRITE_BLOCK( unsigned  long SECTOR)
/*----------------------------------------------------------- */

void GET_CSD()
{
 SPIPORT &= ~CS; 
       CHAR_SPI( 0x49);   CHAR_SPI( 0x00);     CHAR_SPI( 0X00);
       CHAR_SPI( 0x00);   CHAR_SPI( 0x00);     CHAR_SPI( 0XFF);

       while ((MMC_RESPONCE(0x00)) == 1);

       while( (MMC_RESPONCE(0xFE)) == 1 );

      for(TEMP=0;TEMP<=35;TEMP++)
           BUFFER[TEMP]=CHAR_SPI(0xFF);

SendStr(CSD);

      for(TEMP=0;TEMP<=15;TEMP++)
          PRINT_ASCII(BUFFER[TEMP]);
         
       
SEND_CHAR_UART('\n');
SPIPORT |= CS;       // Deselect card
}
/*------------------------------------------------------------*/
//void GET_CID()
/*----------------------------------------------------------- */
void GET_CID()
{
SPIPORT &= ~CS;       // select card
       CHAR_SPI( 0x4A);   CHAR_SPI( 0x00);     CHAR_SPI( 0X00);
       CHAR_SPI( 0x00);   CHAR_SPI( 0x00);     CHAR_SPI( 0XFF);

       while ((MMC_RESPONCE(0x00)) == 1);
      while( (MMC_RESPONCE(0xFE)) == 1 );

      for(TEMP=0;TEMP<=35;TEMP++)
           BUFFER[TEMP]=CHAR_SPI(0xFF);
          
         
SendStr(CID);

      for(TEMP=0;TEMP<=15;TEMP++)
          PRINT_ASCII(BUFFER[TEMP]);
       
SEND_CHAR_UART('\n');
SPIPORT |= CS;       // Deselect card
}
/*----------------------------------------------------*/
void INSULATOR()
{ CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
  CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);   
  CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
  CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);       
}

/*--------------------------------------------------------------------------------------*/
unsigned char  MMC_READ_BLOCK( unsigned   long SECTOR)
{

unsigned char LPCNT=0;
unsigned char LTMP=0;
unsigned long ADDRESS=0;
ADDRESS=SECTOR*BLOCK_SIZE;
 
      
/*-----------------------CMD17------------------------------------------------*/      
       SPIPORT &= ~CS;
      
       CHAR_SPI( 0x51);
       CHAR_SPI (ADDRESS>>24);        CHAR_SPI (ADDRESS>>16);
       CHAR_SPI (ADDRESS>>Cool;         CHAR_SPI (ADDRESS>>0);     
       CHAR_SPI( 0xFF);

           if( (MMC_RESPONCE(0x00)) == 1 )
                {  SPIPORT |= CS;
                  return 1;
                  }
             while( (MMC_RESPONCE(0xFE)) == 1 )
                                SEND_CHAR_UART('r');
                              
                              

for(LTMP=0;LTMP<4;LTMP++)
{
      for(LPCNT=0;LPCNT<128; LPCNT++)
           BUFFER[LPCNT]=CHAR_SPI(0xFF);   
      for(LPCNT=0;LPCNT<128; LPCNT++)
      {
         if((LPCNT%16)==0)SEND_CHAR_UART('\r');
         //PRINT_ASCII(BUFFER[LPCNT]);
         SEND_CHAR_UART(BUFFER[LPCNT]);
           }
   }       
          
          
          

            CHAR_SPI(0xFF);  CHAR_SPI(0xFF);  //rwad CHKSUM
SendStr( MSGR);
/*----------------------------------------------------------------------------*/
 SPIPORT |= CS;
 CHAR_SPI(0xFF); 
return 0;
}                      

/*--------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------*/
unsigned char  MMC_WRITE_BLOCK( unsigned   int SECTOR,unsigned char WRT)
{
unsigned char LPCNT=0;
unsigned long ADDRESS=0;
ADDRESS=SECTOR*BLOCK_SIZE;
 
      
/*-----------------------CMD24------------------------------------------------*/      
       SPIPORT &= ~CS;
      
       CHAR_SPI( 0x58);
       CHAR_SPI (ADDRESS>>24);        CHAR_SPI (ADDRESS>>16);
       CHAR_SPI (ADDRESS>>Cool;         CHAR_SPI (ADDRESS>>0);     
       CHAR_SPI( 0xFF);

      
           if( (MMC_RESPONCE(0x00)) == 1 )
                {
                        SPIPORT |=CS;
                              return 1;
                           }
         CHAR_SPI(0xFF);
         CHAR_SPI(0xFE);                //start of DATABLOCK

             for(LPCNT=0;LPCNT<128; LPCNT++)CHAR_SPI(WRT);
             for(LPCNT=0;LPCNT<128; LPCNT++)CHAR_SPI(WRT+1);
             for(LPCNT=0;LPCNT<128; LPCNT++)CHAR_SPI(WRT+2);
             for(LPCNT=0;LPCNT<128; LPCNT++)CHAR_SPI(WRT+3);         
         
         CHAR_SPI(0xFF); CHAR_SPI(0xFF);   // dummy chksum
         
         
       LPCNT= CHAR_SPI(0xFF);
SendStr(WACK);   PRINT_ASCII(LPCNT);   PRINT_ASCII((LPCNT & 0x0F));
        if ( (LPCNT & 0x0F) != 0x05 )
          {
                  SPIPORT |=CS;
                  return 1;
            }
            
                   if( MMC_WAIT_FOR_WRITE_FINISH()==1)
                {
               SendStr(WNFSH);
                                SPIPORT |=CS;
                              return 1;
                            }
SendStr( MSGW);
/*----------------------------------------------------------------------------------------------------*/
SPIPORT |= CS;
 CHAR_SPI(0xFF); 
return 0;
}   
       
/* ************************************************************************ *\
  Function: 'main()'.
\* ************************************************************************ */

void main(void)
{

  init_devices();                      // set the baudrate to 19,200 bps using a 14.7456MHz crystal.
  SpiInit();
SendStr( MSGF);                         // Transmit welcome message.
while ( MMC_INIT() != 0)
SendStr( MSG);INSULATOR();
 
/*------------------------*/
SPCR  = 0x50;SPSR  |=0x01;
/*------------------------*/
GET_CSD();          INSULATOR();
GET_CID();        INSULATOR();

MMC_WRITE_BLOCK(101,0x45);INSULATOR();;
MMC_READ_BLOCK(101);INSULATOR();

MMC_WRITE_BLOCK(100,0x54);INSULATOR();
MMC_READ_BLOCK(100);INSULATOR();

/*-------------------------------------------------*/
 

 
 while (1)                            // Now do this forever.
    {
     CHAR_SPI(0x55);;
    }
 
}



 
Logged

regards
m.yasir
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #9 on: September 29, 2007, 05:18:49 17:18 »

This is a prototype code for writing and reading a single sector you can simulate and run this code in proteus


i would send you the other code later which i have used for mmc card based voice recording and play back system
Logged

regards
m.yasir
Trishool
V.I.P
Active Member
*****
Offline Offline

Posts: 112

Thank You
-Given: 9
-Receive: 9



« Reply #10 on: September 29, 2007, 05:32:55 17:32 »

Hi, My 2 cents, If you could search 8052.com you will get loads of info on the subject.

Rgds
Ts
Logged
lory19
Guest
« Reply #11 on: December 17, 2007, 04:01:39 16:01 »

Hi !
I ,m new here i have some interest I looking how write data in mmc card
from analog device 0-to 5v
but I don,t know nothing about C
Regards !
Lory
Logged
zokij
Senior Member
****
Offline Offline

Posts: 330

Thank You
-Given: 196
-Receive: 617


Nice time :)


« Reply #12 on: December 18, 2007, 09:58:24 09:58 »

MMC/SD Board

MMC/SD board scheme [30KB] http://www.mikroe.com/pdf/mmc-sd_board_schematic.pdf
Examples [1.21MB]  http://www.mikroe.com/zip/mmc-sd_board_examples.zip

or

Compact Flash Board

Compact Flash board scheme[50KB]  http://www.mikroe.com/pdf/cf_board_schematic.pdf
Examples [1.0MB]  http://www.mikroe.com/zip/cf_board_examples.zip

 Roll Eyes Nice time  Wink
Logged
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #13 on: January 17, 2008, 05:25:48 05:25 »

what type of analog device you are interested in
i have implemented a voice recording system which takes data from mic and writes it to MMC card after converting it to digital format using analog to digital converter

what you have to do is to use an analog to digital converter ,which would take analog input data from your analog device like mic,temperature sensor etc.
this digital data is then tansferred to the microcontroller which would write it on MMC card which can be  subsequently read on user demand from  MMC using the same microcontroller

Posted on: January 14, 2008, 06:12:43 06:12 - Automerged

i don't know how to upload pic or image file on this post,other wise i would also post the schematic diagram of the circuit for the above code in Proteus

the above code is also implementable in Preteus
Logged

regards
m.yasir
ABBOSE
Junior Member
**
Offline Offline

Posts: 46

Thank You
-Given: 25
-Receive: 21


« Reply #14 on: January 17, 2008, 07:09:18 07:09 »

To interface flash memory with PIC , please see the topics
http://www.sonsivri.com/forum/index.php?topic=5531.0
Logged
nine9
Guest
« Reply #15 on: January 21, 2008, 09:00:37 21:00 »

Here is a simple solution for connecting a MMC/SD for AVR:
http://translate.google.com/translate?u=http%3A%2F%2Fwww.ulrichradig.de%2Fhome%2Findex.php%2Favr%2Fmmc-sd&langpair=de%7Cen&hl=en&ie=UTF8
Logged
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #16 on: January 25, 2008, 10:48:28 10:48 »


The schematic diagram of the above mentioned code,drawn and implemented in proteus,can be down loaded from the following link for rapidshare

Download-Link #1: http://rapidshare.com/files/86452033/mmc.bmp.html


replace the smiley symbol in the above mentioned code with 8
Logged

regards
m.yasir
lacsicz
Guest
« Reply #17 on: January 26, 2008, 12:52:37 00:52 »

Just two quick questions to add here:
I've seen that most schematics use resistors for voltage dividing 1.8k and 3.3k. How safe is it for the sd/mmc shouldn't they be grater values?

How big could be a SD/MMC? is it safe to use 512MB or 1GB versions? and could they be formatted in a cardreader if something fails?
Logged
yasir9909
Active Member
***
Offline Offline

Posts: 153

Thank You
-Given: 7
-Receive: 107


« Reply #18 on: February 01, 2008, 07:43:30 07:43 »

yup in most of the schematics you would see a voltage divider network of 6 resitors 3x1.8k and 3x3.3 k for finding answer to this particular question you need to consult data sheet of mmc i would reply you on this question later

well ,as far as my knowledge is concerned,so far i have seen  mmc and mciro sd cards of capacity upto 2GBs,what do you mean by safe here

both sd and mmc cards can be formated in your mobile as well as by your PC (by using mmc to usb converter )

regards
m.yasir


Posted on: January 28, 2008, 05:30:38 05:30 - Automerged

Logged

regards
m.yasir
fagari
Junior Member
**
Offline Offline

Posts: 35

Thank You
-Given: 3
-Receive: 41


« Reply #19 on: February 02, 2008, 12:35:37 12:35 »

look at another example

http://www.sonsivri.com/forum/index.php?topic=6658.0
Logged
neer4evr
Guest
« Reply #20 on: February 13, 2008, 03:12:55 15:12 »

hey did anyone checkout proteus 7.2 sp2 it has a sample design for MMC card as a USB mass storage device. It is quite cool.
Logged
billy48
Guest
« Reply #21 on: March 04, 2008, 05:32:18 05:32 »

Does anyone try to interface MMC with LPC2138?
Logged
supoj
Inactive

Offline Offline

Posts: 6

Thank You
-Given: 14
-Receive: 1


« Reply #22 on: March 14, 2008, 12:37:21 12:37 »

http://www.mikroe.com/en/compilers/   
mikroBasic for AVR  Work but support Fat16
Logged
Pages: [1]
Print
Jump to:  


DISCLAIMER
WE DONT HOST ANY ILLEGAL FILES ON THE SERVER
USE CONTACT US TO REPORT ILLEGAL FILES
ADMINISTRATORS CANNOT BE HELD RESPONSIBLE FOR USERS POSTS AND LINKS

... Copyright 2003-2999 Sonsivri.to ...
Powered by SMF 1.1.18 | SMF © 2006-2009, Simple Machines LLC | HarzeM Dilber MC