Ika-tachi
/
gg-button
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

file encoding fixes

Browse Source
master
Nidan 14 years ago
parent 0f4c42b594
commit 7566ff1317
3 changed files with 406 additions and 406 deletions
Show Stats Download Patch File Download Diff File

2
gg.c
Unescape View File

@ -52,7 +52,7 @@ ISR(TIMER1_OVF1_vect)
/* TODO: a-law decoding */ /* TODO: a-law decoding */
/* TODO: 11bit PWM emulation */ /* TODO: 11bit PWM emulation */
OCR1A = buffer[pos];/* play next sample */ OCR1A = buffer[pos];/* play sample */
} }

648
mmc.c
Unescape View File

@ -1,324 +1,324 @@
/*####################################################################################### /*#######################################################################################
Connect AVR to MMC/SD Connect AVR to MMC/SD
Copyright (C) 2004 Ulrich Radig Copyright (C) 2004 Ulrich Radig
Bei Fragen und Verbesserungen wendet euch per EMail an Bei Fragen und Verbesserungen wendet euch per EMail an
mail@ulrichradig.de mail@ulrichradig.de
oder im Forum meiner Web Page : www.ulrichradig.de oder im Forum meiner Web Page : www.ulrichradig.de
Dieses Programm ist freie Software. Sie können es unter den Bedingungen der Dieses Programm ist freie Software. Sie können es unter den Bedingungen der
GNU General Public License, wie von der Free Software Foundation veröffentlicht, GNU General Public License, wie von der Free Software Foundation veröffentlicht,
weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder
(nach Ihrer Option) jeder späteren Version. (nach Ihrer Option) jeder späteren Version.
Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, Die Veröffentlichung dieses Programms erfolgt in der Hoffnung,
daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE, dass es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE,
sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT
FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License. FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License.
Sie sollten eine Kopie der GNU General Public License zusammen mit diesem Sie sollten eine Kopie der GNU General Public License zusammen mit diesem
Programm erhalten haben. Programm erhalten haben.
Falls nicht, schreiben Sie an die Free Software Foundation, Falls nicht, schreiben Sie an die Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
#######################################################################################*/ #######################################################################################*/
#include "mmc.h" #include "mmc.h"
//############################################################################ //############################################################################
//Routine zur Initialisierung der MMC/SD-Karte (SPI-MODE) //Routine zur Initialisierung der MMC/SD-Karte (SPI-MODE)
unsigned char mmc_init () unsigned char mmc_init ()
//############################################################################ //############################################################################
{ {
unsigned int Timeout = 0; unsigned int Timeout = 0;
//Konfiguration des Ports an der die MMC/SD-Karte angeschlossen wurde //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_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_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<<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<<MMC_Chip_Select); //Setzen von Pin MMC_Chip_Select auf Output
MMC_Direction_REG |= (1<<SPI_SS); MMC_Direction_REG |= (1<<SPI_SS);
MMC_Write |= (1<<MMC_Chip_Select); //Setzt den Pin MMC_Chip_Select auf High Pegel MMC_Write |= (1<<MMC_Chip_Select); //Setzt den Pin MMC_Chip_Select auf High Pegel
for(unsigned char a=0;a<200;a++){ for(unsigned char a=0;a<200;a++){
nop(); nop();
}; //Wartet eine kurze Zeit }; //Wartet eine kurze Zeit
#if SPI_Mode #if SPI_Mode
//Aktiviren des SPI - Bus, Clock = Idel LOW //Aktiviren des SPI - Bus, Clock = Idel LOW
//SPI Clock teilen durch 128 //SPI Clock teilen durch 128
SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0)|(1<<SPR1); //Enable SPI, SPI in Master Mode SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0)|(1<<SPR1); //Enable SPI, SPI in Master Mode
SPSR = (0<<SPI2X); SPSR = (0<<SPI2X);
#endif #endif
//Initialisiere MMC/SD-Karte in den SPI-Mode //Initialisiere MMC/SD-Karte in den SPI-Mode
for (unsigned char b = 0;b<0x0f;b++) //Sendet min 74+ Clocks an die MMC/SD-Karte for (unsigned char b = 0;b<0x0f;b++) //Sendet min 74+ Clocks an die MMC/SD-Karte
{ {
mmc_write_byte(0xff); mmc_write_byte(0xff);
} }
//Sendet Commando CMD0 an MMC/SD-Karte //Sendet Commando CMD0 an MMC/SD-Karte
unsigned char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95}; unsigned char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};
while(mmc_write_command (CMD) !=1) while(mmc_write_command (CMD) !=1)
{ {
if (Timeout++ > 200) if (Timeout++ > 200)
{ {
MMC_Disable(); MMC_Disable();
return(1); //Abbruch bei Commando1 (Return Code1) return(1); //Abbruch bei Commando1 (Return Code1)
} }
} }
//Sendet Commando CMD1 an MMC/SD-Karte //Sendet Commando CMD1 an MMC/SD-Karte
Timeout = 0; Timeout = 0;
CMD[0] = 0x41;//Commando 1 CMD[0] = 0x41;//Commando 1
CMD[5] = 0xFF; CMD[5] = 0xFF;
while( mmc_write_command (CMD) !=0) while( mmc_write_command (CMD) !=0)
{ {
if (Timeout++ > 400) if (Timeout++ > 400)
{ {
MMC_Disable(); MMC_Disable();
return(2); //Abbruch bei Commando2 (Return Code2) return(2); //Abbruch bei Commando2 (Return Code2)
} }
} }
#if SPI_Mode #if SPI_Mode
//SPI Bus auf max Geschwindigkeit //SPI Bus auf max Geschwindigkeit
SPCR &= ~((1<<SPR0) | (1<<SPR1)); SPCR &= ~((1<<SPR0) | (1<<SPR1));
SPSR = SPSR|(1<<SPI2X); SPSR = SPSR|(1<<SPI2X);
#endif #endif
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv) //set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
MMC_Disable(); MMC_Disable();
return(0); return(0);
} }
//############################################################################ //############################################################################
//Sendet ein Commando an die MMC/SD-Karte //Sendet ein Commando an die MMC/SD-Karte
unsigned char mmc_write_command (unsigned char *cmd) unsigned char mmc_write_command (unsigned char *cmd)
//############################################################################ //############################################################################
{ {
unsigned char tmp = 0xff; unsigned char tmp = 0xff;
unsigned int Timeout = 0; unsigned int Timeout = 0;
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv) //set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
MMC_Disable(); MMC_Disable();
//sendet 8 Clock Impulse //sendet 8 Clock Impulse
mmc_write_byte(0xFF); mmc_write_byte(0xFF);
//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv) //set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)
MMC_Enable(); MMC_Enable();
//sendet 6 Byte Commando //sendet 6 Byte Commando
for (unsigned char a = 0;a<0x06;a++) //sendet 6 Byte Commando zur MMC/SD-Karte for (unsigned char a = 0;a<0x06;a++) //sendet 6 Byte Commando zur MMC/SD-Karte
{ {
mmc_write_byte(*cmd++); mmc_write_byte(*cmd++);
} }
//Wartet auf ein gültige Antwort von der MMC/SD-Karte //Wartet auf ein gültige Antwort von der MMC/SD-Karte
while (tmp == 0xff) while (tmp == 0xff)
{ {
tmp = mmc_read_byte(); tmp = mmc_read_byte();
if (Timeout++ > 500) if (Timeout++ > 500)
{ {
break; //Abbruch da die MMC/SD-Karte nicht Antwortet break; //Abbruch da die MMC/SD-Karte nicht Antwortet
} }
} }
return(tmp); return(tmp);
} }
//############################################################################ //############################################################################
//Routine zum Empfangen eines Bytes von der MMC-Karte //Routine zum Empfangen eines Bytes von der MMC-Karte
unsigned char mmc_read_byte (void) unsigned char mmc_read_byte (void)
//############################################################################ //############################################################################
{ {
unsigned char Byte = 0; unsigned char Byte = 0;
#if SPI_Mode //Routine für Hardware SPI #if SPI_Mode //Routine für Hardware SPI
SPDR = 0xff; SPDR = 0xff;
while(!(SPSR & (1<<SPIF))){}; while(!(SPSR & (1<<SPIF))){};
Byte = SPDR; Byte = SPDR;
#else //Routine für Software SPI #else //Routine für Software SPI
for (unsigned char a=8; a>0; a--) //das Byte wird Bitweise nacheinander Empangen MSB First for (unsigned char a=8; a>0; a--) //das Byte wird Bitweise nacheinander Empangen MSB First
{ {
MMC_Write &=~(1<<SPI_Clock); //erzeugt ein Clock Impuls (Low) MMC_Write &=~(1<<SPI_Clock); //erzeugt ein Clock Impuls (Low)
if (bit_is_set(MMC_Read,SPI_DI) > 0) //Lesen des Pegels von MMC_DI if (bit_is_set(MMC_Read,SPI_DI) > 0) //Lesen des Pegels von MMC_DI
{ {
Byte |= (1<<(a-1)); Byte |= (1<<(a-1));
} }
else else
{ {
Byte &=~(1<<(a-1)); Byte &=~(1<<(a-1));
} }
MMC_Write |=(1<<SPI_Clock); //setzt Clock Impuls wieder auf (High) MMC_Write |=(1<<SPI_Clock); //setzt Clock Impuls wieder auf (High)
} }
#endif #endif
return (Byte); return (Byte);
} }
//############################################################################ //############################################################################
//Routine zum Senden eines Bytes zur MMC-Karte //Routine zum Senden eines Bytes zur MMC-Karte
void mmc_write_byte (unsigned char Byte) void mmc_write_byte (unsigned char Byte)
//############################################################################ //############################################################################
{ {
#if SPI_Mode //Routine für Hardware SPI #if SPI_Mode //Routine für Hardware SPI
SPDR = Byte; //Sendet ein Byte SPDR = Byte; //Sendet ein Byte
while(!(SPSR & (1<<SPIF))) //Wartet bis Byte gesendet wurde while(!(SPSR & (1<<SPIF))) //Wartet bis Byte gesendet wurde
{ {
} }
#else //Routine für Software SPI #else //Routine für Software SPI
for (unsigned char a=8; a>0; a--) //das Byte wird Bitweise nacheinander Gesendet MSB First for (unsigned char a=8; a>0; a--) //das Byte wird Bitweise nacheinander Gesendet MSB First
{ {
if (bit_is_set(Byte,(a-1))>0) //Ist Bit a in Byte gesetzt if (bit_is_set(Byte,(a-1))>0) //Ist Bit a in Byte gesetzt
{ {
MMC_Write |= (1<<SPI_DO); //Set Output High MMC_Write |= (1<<SPI_DO); //Set Output High
} }
else else
{ {
MMC_Write &= ~(1<<SPI_DO); //Set Output Low MMC_Write &= ~(1<<SPI_DO); //Set Output Low
} }
MMC_Write &= ~(1<<SPI_Clock); //erzeugt ein Clock Impuls (LOW) MMC_Write &= ~(1<<SPI_Clock); //erzeugt ein Clock Impuls (LOW)
MMC_Write |= (1<<SPI_Clock); //setzt Clock Impuls wieder auf (High) MMC_Write |= (1<<SPI_Clock); //setzt Clock Impuls wieder auf (High)
} }
MMC_Write |= (1<<SPI_DO); //setzt Output wieder auf High MMC_Write |= (1<<SPI_DO); //setzt Output wieder auf High
#endif #endif
} }
//############################################################################ //############################################################################
//Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte //Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte
unsigned char mmc_write_sector (unsigned long addr,unsigned char *Buffer) unsigned char mmc_write_sector (unsigned long addr,unsigned char *Buffer)
//############################################################################ //############################################################################
{ {
unsigned char tmp; unsigned char tmp;
//Commando 24 zum schreiben eines Blocks auf die MMC/SD - Karte //Commando 24 zum schreiben eines Blocks auf die MMC/SD - Karte
unsigned char cmd[] = {0x58,0x00,0x00,0x00,0x00,0xFF}; unsigned char cmd[] = {0x58,0x00,0x00,0x00,0x00,0xFF};
/*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben, /*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben,
addr wird von Blocks zu Bytes umgerechnet danach werden addr wird von Blocks zu Bytes umgerechnet danach werden
diese in das Commando eingefügt*/ diese in das Commando eingefügt*/
addr = addr << 9; //addr = addr * 512 addr = addr << 9; //addr = addr * 512
cmd[1] = ((addr & 0xFF000000) >>24 ); cmd[1] = ((addr & 0xFF000000) >>24 );
cmd[2] = ((addr & 0x00FF0000) >>16 ); cmd[2] = ((addr & 0x00FF0000) >>16 );
cmd[3] = ((addr & 0x0000FF00) >>8 ); cmd[3] = ((addr & 0x0000FF00) >>8 );
//Sendet Commando cmd24 an MMC/SD-Karte (Write 1 Block/512 Bytes) //Sendet Commando cmd24 an MMC/SD-Karte (Write 1 Block/512 Bytes)
tmp = mmc_write_command (cmd); tmp = mmc_write_command (cmd);
if (tmp != 0) if (tmp != 0)
{ {
return(tmp); return(tmp);
} }
//Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte //Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte
for (unsigned char a=0;a<100;a++) for (unsigned char a=0;a<100;a++)
{ {
mmc_read_byte(); mmc_read_byte();
} }
//Sendet Start Byte an MMC/SD-Karte //Sendet Start Byte an MMC/SD-Karte
mmc_write_byte(0xFE); mmc_write_byte(0xFE);
//Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte //Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte
for (unsigned int a=0;a<512;a++) for (unsigned int a=0;a<512;a++)
{ {
mmc_write_byte(*Buffer++); mmc_write_byte(*Buffer++);
} }
//CRC-Byte schreiben //CRC-Byte schreiben
mmc_write_byte(0xFF); //Schreibt Dummy CRC mmc_write_byte(0xFF); //Schreibt Dummy CRC
mmc_write_byte(0xFF); //CRC Code wird nicht benutzt mmc_write_byte(0xFF); //CRC Code wird nicht benutzt
//Fehler beim schreiben? (Data Response XXX00101 = OK) //Fehler beim schreiben? (Data Response XXX00101 = OK)
if((mmc_read_byte()&0x1F) != 0x05) return(1); if((mmc_read_byte()&0x1F) != 0x05) return(1);
//Wartet auf MMC/SD-Karte Bussy //Wartet auf MMC/SD-Karte Bussy
while (mmc_read_byte() != 0xff){}; while (mmc_read_byte() != 0xff){};
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv) //set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
MMC_Disable(); MMC_Disable();
return(0); return(0);
} }
//############################################################################ //############################################################################
//Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes) //Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
void mmc_read_block(unsigned char *cmd,unsigned char *Buffer,unsigned int Bytes) void mmc_read_block(unsigned char *cmd,unsigned char *Buffer,unsigned int Bytes)
//############################################################################ //############################################################################
{ {
//Sendet Commando cmd an MMC/SD-Karte //Sendet Commando cmd an MMC/SD-Karte
if (mmc_write_command (cmd) != 0) if (mmc_write_command (cmd) != 0)
{ {
return; return;
} }
//Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte) //Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
while (mmc_read_byte() != 0xfe){}; while (mmc_read_byte() != 0xfe){};
//Lesen des Bolcks (normal 512Bytes) von MMC/SD-Karte //Lesen des Bolcks (normal 512Bytes) von MMC/SD-Karte
for (unsigned int a=0;a<Bytes;a++) for (unsigned int a=0;a<Bytes;a++)
{ {
*Buffer++ = mmc_read_byte(); *Buffer++ = mmc_read_byte();
} }
//CRC-Byte auslesen //CRC-Byte auslesen
mmc_read_byte();//CRC - Byte wird nicht ausgewertet mmc_read_byte();//CRC - Byte wird nicht ausgewertet
mmc_read_byte();//CRC - Byte wird nicht ausgewertet mmc_read_byte();//CRC - Byte wird nicht ausgewertet
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv) //set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
MMC_Disable(); MMC_Disable();
return; return;
} }
//############################################################################ //############################################################################
//Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte //Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
unsigned char mmc_read_sector (unsigned long addr,unsigned char *Buffer) unsigned char mmc_read_sector (unsigned long addr,unsigned char *Buffer)
//############################################################################ //############################################################################
{ {
//Commando 16 zum lesen eines Blocks von der MMC/SD - Karte //Commando 16 zum lesen eines Blocks von der MMC/SD - Karte
unsigned char cmd[] = {0x51,0x00,0x00,0x00,0x00,0xFF}; unsigned char cmd[] = {0x51,0x00,0x00,0x00,0x00,0xFF};
/*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben, /*Die Adressierung der MMC/SD-Karte wird in Bytes angegeben,
addr wird von Blocks zu Bytes umgerechnet danach werden addr wird von Blocks zu Bytes umgerechnet danach werden
diese in das Commando eingefügt*/ diese in das Commando eingefügt*/
addr = addr << 9; //addr = addr * 512 addr = addr << 9; //addr = addr * 512
cmd[1] = ((addr & 0xFF000000) >>24 ); cmd[1] = ((addr & 0xFF000000) >>24 );
cmd[2] = ((addr & 0x00FF0000) >>16 ); cmd[2] = ((addr & 0x00FF0000) >>16 );
cmd[3] = ((addr & 0x0000FF00) >>8 ); cmd[3] = ((addr & 0x0000FF00) >>8 );
mmc_read_block(cmd,Buffer,512); mmc_read_block(cmd,Buffer,512);
return(0); return(0);
} }
//############################################################################ //############################################################################
//Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes) //Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
unsigned char mmc_read_cid (unsigned char *Buffer) unsigned char mmc_read_cid (unsigned char *Buffer)
//############################################################################ //############################################################################
{ {
//Commando zum lesen des CID Registers //Commando zum lesen des CID Registers
unsigned char cmd[] = {0x4A,0x00,0x00,0x00,0x00,0xFF}; unsigned char cmd[] = {0x4A,0x00,0x00,0x00,0x00,0xFF};
mmc_read_block(cmd,Buffer,16); mmc_read_block(cmd,Buffer,16);
return(0); return(0);
} }
//############################################################################ //############################################################################
//Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes) //Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes)
unsigned char mmc_read_csd (unsigned char *Buffer) unsigned char mmc_read_csd (unsigned char *Buffer)
//############################################################################ //############################################################################
{ {
//Commando zum lesen des CSD Registers //Commando zum lesen des CSD Registers
unsigned char cmd[] = {0x49,0x00,0x00,0x00,0x00,0xFF}; unsigned char cmd[] = {0x49,0x00,0x00,0x00,0x00,0xFF};
mmc_read_block(cmd,Buffer,16); mmc_read_block(cmd,Buffer,16);
return(0); return(0);
} }

