Hannes
14 years ago
commit
a113f7f64a
@ -1 +1,7 @@
|
||||
/*.swp
|
||||
/*.d
|
||||
headeredit
|
||||
/*.o
|
||||
/disasm
|
||||
/firmware.bin
|
||||
/firmware.hex
|
||||
|
||||
@ -0,0 +1,77 @@
|
||||
CFLAGS += -Wall -Os -I. -mmcu=attiny26 -std=c99
|
||||
DEFINES += -DF_CPU=16e6
|
||||
|
||||
OBJECTS = gg.o mmc.o
|
||||
|
||||
# further optimization:
|
||||
# this removes dead code and does global linker optimization
|
||||
#CFLAGS += -ffunction-sections -Wl,--gc-sections -Wl,--relax
|
||||
#CFLAGS += --param inline-call-cost=2
|
||||
|
||||
COMPILE = avr-gcc $(CFLAGS) $(DEFINES)
|
||||
|
||||
# symbolic targets:
|
||||
all: firmware.hex
|
||||
|
||||
.c.o:
|
||||
$(COMPILE) -c $< -o $@
|
||||
|
||||
.S.o:
|
||||
$(COMPILE) -x assembler-with-cpp -c $< -o $@
|
||||
# "-x assembler-with-cpp" should not be necessary since this is the default
|
||||
# file type for the .S (with capital S) extension. However, upper case
|
||||
# characters are not always preserved on Windows. To ensure WinAVR
|
||||
# compatibility define the file type manually.
|
||||
|
||||
.c.s:
|
||||
$(COMPILE) -S $< -o $@
|
||||
|
||||
flash: all
|
||||
avrdude -c usbasp -p t26 -U flash:w:firmware.hex
|
||||
|
||||
fuses:
|
||||
echo TODO
|
||||
# avrdude -c usbasp -p t26 -U lfuse:w:0xe4:m -U hfuse:w:0xd9:m # internal 8Mhz oscillator
|
||||
|
||||
|
||||
## what are the source dependencies
|
||||
%.d: %.c
|
||||
@set -e; rm -f $@; \
|
||||
$(COMPILE) -MM $< | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@;
|
||||
# line 1: exits if anything goes wrong
|
||||
# line 2a: gcc -MM outputs dependencies
|
||||
# line 2b: insert the %.d into dependency list
|
||||
|
||||
#main.c: version.h
|
||||
|
||||
|
||||
version.h: .svn/entries
|
||||
export LANG=POSIX; (svn info 2>/dev/null || echo "Revision: unknown") | awk '/^Revision:/ {print "#define SVNVERSION \"" $$2 "\""};' >version.h
|
||||
|
||||
|
||||
clean:
|
||||
rm -f *.o *.hex *.obj *.i *.s *.d */*.i */*.s */*.o */*.d version.h
|
||||
|
||||
# file targets:
|
||||
firmware.bin: $(OBJECTS)
|
||||
$(COMPILE) -o firmware.bin $(OBJECTS)
|
||||
|
||||
firmware.hex: firmware.bin
|
||||
rm -f firmware.hex firmware.eep.hex
|
||||
avr-objcopy -j .text -j .data -O ihex firmware.bin firmware.hex
|
||||
avr-size firmware.bin
|
||||
# ./checksize firmware.bin 8192 960
|
||||
# do the checksize script as our last action to allow successful compilation
|
||||
# on Windows with WinAVR where the Unix commands will fail.
|
||||
|
||||
disasm: firmware.bin
|
||||
avr-objdump -d firmware.bin >disasm
|
||||
|
||||
functionsize: disasm
|
||||
python avrbuild/functionsize.py
|
||||
|
||||
countregs: disasm
|
||||
python avrbuild/countregs.py
|
||||
|
||||
# for depends:
|
||||
-include $(OBJECTS:.o=.d)
|
||||
@ -0,0 +1,18 @@
|
||||
#!/usr/bin/python
|
||||
import re
|
||||
import os
|
||||
|
||||
fd = os.popen("avr-objdump -d firmware.bin")
|
||||
regcount = [0]*32
|
||||
s="foo"
|
||||
while s:
|
||||
s=fd.readline()
|
||||
m=re.findall(r"[ \n\t,;]r(\d\d?)[ \n\t,;]",s)
|
||||
if m:
|
||||
for i in m:
|
||||
regcount[int(i)] += 1;
|
||||
|
||||
for i in range(16):
|
||||
print "r%2d: %4d"%(i,regcount[i]),
|
||||
print "\tr%2d: %4d"%(i+16,regcount[i+16])
|
||||
|
||||
@ -0,0 +1,50 @@
|
||||
#!/usr/bin/python
|
||||
import re
|
||||
import os
|
||||
|
||||
|
||||
def main():
|
||||
fd = os.popen("avr-objdump -d firmware.bin")
|
||||
oldaddr=0
|
||||
lastfnname=""
|
||||
namespacedict = {}
|
||||
s="foo"
|
||||
while s:
|
||||
s=fd.readline()
|
||||
m=re.match("([0-9a-f]+) <(\w+)>:",s)
|
||||
if m:
|
||||
addr,fname=m.groups()
|
||||
addr=int(addr,16)
|
||||
size=addr-oldaddr
|
||||
oldaddr=addr
|
||||
# print size,"\t",lastfnname
|
||||
namespace=get_namespace(lastfnname)
|
||||
try:
|
||||
namespacedict[namespace].append((lastfnname, size))
|
||||
except:
|
||||
namespacedict[namespace] = [(lastfnname, size)]
|
||||
lastfnname = fname
|
||||
|
||||
print "individual sizes:"
|
||||
for k,v in namespacedict.items():
|
||||
for a,b in sorted(v):
|
||||
print "%4i %s"%(b,a)
|
||||
print "namespace sizes:"
|
||||
for k,v in namespacedict.items():
|
||||
totalsize = sum( [ i[1] for i in v ] )
|
||||
print "%4i %s*"%(totalsize,k)
|
||||
|
||||
def get_namespace(name):
|
||||
matchlist = [
|
||||
r"(^__)",
|
||||
r"(^\w+?_)",
|
||||
r"(\w[a-z0-9])[A-Z]"]
|
||||
for i in matchlist:
|
||||
m = re.match(i, name)
|
||||
if m:
|
||||
return m.groups()[0]
|
||||
return "<nonamespace>"
|
||||
|
||||
|
||||
if __name__=="__main__":
|
||||
main()
|
||||
@ -0,0 +1,43 @@
|
||||
#!/usr/bin/python
|
||||
|
||||
import re
|
||||
|
||||
print "Auto-generating menu_autogen.h..."
|
||||
|
||||
items=set([])
|
||||
|
||||
fd=file("menu.c")
|
||||
for line in fd:
|
||||
m = re.search(r"menu_item_(\w+)\s*\(",line)
|
||||
if m:
|
||||
items.add( m.groups()[0])
|
||||
|
||||
fd.close()
|
||||
|
||||
items=list(items) # create clear ordering
|
||||
|
||||
fd=file("menu_autogen.h","wb")
|
||||
|
||||
fd.write("\n");
|
||||
for i in range(len(items)):
|
||||
fd.write("extern int8_t menu_item_%s();\n" % items[i])
|
||||
|
||||
fd.write("\ntypedef int8_t (*item_handler_t)();\n\n")
|
||||
|
||||
fd.write("item_handler_t menu_item_handlers[] = {\n")
|
||||
fd.write("\t\tNULL")
|
||||
|
||||
for i in range(len(items)):
|
||||
fd.write(",\n\t\t*menu_item_%s" % items[i])
|
||||
|
||||
fd.write("\n};\n\n")
|
||||
|
||||
for i in range(len(items)):
|
||||
fd.write("#define MENU_ITEM_%s \t%s\n" % (items[i].upper(), i+1))
|
||||
|
||||
fd.write("\n")
|
||||
fd.write("#define MENU_MAX_ITEM %s\n\n"%len(items))
|
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,113 @@
|
||||
#!/usr/bin/python
|
||||
|
||||
import re
|
||||
from sys import argv
|
||||
|
||||
startline = "/* autogenerated by update_header.py. Please check and uncomment.\n"
|
||||
changedline = "// changed declarations:\n"
|
||||
newline = "// new declarations:\n"
|
||||
endline = "*/ // update_header.py end\n"
|
||||
|
||||
def parse_c(data):
|
||||
l=0
|
||||
while l!=len(data):
|
||||
l=len(data)
|
||||
data=re.sub(r"(?ms)\{[^{}]*\}",";",data)
|
||||
data = re.sub(r"(?ms)/\*.*?\*/","",data)
|
||||
data = re.sub(r"(?m)^#.*$","",data)
|
||||
data = data.split(";")
|
||||
data = map(lambda x:x.strip(), data)
|
||||
data = filter(None, data) # kill empty lines
|
||||
data = map(lambda x:re.sub(r"\s*=.*$","",x), data)
|
||||
return data
|
||||
|
||||
|
||||
def make_symtable(data):
|
||||
symbols={}
|
||||
for i in data:
|
||||
symname=get_symname(i)
|
||||
symbols[symname] = i
|
||||
return symbols
|
||||
|
||||
def get_symname(line):
|
||||
try:
|
||||
r = re.search(r"(\w+)($|\(|\[)",line).groups()[0]
|
||||
return r
|
||||
except:
|
||||
raise 'Could not extract symbol from "%s".'%repr(line)
|
||||
|
||||
def update_header(filebase):
|
||||
data = file(filebase+".c").read()
|
||||
data = parse_c(data)
|
||||
header = file(filebase+".h").read()
|
||||
header = parse_c(header)
|
||||
headersyms = make_symtable(header)
|
||||
|
||||
changed=[]
|
||||
new=[]
|
||||
for i in data:
|
||||
symname = get_symname(i)
|
||||
if symname not in headersyms:
|
||||
new.append(i)
|
||||
continue
|
||||
headerline = headersyms[symname]
|
||||
headerline = re.sub(r"extern\s+","",headerline)
|
||||
if headerline != i:
|
||||
changed.append(i)
|
||||
|
||||
print changed
|
||||
print new
|
||||
|
||||
if (not changed) and (not new):
|
||||
return # nothing to do
|
||||
|
||||
fd=file(filebase+".h")
|
||||
header = fd.readlines()
|
||||
fd.close()
|
||||
if startline in header:
|
||||
try:
|
||||
print "foo"
|
||||
start=header.index(startline)
|
||||
stop=header.index(endline)
|
||||
print start, stop
|
||||
header = header[:start] + header[stop+1:]
|
||||
fd = file(filebase+".h","wb")
|
||||
fd.write("".join(header))
|
||||
fd.close()
|
||||
except:
|
||||
print "Error killing old entry"
|
||||
fd = file(filebase+".h","ab")
|
||||
|
||||
fd.write("\n\n\n")
|
||||
fd.write(startline)
|
||||
if changed:
|
||||
fd.write("\n")
|
||||
fd.write(changedline)
|
||||
for i in changed:
|
||||
fd.write("extern "+i+";\n")
|
||||
if new:
|
||||
fd.write("\n")
|
||||
fd.write(newline)
|
||||
for i in new:
|
||||
fd.write("extern "+i+";\n")
|
||||
fd.write("\n")
|
||||
fd.write(endline)
|
||||
fd.write("\n\n\n")
|
||||
fd.close()
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
for i in argv[1:]:
|
||||
i=re.sub(".[ch]$","",i)
|
||||
update_header(i)
|
||||
|
||||
|
||||
if __name__=="__main__":
|
||||
main()
|
||||
@ -1,324 +1,324 @@
|
||||
/*#######################################################################################
|
||||
Connect AVR to MMC/SD
|
||||
|
||||
Copyright (C) 2004 Ulrich Radig
|
||||
|
||||
Bei Fragen und Verbesserungen wendet euch per EMail an
|
||||
|
||||
mail@ulrichradig.de
|
||||
|
||||
oder im Forum meiner Web Page : www.ulrichradig.de
|
||||
|
||||
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,
|
||||
weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder
|
||||
(nach Ihrer Option) jeder späteren Version.
|
||||
|
||||
Die Veröffentlichung dieses Programms erfolgt in der Hoffnung,
|
||||
daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE,
|
||||
sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT
|
||||
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
|
||||
Programm erhalten haben.
|
||||
Falls nicht, schreiben Sie an die Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
|
||||
#######################################################################################*/
|
||||
|
||||
#include "mmc.h"
|
||||
|
||||
//############################################################################
|
||||
//Routine zur Initialisierung der MMC/SD-Karte (SPI-MODE)
|
||||
unsigned char mmc_init ()
|
||||
//############################################################################
|
||||
{
|
||||
unsigned int Timeout = 0;
|
||||
|
||||
//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_Write |= (1<<MMC_Chip_Select); //Setzt den Pin MMC_Chip_Select auf High Pegel
|
||||
|
||||
for(unsigned char a=0;a<200;a++){
|
||||
nop();
|
||||
}; //Wartet eine kurze Zeit
|
||||
|
||||
#if SPI_Mode
|
||||
//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);
|
||||
#endif
|
||||
|
||||
//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
|
||||
{
|
||||
mmc_write_byte(0xff);
|
||||
}
|
||||
|
||||
//Sendet Commando CMD0 an MMC/SD-Karte
|
||||
unsigned char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};
|
||||
while(mmc_write_command (CMD) !=1)
|
||||
{
|
||||
if (Timeout++ > 200)
|
||||
{
|
||||
MMC_Disable();
|
||||
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( mmc_write_command (CMD) !=0)
|
||||
{
|
||||
if (Timeout++ > 400)
|
||||
{
|
||||
MMC_Disable();
|
||||
return(2); //Abbruch bei Commando2 (Return Code2)
|
||||
}
|
||||
}
|
||||
#if SPI_Mode
|
||||
//SPI Bus auf max Geschwindigkeit
|
||||
SPCR &= ~((1<<SPR0) | (1<<SPR1));
|
||||
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 mmc_write_command (unsigned char *cmd)
|
||||
//############################################################################
|
||||
{
|
||||
unsigned char tmp = 0xff;
|
||||
unsigned int Timeout = 0;
|
||||
|
||||
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
|
||||
MMC_Disable();
|
||||
|
||||
//sendet 8 Clock Impulse
|
||||
mmc_write_byte(0xFF);
|
||||
|
||||
//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)
|
||||
MMC_Enable();
|
||||
|
||||
//sendet 6 Byte Commando
|
||||
for (unsigned char a = 0;a<0x06;a++) //sendet 6 Byte Commando zur MMC/SD-Karte
|
||||
{
|
||||
mmc_write_byte(*cmd++);
|
||||
}
|
||||
|
||||
//Wartet auf ein gültige Antwort von der MMC/SD-Karte
|
||||
while (tmp == 0xff)
|
||||
{
|
||||
tmp = mmc_read_byte();
|
||||
if (Timeout++ > 500)
|
||||
{
|
||||
break; //Abbruch da die MMC/SD-Karte nicht Antwortet
|
||||
}
|
||||
}
|
||||
return(tmp);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum Empfangen eines Bytes von der MMC-Karte
|
||||
unsigned char mmc_read_byte (void)
|
||||
//############################################################################
|
||||
{
|
||||
unsigned char Byte = 0;
|
||||
#if SPI_Mode //Routine für Hardware SPI
|
||||
SPDR = 0xff;
|
||||
while(!(SPSR & (1<<SPIF))){};
|
||||
Byte = SPDR;
|
||||
|
||||
#else //Routine für Software SPI
|
||||
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)
|
||||
|
||||
if (bit_is_set(MMC_Read,SPI_DI) > 0) //Lesen des Pegels von MMC_DI
|
||||
{
|
||||
Byte |= (1<<(a-1));
|
||||
}
|
||||
else
|
||||
{
|
||||
Byte &=~(1<<(a-1));
|
||||
}
|
||||
MMC_Write |=(1<<SPI_Clock); //setzt Clock Impuls wieder auf (High)
|
||||
}
|
||||
#endif
|
||||
return (Byte);
|
||||
}
|
||||
|
||||
|
||||
//############################################################################
|
||||
//Routine zum Senden eines Bytes zur MMC-Karte
|
||||
void mmc_write_byte (unsigned char Byte)
|
||||
//############################################################################
|
||||
{
|
||||
#if SPI_Mode //Routine für Hardware SPI
|
||||
SPDR = Byte; //Sendet ein Byte
|
||||
while(!(SPSR & (1<<SPIF))) //Wartet bis Byte gesendet wurde
|
||||
{
|
||||
}
|
||||
#else //Routine für Software SPI
|
||||
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
|
||||
{
|
||||
MMC_Write |= (1<<SPI_DO); //Set Output High
|
||||
}
|
||||
else
|
||||
{
|
||||
MMC_Write &= ~(1<<SPI_DO); //Set Output 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_DO); //setzt Output wieder auf High
|
||||
#endif
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte
|
||||
unsigned char mmc_write_sector (unsigned long addr,unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
unsigned char tmp;
|
||||
//Commando 24 zum schreiben eines Blocks auf die MMC/SD - Karte
|
||||
unsigned char cmd[] = {0x58,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
/*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
|
||||
|
||||
cmd[1] = ((addr & 0xFF000000) >>24 );
|
||||
cmd[2] = ((addr & 0x00FF0000) >>16 );
|
||||
cmd[3] = ((addr & 0x0000FF00) >>8 );
|
||||
|
||||
//Sendet Commando cmd24 an MMC/SD-Karte (Write 1 Block/512 Bytes)
|
||||
tmp = mmc_write_command (cmd);
|
||||
if (tmp != 0)
|
||||
{
|
||||
return(tmp);
|
||||
}
|
||||
|
||||
//Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte
|
||||
for (unsigned char a=0;a<100;a++)
|
||||
{
|
||||
mmc_read_byte();
|
||||
}
|
||||
|
||||
//Sendet Start Byte an MMC/SD-Karte
|
||||
mmc_write_byte(0xFE);
|
||||
|
||||
//Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte
|
||||
for (unsigned int a=0;a<512;a++)
|
||||
{
|
||||
mmc_write_byte(*Buffer++);
|
||||
}
|
||||
|
||||
//CRC-Byte schreiben
|
||||
mmc_write_byte(0xFF); //Schreibt Dummy CRC
|
||||
mmc_write_byte(0xFF); //CRC Code wird nicht benutzt
|
||||
|
||||
//Fehler beim schreiben? (Data Response XXX00101 = OK)
|
||||
if((mmc_read_byte()&0x1F) != 0x05) return(1);
|
||||
|
||||
//Wartet auf MMC/SD-Karte Bussy
|
||||
while (mmc_read_byte() != 0xff){};
|
||||
|
||||
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
|
||||
MMC_Disable();
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//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)
|
||||
//############################################################################
|
||||
{
|
||||
//Sendet Commando cmd an MMC/SD-Karte
|
||||
if (mmc_write_command (cmd) != 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
//Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
|
||||
|
||||
while (mmc_read_byte() != 0xfe){};
|
||||
|
||||
//Lesen des Bolcks (normal 512Bytes) von MMC/SD-Karte
|
||||
for (unsigned int a=0;a<Bytes;a++)
|
||||
{
|
||||
*Buffer++ = mmc_read_byte();
|
||||
}
|
||||
//CRC-Byte auslesen
|
||||
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)
|
||||
MMC_Disable();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
|
||||
unsigned char mmc_read_sector (unsigned long addr,unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
//Commando 16 zum lesen eines Blocks von der MMC/SD - Karte
|
||||
unsigned char cmd[] = {0x51,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
/*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
|
||||
|
||||
cmd[1] = ((addr & 0xFF000000) >>24 );
|
||||
cmd[2] = ((addr & 0x00FF0000) >>16 );
|
||||
cmd[3] = ((addr & 0x0000FF00) >>8 );
|
||||
|
||||
mmc_read_block(cmd,Buffer,512);
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
|
||||
unsigned char mmc_read_cid (unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
//Commando zum lesen des CID Registers
|
||||
unsigned char cmd[] = {0x4A,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
mmc_read_block(cmd,Buffer,16);
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes)
|
||||
unsigned char mmc_read_csd (unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
//Commando zum lesen des CSD Registers
|
||||
unsigned char cmd[] = {0x49,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
mmc_read_block(cmd,Buffer,16);
|
||||
|
||||
return(0);
|
||||
}
|
||||
/*#######################################################################################
|
||||
Connect AVR to MMC/SD
|
||||
|
||||
Copyright (C) 2004 Ulrich Radig
|
||||
|
||||
Bei Fragen und Verbesserungen wendet euch per EMail an
|
||||
|
||||
mail@ulrichradig.de
|
||||
|
||||
oder im Forum meiner Web Page : www.ulrichradig.de
|
||||
|
||||
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,
|
||||
weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder
|
||||
(nach Ihrer Option) jeder späteren Version.
|
||||
|
||||
Die Veröffentlichung dieses Programms erfolgt in der Hoffnung,
|
||||
dass es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE,
|
||||
sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT
|
||||
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
|
||||
Programm erhalten haben.
|
||||
Falls nicht, schreiben Sie an die Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
|
||||
#######################################################################################*/
|
||||
|
||||
#include "mmc.h"
|
||||
|
||||
//############################################################################
|
||||
//Routine zur Initialisierung der MMC/SD-Karte (SPI-MODE)
|
||||
unsigned char mmc_init ()
|
||||
//############################################################################
|
||||
{
|
||||
unsigned int Timeout = 0;
|
||||
|
||||
//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_Write |= (1<<MMC_Chip_Select); //Setzt den Pin MMC_Chip_Select auf High Pegel
|
||||
|
||||
for(unsigned char a=0;a<200;a++){
|
||||
nop();
|
||||
}; //Wartet eine kurze Zeit
|
||||
|
||||
#if SPI_Mode
|
||||
//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);
|
||||
#endif
|
||||
|
||||
//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
|
||||
{
|
||||
mmc_write_byte(0xff);
|
||||
}
|
||||
|
||||
//Sendet Commando CMD0 an MMC/SD-Karte
|
||||
unsigned char CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};
|
||||
while(mmc_write_command (CMD) !=1)
|
||||
{
|
||||
if (Timeout++ > 200)
|
||||
{
|
||||
MMC_Disable();
|
||||
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( mmc_write_command (CMD) !=0)
|
||||
{
|
||||
if (Timeout++ > 400)
|
||||
{
|
||||
MMC_Disable();
|
||||
return(2); //Abbruch bei Commando2 (Return Code2)
|
||||
}
|
||||
}
|
||||
#if SPI_Mode
|
||||
//SPI Bus auf max Geschwindigkeit
|
||||
SPCR &= ~((1<<SPR0) | (1<<SPR1));
|
||||
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 mmc_write_command (unsigned char *cmd)
|
||||
//############################################################################
|
||||
{
|
||||
unsigned char tmp = 0xff;
|
||||
unsigned int Timeout = 0;
|
||||
|
||||
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
|
||||
MMC_Disable();
|
||||
|
||||
//sendet 8 Clock Impulse
|
||||
mmc_write_byte(0xFF);
|
||||
|
||||
//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)
|
||||
MMC_Enable();
|
||||
|
||||
//sendet 6 Byte Commando
|
||||
for (unsigned char a = 0;a<0x06;a++) //sendet 6 Byte Commando zur MMC/SD-Karte
|
||||
{
|
||||
mmc_write_byte(*cmd++);
|
||||
}
|
||||
|
||||
//Wartet auf ein gültige Antwort von der MMC/SD-Karte
|
||||
while (tmp == 0xff)
|
||||
{
|
||||
tmp = mmc_read_byte();
|
||||
if (Timeout++ > 500)
|
||||
{
|
||||
break; //Abbruch da die MMC/SD-Karte nicht Antwortet
|
||||
}
|
||||
}
|
||||
return(tmp);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum Empfangen eines Bytes von der MMC-Karte
|
||||
unsigned char mmc_read_byte (void)
|
||||
//############################################################################
|
||||
{
|
||||
unsigned char Byte = 0;
|
||||
#if SPI_Mode //Routine für Hardware SPI
|
||||
SPDR = 0xff;
|
||||
while(!(SPSR & (1<<SPIF))){};
|
||||
Byte = SPDR;
|
||||
|
||||
#else //Routine für Software SPI
|
||||
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)
|
||||
|
||||
if (bit_is_set(MMC_Read,SPI_DI) > 0) //Lesen des Pegels von MMC_DI
|
||||
{
|
||||
Byte |= (1<<(a-1));
|
||||
}
|
||||
else
|
||||
{
|
||||
Byte &=~(1<<(a-1));
|
||||
}
|
||||
MMC_Write |=(1<<SPI_Clock); //setzt Clock Impuls wieder auf (High)
|
||||
}
|
||||
#endif
|
||||
return (Byte);
|
||||
}
|
||||
|
||||
|
||||
//############################################################################
|
||||
//Routine zum Senden eines Bytes zur MMC-Karte
|
||||
void mmc_write_byte (unsigned char Byte)
|
||||
//############################################################################
|
||||
{
|
||||
#if SPI_Mode //Routine für Hardware SPI
|
||||
SPDR = Byte; //Sendet ein Byte
|
||||
while(!(SPSR & (1<<SPIF))) //Wartet bis Byte gesendet wurde
|
||||
{
|
||||
}
|
||||
#else //Routine für Software SPI
|
||||
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
|
||||
{
|
||||
MMC_Write |= (1<<SPI_DO); //Set Output High
|
||||
}
|
||||
else
|
||||
{
|
||||
MMC_Write &= ~(1<<SPI_DO); //Set Output 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_DO); //setzt Output wieder auf High
|
||||
#endif
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum schreiben eines Blocks(512Byte) auf die MMC/SD-Karte
|
||||
unsigned char mmc_write_sector (unsigned long addr,unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
unsigned char tmp;
|
||||
//Commando 24 zum schreiben eines Blocks auf die MMC/SD - Karte
|
||||
unsigned char cmd[] = {0x58,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
/*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
|
||||
|
||||
cmd[1] = ((addr & 0xFF000000) >>24 );
|
||||
cmd[2] = ((addr & 0x00FF0000) >>16 );
|
||||
cmd[3] = ((addr & 0x0000FF00) >>8 );
|
||||
|
||||
//Sendet Commando cmd24 an MMC/SD-Karte (Write 1 Block/512 Bytes)
|
||||
tmp = mmc_write_command (cmd);
|
||||
if (tmp != 0)
|
||||
{
|
||||
return(tmp);
|
||||
}
|
||||
|
||||
//Wartet einen Moment und sendet einen Clock an die MMC/SD-Karte
|
||||
for (unsigned char a=0;a<100;a++)
|
||||
{
|
||||
mmc_read_byte();
|
||||
}
|
||||
|
||||
//Sendet Start Byte an MMC/SD-Karte
|
||||
mmc_write_byte(0xFE);
|
||||
|
||||
//Schreiben des Bolcks (512Bytes) auf MMC/SD-Karte
|
||||
for (unsigned int a=0;a<512;a++)
|
||||
{
|
||||
mmc_write_byte(*Buffer++);
|
||||
}
|
||||
|
||||
//CRC-Byte schreiben
|
||||
mmc_write_byte(0xFF); //Schreibt Dummy CRC
|
||||
mmc_write_byte(0xFF); //CRC Code wird nicht benutzt
|
||||
|
||||
//Fehler beim schreiben? (Data Response XXX00101 = OK)
|
||||
if((mmc_read_byte()&0x1F) != 0x05) return(1);
|
||||
|
||||
//Wartet auf MMC/SD-Karte Bussy
|
||||
while (mmc_read_byte() != 0xff){};
|
||||
|
||||
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
|
||||
MMC_Disable();
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//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)
|
||||
//############################################################################
|
||||
{
|
||||
//Sendet Commando cmd an MMC/SD-Karte
|
||||
if (mmc_write_command (cmd) != 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
//Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
|
||||
|
||||
while (mmc_read_byte() != 0xfe){};
|
||||
|
||||
//Lesen des Bolcks (normal 512Bytes) von MMC/SD-Karte
|
||||
for (unsigned int a=0;a<Bytes;a++)
|
||||
{
|
||||
*Buffer++ = mmc_read_byte();
|
||||
}
|
||||
//CRC-Byte auslesen
|
||||
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)
|
||||
MMC_Disable();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
|
||||
unsigned char mmc_read_sector (unsigned long addr,unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
//Commando 16 zum lesen eines Blocks von der MMC/SD - Karte
|
||||
unsigned char cmd[] = {0x51,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
/*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
|
||||
|
||||
cmd[1] = ((addr & 0xFF000000) >>24 );
|
||||
cmd[2] = ((addr & 0x00FF0000) >>16 );
|
||||
cmd[3] = ((addr & 0x0000FF00) >>8 );
|
||||
|
||||
mmc_read_block(cmd,Buffer,512);
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum lesen des CID Registers von der MMC/SD-Karte (16Bytes)
|
||||
unsigned char mmc_read_cid (unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
//Commando zum lesen des CID Registers
|
||||
unsigned char cmd[] = {0x4A,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
mmc_read_block(cmd,Buffer,16);
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
//############################################################################
|
||||
//Routine zum lesen des CSD Registers von der MMC/SD-Karte (16Bytes)
|
||||
unsigned char mmc_read_csd (unsigned char *Buffer)
|
||||
//############################################################################
|
||||
{
|
||||
//Commando zum lesen des CSD Registers
|
||||
unsigned char cmd[] = {0x49,0x00,0x00,0x00,0x00,0xFF};
|
||||
|
||||
mmc_read_block(cmd,Buffer,16);
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
@ -1,72 +1,81 @@
|
||||
/*#######################################################################################
|
||||
Connect ARM to MMC/SD
|
||||
|
||||
Copyright (C) 2004 Ulrich Radig
|
||||
#######################################################################################*/
|
||||
|
||||
#ifndef _MMC_H_
|
||||
#define _MMC_H_
|
||||
|
||||
#include <avr/io.h>
|
||||
|
||||
#define SPI_Mode 1 //1 = Hardware SPI | 0 = Software SPI
|
||||
//#define SPI_Mode 0
|
||||
|
||||
#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
|
||||
|
||||
#if defined (__AVR_ATmega128__)
|
||||
#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_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 SPI_SS 0 //Nicht Benutz muß aber definiert werden
|
||||
#endif
|
||||
|
||||
#if defined (__AVR_ATmega32__)
|
||||
#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_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 SPI_SS 4 //Nicht Benutz muß aber definiert werden
|
||||
#endif
|
||||
|
||||
#if defined (__AVR_ATmega644__)
|
||||
#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_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 SPI_SS 4 //Nicht Benutz muß aber definiert werden
|
||||
#endif
|
||||
|
||||
//Prototypes
|
||||
extern unsigned char mmc_read_byte(void);
|
||||
|
||||
extern void mmc_write_byte(unsigned char);
|
||||
|
||||
extern void mmc_read_block(unsigned char *,unsigned char *,unsigned in);
|
||||
|
||||
extern unsigned char mmc_init(void);
|
||||
|
||||
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_command (unsigned char *);
|
||||
|
||||
extern unsigned char mmc_read_csd (unsigned char *);
|
||||
|
||||
extern unsigned char mmc_read_cid (unsigned char *);
|
||||
|
||||
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
|
||||
#define MMC_Disable() MMC_Write|= (1<<MMC_Chip_Select);
|
||||
|
||||
//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)
|
||||
#define MMC_Enable() MMC_Write&=~(1<<MMC_Chip_Select);
|
||||
|
||||
#define nop() __asm__ __volatile__ ("nop" ::)
|
||||
|
||||
#endif //_MMC_H_
|
||||
|
||||
|
||||
/*#######################################################################################
|
||||
Connect ARM to MMC/SD
|
||||
|
||||
Copyright (C) 2004 Ulrich Radig
|
||||
#######################################################################################*/
|
||||
|
||||
#ifndef _MMC_H_
|
||||
#define _MMC_H_
|
||||
|
||||
#include <avr/io.h>
|
||||
|
||||
//#define SPI_Mode 1 //1 = Hardware SPI | 0 = Software SPI
|
||||
#define SPI_Mode 0
|
||||
|
||||
#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
|
||||
|
||||
#if defined (__AVR_ATmega128__)
|
||||
#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_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 SPI_SS 0 //Nicht Benutz muss aber definiert werden
|
||||
#endif
|
||||
|
||||
#if defined (__AVR_ATmega32__)
|
||||
#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_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 SPI_SS 4 //Nicht Benutz muss aber definiert werden
|
||||
#endif
|
||||
|
||||
#if defined (__AVR_ATmega644__)
|
||||
#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_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 SPI_SS 4 //Nicht Benutz muss aber definiert werden
|
||||
#endif
|
||||
|
||||
#if defined (__AVR_ATtiny26__)
|
||||
#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_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 SPI_SS 4 //Nicht benutzt, muss aber definiert werden
|
||||
#endif
|
||||
|
||||
|
||||
//Prototypes
|
||||
extern unsigned char mmc_read_byte(void);
|
||||
|
||||
extern void mmc_write_byte(unsigned char);
|
||||
|
||||
extern void mmc_read_block(unsigned char *,unsigned char *,unsigned in);
|
||||
|
||||
extern unsigned char mmc_init(void);
|
||||
|
||||
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_command (unsigned char *);
|
||||
|
||||
extern unsigned char mmc_read_csd (unsigned char *);
|
||||
|
||||
extern unsigned char mmc_read_cid (unsigned char *);
|
||||
|
||||
//set MMC_Chip_Select to high (MMC/SD-Karte Inaktiv)
|
||||
#define MMC_Disable() MMC_Write|= (1<<MMC_Chip_Select);
|
||||
|
||||
//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)
|
||||
#define MMC_Enable() MMC_Write&=~(1<<MMC_Chip_Select);
|
||||
|
||||
#define nop() __asm__ __volatile__ ("nop" ::)
|
||||
|
||||
#endif //_MMC_H_
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,33 @@
|
||||
|
||||
void timer_init_mega16(void)
|
||||
{
|
||||
ICR1 = (1 << 11) - 1;/* 11 bit pwm */
|
||||
OCR1A = 0;
|
||||
TCCR1A = (1 << COM1A1) | (1 << CS10) | (1 << WGM11);/* fast pwm, non inverted, top in ICR1 */
|
||||
TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS10);/* fast pwm, top in ICR1, */
|
||||
DDRD |= (1 << PD5);/* set pwm pin as output */
|
||||
TIMSK = 1 << TOIE1;/* interrupt at top */
|
||||
}
|
||||
|
||||
void timer_init_tiny45(void)
|
||||
{
|
||||
PLLCSR = 1 << PLLE;/* pll enable */
|
||||
delay_us(100);
|
||||
while(!(PLLCSR & (1 << PLOCK))) {;}/* wait for lock */
|
||||
PLLCSR |= 1 << PCKE;/* use pll */
|
||||
|
||||
OCR1C = 0xff;
|
||||
|
||||
/* output pin: OC1A = PB1 = 6 */
|
||||
OCR1A = 0;
|
||||
TCCR1 = (1 << PWM1A) | (1 << COM1A1) | (1 << CS10);/* pwm enable, non inverted, no prescaler */
|
||||
DDRB |= (1 << PB1);
|
||||
|
||||
/* output pin: OC1B = PB5 = 3 */
|
||||
//OCR1B = 0;
|
||||
//TCCR1 = (1 << CS10);/* no prescaler */
|
||||
//GTCCR = (1 << PWM1B) | (1 << COM1B1);/* pwm enable, non inverted */
|
||||
//DDRB |= (1 << PB5);
|
||||
|
||||
TIMSK = 1 << TOIE1;/* interrupt on overflow */
|
||||
}
|
||||
Loading…
Reference in new issue