////////////////////////////////////////////////////////////////////////////////////////////
MMC_SD.C
////////////////////////////////////////////////////////////////////////////////////////////

Chip type           : ATmega8
Program type        : Application
Clock frequency     : 10,000000 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size     : 256
*********************************************/

#include <mega8.h>
#include <stdio.h>
#include <ctype.h>	//character
#include "c:\\Programm\\mmc.c" //Implementierung des mmc.c files(Ausprogrammierte Funktionen)
// Declare your global variables here

void main(void)
{  
	char Buffer[512];
	long addr = 0;
	char tmp = 0;		//Prüfung des Rückgabewertes
	int x;			//Zähler for-schleife
	//Initialisierung der MMC/SD-Karte
	char Timeout = 0;
	char a = 1;
	
	PORTD = 0xFF;
	DDRD = 0x0;
		
	while(PIND.4);				//Wartet bis PIND.4 gedrückt worden ist
	
		
	
	while (a !=0) /*ist der Rückgabewert ungleich NULL ist ein Fehler aufgetreten
					MMC/SD-Karte wird dann neu Initialisiert*/
	{
		a = Init_MMC();/*	
		Timeout++;
		if (Timeout == 20)
		{
//ERRORLED
		       	break;
		}                */
	}
	
PORTB.0=1;
	
	//Initialisierung der MMC/SD-Karte 
        //Erzeugt ein  Array von 512 Bytes mit dem Inhalt EEhex
	for(x=0; x<512; x++)
	{
		Buffer[x] = 0xEE;
	}


	//schreibt Array in den ersten Blocks der MMC/SD Karte (addr = 0)
	tmp = Write_Block_MMC (addr,Buffer);
	if (tmp != 0) //ist der Rückgabewert ungleich NULL ist ein Fehler aufgetreten 
	{
//ERRORLED			
	}	
        

	//auslesen des zweiten Blocks von der MMC/SD Karte (addr = 1)
	addr = 1;
	tmp = Read_Block_MMC (addr,Buffer);
	if (tmp != 0) //ist der Rückgabewert ungleich NULL ist ein Fehler aufgetreten 
	{
//ERRORLED
	}
	

	//auslesen des ersten Blocks von der MMC/SD Karte (addr = 0)
	addr = 0;
	tmp = Read_Block_MMC (addr,Buffer);
	if (tmp != 0) //ist der Rückgabewert ungleich NULL ist ein Fehler aufgetreten 
	{
//ERRORLED	
	}
		
	
		
        while (1)
	{
	}
}

////////////////////////////////////////////////////////////////////////////////////////////
MMC.C
////////////////////////////////////////////////////////////////////////////////////////////

/*
 Copyright:      Manuel Plainer  mailto: ploana@gmx.net         / ulrich radig
 Author:         Manuel Plainer
 Remarks:        
 known Problems: none
 Version:        22.11.2005
 Description:    Enthält die Befehle für die Kommunikation mit der SD-Karte(wird im main-Programm impledmentiert)
*/     

#include <spi.h>	//SPI mode ... Hardware SPI


#define SPI_Mode			1
#define MMC_Write			PORTB	//Port an der die MMC/SD-Karte angeschlossen ist also des SPI 
#define MMC_Read			PINB
#define MMC_Direction_REG		DDRB

//Für AVR_ATmega8L
#define SPI_DI         			4       //MasterInSlaveOut
#define SPI_DO                          3       //MasterOutSlaveOut
#define SPI_Clock                       5       //SCK
#define MMC_Chip_Select                 1	//selbst definiert 
#define SPI_SS                          2       //SS nur wenn als Slave verwendet    

//Für SPI Control Register - SPCR
#define SPIE				7
#define SPE				6
#define DORD				5
#define MSTR				4
#define CPOL				3
#define CPHA				2
#define SPR1				1
#define SPR0				0

//Für SPI Status Register - SPSR
#define SPIF				7
#define WCOL				6
#define SPI2X				0