162
mmc.h
Unescape View File

@ -1,81 +1,81 @@
/*####################################################################################### /*#######################################################################################
Connect ARM to MMC/SD Connect ARM to MMC/SD
Copyright (C) 2004 Ulrich Radig Copyright (C) 2004 Ulrich Radig
#######################################################################################*/ #######################################################################################*/
#ifndef _MMC_H_ #ifndef _MMC_H_
#define _MMC_H_ #define _MMC_H_
#include <avr/io.h> #include <avr/io.h>
//#define SPI_Mode 1 //1 = Hardware SPI | 0 = Software SPI //#define SPI_Mode 1 //1 = Hardware SPI | 0 = Software SPI
#define SPI_Mode 0 #define SPI_Mode 0
#define MMC_Write PORTB //Port an der die MMC/SD-Karte angeschlossen ist also des SPI #define MMC_Write PORTB //Port an der die MMC/SD-Karte angeschlossen ist also des SPI
#define MMC_Read PINB #define MMC_Read PINB
#define MMC_Direction_REG DDRB #define MMC_Direction_REG DDRB
#if defined (__AVR_ATmega128__) #if defined (__AVR_ATmega128__)
#define SPI_DI 3 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist #define SPI_DI 3 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist
#define SPI_DO 2 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist #define SPI_DO 2 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist
#define SPI_Clock 1 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk) #define SPI_Clock 1 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk)
#define MMC_Chip_Select 4 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist #define MMC_Chip_Select 4 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist
#define SPI_SS 0 //Nicht Benutz muß aber definiert werden #define SPI_SS 0 //Nicht Benutz muss aber definiert werden
#endif #endif
#if defined (__AVR_ATmega32__) #if defined (__AVR_ATmega32__)
#define SPI_DI 6 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist #define SPI_DI 6 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist
#define SPI_DO 5 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist #define SPI_DO 5 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist
#define SPI_Clock 7 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk) #define SPI_Clock 7 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk)
#define MMC_Chip_Select 3 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist #define MMC_Chip_Select 3 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist
#define SPI_SS 4 //Nicht Benutz muß aber definiert werden #define SPI_SS 4 //Nicht Benutz muss aber definiert werden
#endif #endif
#if defined (__AVR_ATmega644__) #if defined (__AVR_ATmega644__)
#define SPI_DI 6 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist #define SPI_DI 6 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist
#define SPI_DO 5 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist #define SPI_DO 5 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist
#define SPI_Clock 7 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk) #define SPI_Clock 7 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk)
#define MMC_Chip_Select 1 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist #define MMC_Chip_Select 1 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist
#define SPI_SS 4 //Nicht Benutz muß aber definiert werden #define SPI_SS 4 //Nicht Benutz muss aber definiert werden
#endif #endif
#if defined (__AVR_ATtiny26__) #if defined (__AVR_ATtiny26__)
#define SPI_DI 6 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist #define SPI_DI 6 //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist
#define SPI_DO 5 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist #define SPI_DO 5 //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist
#define SPI_Clock 7 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk) #define SPI_Clock 7 //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk)
#define MMC_Chip_Select 1 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist #define MMC_Chip_Select 1 //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist
#define SPI_SS 4 //Nicht benutzt, muß aber definiert werden #define SPI_SS 4 //Nicht benutzt, muss aber definiert werden
#endif #endif
//Prototypes //Prototypes
extern unsigned char mmc_read_byte(void); extern unsigned char mmc_read_byte(void);
extern void mmc_write_byte(unsigned char); extern void mmc_write_byte(unsigned char);
extern void mmc_read_block(unsigned char *,unsigned char *,unsigned in); extern void mmc_read_block(unsigned char *,unsigned char *,unsigned in);
extern unsigned char mmc_init(void); extern unsigned char mmc_init(void);
extern unsigned char mmc_read_sector (unsigned long,unsigned char *); extern unsigned char mmc_read_sector (unsigned long,unsigned char *);
extern unsigned char mmc_write_sector (unsigned long,unsigned char *); extern unsigned char mmc_write_sector (unsigned long,unsigned char *);
extern unsigned char mmc_write_command (unsigned char *); extern unsigned char mmc_write_command (unsigned char *);
extern unsigned char mmc_read_csd (unsigned char *); extern unsigned char mmc_read_csd (unsigned char *);
extern unsigned char mmc_read_cid (unsigned char *); extern unsigned char mmc_read_cid (unsigned char *);
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv) //set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
#define MMC_Disable() MMC_Write|= (1<<MMC_Chip_Select); #define MMC_Disable() MMC_Write|= (1<<MMC_Chip_Select);
//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv) //set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)
#define MMC_Enable() MMC_Write&=~(1<<MMC_Chip_Select); #define MMC_Enable() MMC_Write&=~(1<<MMC_Chip_Select);
#define nop() __asm__ __volatile__ ("nop" ::) #define nop() __asm__ __volatile__ ("nop" ::)
#endif //_MMC_H_ #endif //_MMC_H_

Write Preview
Loading…
Cancel
Save