//set MMC_Chip_Select to high  --> Karte inaktiv
#define MMC_Disable() MMC_Write |= (1<<MMC_Chip_Select);
//set MMC_Chip_Select to low  --> Karte aktiv
#define MMC_Enable() MMC_Write &= ~(1<<MMC_Chip_Select);

//Prototypes
unsigned char Read_Byte_MMC();
void Write_Byte_MMC(unsigned char);
char Init_MMC();
char Read_Block_MMC (unsigned long, char *Buffer);
char Write_Block_MMC (unsigned long, char *Buffer);
unsigned char Write_Command_MMC (unsigned char *CMD);

//Routine zur Initialisierung der MMC/SD-Karte (SPI-MODE)
char Init_MMC()
{
	unsigned char Timeout = 0;
	int a = 0;				//Zähler für Schleifen;
	static char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};
	

	//Konfiguration des Ports an der die MMC/SD-Karte angeschlossen wurde
	MMC_Direction_REG &=~(1<<SPI_DI);		//Setzen von Pin MMC_DI auf Input
	MMC_Direction_REG |= (1<<SPI_Clock);		//Setzen von Pin MMC_Clock auf Output
	MMC_Direction_REG |= (1<<SPI_DO);		//Setzen von Pin MMC_DO auf Output
	MMC_Direction_REG |= (1<<MMC_Chip_Select);	//Setzen von Pin MMC_Chip_Select auf Output
	MMC_Direction_REG |= (1<<SPI_SS);	
	MMC_Disable();   //MMC_Write |= (1<<MMC_Chip_Select);		//Setzt den Pin MMC_Chip_Select auf High Pegel
	        
	for(a=0;a<2000;a++){};			//Wartet eine kurze Zeit
        
	
	//Aktiviren des SPI - Bus, Clock = Idel LOW
	//SPI Clock teilen durch 128
	SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0)|(1<<SPR1); 	//Enable SPI, SPI in Master Mode	
	SPSR = (0<<SPI2X);  				//SPRO,SPR1=1 SPIX2=0  fosc/128
	
	
	//Initialisiere MMC/SD-Karte in den SPI-Mode
	for (a = 0; a < 0x0f; a++) //Sendet min 74+ Clocks an die MMC/SD-Karte
	{
		Write_Byte_MMC(0xff);
	}
	
	//Sendet Commando CMD0 an MMC/SD-Karte
	Timeout = 0;
	while(Write_Command_MMC(CMD) != 1)
	{
		Timeout++;
		if (Timeout > 200)
		{
			
			return(1); //Abbruch bei Commando1 (Return Code1)
		}
	}
	
	//Sendet Commando CMD1 an MMC/SD-Karte
	Timeout = 0;
	CMD[0] = 0x41;//Commando 1
	CMD[5] = 0xFF;
	while(Write_Command_MMC(CMD) != 0)
	{
		Timeout++;
		if (Timeout > 10)
		{
			return(2); //Abbruch bei Commando2 (Return Code2)
		}
	}
	
	#if SPI_Mode
		//SPI Bus auf max Geschwindigkeit               
		SPCR &= ~((1<<SPR0) | (1<<SPR1));               //SPRO,SPR1=0 SPIX2=1  fosc/2
		SPSR = SPSR|(1<<SPI2X);
	#endif
	//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
	MMC_Disable(); 

	return(0);
}

//Sendet ein Commando an die MMC/SD-Karte               
unsigned char Write_Command_MMC (unsigned char *CMD)
{
	unsigned char tmp = 0xff, Timeout = 0;
	int a = 0;
	
	//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv) 
	MMC_Disable();

	//sendet 8 Clock Impulse
	Write_Byte_MMC(0xFF);

	//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)
	MMC_Enable();
 
	//sendet 6 Byte Commando
	for(a = 0;a<0x06;a++) //sendet 6 Byte Commando zur MMC/SD-Karte
	{
		Write_Byte_MMC(*CMD++);
	}

	//Wartet auf ein gültige Antwort von der MMC/SD-Karte
	while (tmp == 0xff)	
	{
		tmp = Read_Byte_MMC();
		if (Timeout++ > 100)
		{
			break; //Abbruch da die MMC/SD-Karte nicht Antwortet
		}
	}
        
	return(tmp);
}

//Routine zum Empfangen eines Bytes von der MMC-Karte
unsigned char Read_Byte_MMC (void)
{
	unsigned char Byte = 0;
	//Routine für Hardware SPI
	SPDR = 0xff;
	while(!(SPSR & (1<<SPIF))){};
	Byte = SPDR;

	return (Byte);
}

//Routine zum Senden eines Bytes zur MMC-Karte
void Write_Byte_MMC (unsigned char Byte)
{
	
	//Routine für Hardware SPI
	SPDR = Byte; 	//Sendet ein Byte
	while(!(SPSR & (1<<SPIF))) //Wartet bis Byte gesendet wurde
	{
	}
}

//Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
char Read_Block_MMC (unsigned long addr,char *Buffer)
{
	char tmp;
	int Timeout;
	int a=0;
	char CMD17[] = {0x51,0x00,0x00,0x00,0x00,0xFF}; //Commando 16 zum lesen eines Blocks
	
	/*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben,
	  addr wird von Blocks zu Bytes umgerechnet danach werden 
	  diese in das Commando eingefügt*/
	  
	addr = addr << 9; //addr = addr * 512
	
	CMD17[1] = ((addr & 0xFF000000) >>24 );
	CMD17[2] = ((addr & 0x00FF0000) >>16 );
	CMD17[3] = ((addr & 0x0000FF00) >>8 );

	//Sendet Commando CMD16 an MMC/SD-Karte (Read 1 Block/512 Bytes)
	tmp = Write_Command_MMC (CMD17);
	if (tmp != 0)
	{
		return(tmp);
	}
			
	//Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
	Timeout = 0;
	while (tmp != 0xfe)
	{
		tmp = Read_Byte_MMC();
		Timeout++;
		if (Timeout > 1000)
		{
			return(1);
		}
	}
	
	//Lesen des Bolcks (512Bytes) von MMC/SD-Karte
	for (a=0;a<512;a++)
	{
		*Buffer++ = Read_Byte_MMC();
	}
	
	//CRC-Byte auslesen
	tmp = Read_Byte_MMC();//CRC - Byte wird nicht ausgewertet
	tmp = Read_Byte_MMC();
	
	
	return(0);
}

//Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte
char Write_Block_MMC (unsigned long addr, char *Buffer)
{
	char tmp;
	int a=0;
	char CMD24[] = {0x58,0x00,0x00,0x00,0x00,0xFF}; //Commando 24 zum schreiben eines Blocks
	
	/*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben,
	  addr wird von Blocks zu Bytes umgerechnet danach werden 
	  diese in das Commando eingefügt*/
	  
	addr = addr << 9; //addr = addr * 512
	
	CMD24[1] = ((addr & 0xFF000000) >>24 );
	CMD24[2] = ((addr & 0x00FF0000) >>16 );
	CMD24[3] = ((addr & 0x0000FF00) >>8 );

	//Sendet Commando CMD24 an MMC/SD-Karte (Write 1 Block/512 Bytes)
	tmp = Write_Command_MMC (CMD24);
	if (tmp != 0)
	{
		return(tmp);
	}
			
	//Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte
	for (a=0;a<100;a++)
	{
		tmp = Read_Byte_MMC();
	}
	
	//Sendet Start Byte an MMC/SD-Karte
	Write_Byte_MMC(0xFE);	
	
	//Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte
	for (a=0;a<512;a++)
	{
		Write_Byte_MMC(*Buffer++);
	}
	
	//CRC-Byte schreiben
	Write_Byte_MMC(0xFF); //Schreibt Dummy CRC
	Write_Byte_MMC(0xFF); //CRC Code wird nicht benutzt
	
	//Wartet auf MMC/SD-Karte Bussy
	tmp = 0;
	while (tmp != 0xff)
	{
		tmp = Read_Byte_MMC();
	}
	return(0);
}