int main(void)
{
static unsigned char buffer[BUFFER_SIZE];
unsigned short i;
unsigned char timeout = 3;
RTCTime local_time;
SystemInit();
// IODIR0 |= (P0_15|P0_16|P0_17); // some outputs for debugging and measures
//P0_16 ReadSector() in mmc_spi.c
//P0_17 enc28j60 write packet
//P0_15 general purpose, BE AWARE !
// uart1Init(B38400, UART_8N1, UART_FIFO_8); // setup the UART
uart1Init(B115200, UART_8N1, UART_FIFO_8); // setup the UART
rprintf_devopen( uart1_sendchar ); /* init rprintf */
VICIntEnClear = 0xFFFFFFFF;
VICIntSelect = 0x00000000;
RTCInit();
/* current date 05.08.2007 20:45:00*/
local_time.RTC_Sec = 0;
local_time.RTC_Min = 45;
local_time.RTC_Hour = 20;
local_time.RTC_Mday = 5;
local_time.RTC_Wday = 3; // My monday has 0
local_time.RTC_Yday = 1;
local_time.RTC_Mon = 8;
local_time.RTC_Year = 2007;
RTCSetTime( local_time ); /* Set local time */
// RTCStart();
init_timer();
enableIRQ();
printf("Holgi's ARM7 LPC213x MultiFAT Speed Test\n\r");
MMC_IO_Init();
enc28j60_io_init(); // You don't need this ! It's for my board only.
while (GetDriveInformation() != F_OK && timeout--)
{
printf ("MMC/SD-Card not found !\n\r");
HaltCPU();
}
ShowDOSConfig(); // show selected DOS details from dosdefs.h
/*
// test time measurement
StartTimer();
timer_value = SetDelay10ms(1000); // delay 10 seconds
while(CheckDelay10ms(timer_value)==0);
StopTimer(); // stop measure and show results
// result is 2MB in 10s -> 200kB/s
// end test time measurement
*/
printf("\nTest directory functions\n");
Chdir("dir1");
Remove("dir4");
Chdir("/"); // Back to root
Remove("dir1");
Mkdir("dir1");
Chdir("dir1");
Mkdir("dir2");
Mkdir("dir3");
Rename("dir3","dir4");
Remove("dir2");
// You should have now:
// dir1/dir4
Chdir("/"); // Back to root
printf("\nDeleting files\n");
Remove("01.bin"); //Remove last data
Remove("02.bin");
Remove("04.bin");
Remove("08.bin");
Remove("16.bin");
Remove("32.bin");
Remove("64.bin");
Remove("77.bin");
Remove("128.bin");
Remove("MAX.bin");
//Fill the test buffer
for(i=0; i<BUFFER_SIZE; i++) buffer[i]=(unsigned char)(i);
printf("\nStart writing files\n");
WriteTestFile("01.bin",buffer,1);
WriteTestFile("02.bin",buffer,2);
WriteTestFile("04.bin",buffer,4);
WriteTestFile("08.bin",buffer,8);
WriteTestFile("16.bin",buffer,16);
WriteTestFile("32.bin",buffer,32);
WriteTestFile("64.bin",buffer,64);
WriteTestFile("77.bin",buffer,77);
WriteTestFile("128.bin",buffer,128);
WriteTestFile("MAX.bin",buffer,BUFFER_SIZE);
printf("\nStart reading files\n");
ReadTestFile("01.bin",buffer,1);
ReadTestFile("02.bin",buffer,2);
ReadTestFile("04.bin",buffer,4);
ReadTestFile("08.bin",buffer,8);
ReadTestFile("16.bin",buffer,16);
ReadTestFile("32.bin",buffer,32);
ReadTestFile("64.bin",buffer,64);
ReadTestFile("77.bin",buffer,77);
ReadTestFile("128.bin",buffer,128);
ReadTestFile("MAX.bin",buffer,BUFFER_SIZE);
printf("\nVerifying files\n");
VerifyTestFile("32.bin",buffer,32);
VerifyTestFile("64.bin",buffer,64);
VerifyTestFile("77.bin",buffer,77);
VerifyTestFile("128.bin",buffer,128);
VerifyTestFile("MAX.bin",buffer,BUFFER_SIZE);
printf("Test done.\n");
// test if RTC is running
local_time=RTCGetTime();
printf("%02u:%02u:%02u %02u.%02u.%04u\n\r",local_time.RTC_Hour,local_time.RTC_Min,local_time.RTC_Sec
,local_time.RTC_Mday,local_time.RTC_Mon,local_time.RTC_Year );
while(1)
{
/*
if(CheckDelay10ms(timer_value))
{
timer_value = SetDelay10ms(1000); // delay 10 seconds
// test if RTC is running
local_time=RTCGetTime();
printf("%02u:%02u:%02u %02u.%02u.%04u\n\r",local_time.RTC_Hour,local_time.RTC_Min,local_time.RTC_Sec
,local_time.RTC_Mday,local_time.RTC_Mon,local_time.RTC_Year );
}
*/
}
return(0);
}
/**
Handle incomming frames from the serial port.
*/
void rxhandler(void) {
switch (serRxBuf.header.type) {
case ACK:
case NACK:
break;
case T_CONNECT: //connect JTAG to the target
InitTarget();
if (GetDevice() == STATUS_OK) {
txACK();
//printf("Device type: %04x\n", DEVICE);
} else{
txNACKstr("no target");
}
break;
case T_RELEASE: //release JTAG from target
ClrTCLK();
IR_Shift(IR_CNTRL_SIG_16BIT);
DR_Shift16(0x3001); //lch
IR_Shift(IR_CNTRL_SIG_RELEASE);
SetTCLK();
ReleaseTarget();
txACK();
break;
case T_RESET: //reset the target and release JTAG
ReleaseDevice(V_RESET);
ReleaseTarget();
txACK();
break;
case T_PUC: //reset the target through JTAG, keep connection
ExecutePUC();
txACK();
break;
case T_MEMREAD: //ream memory from target
{ //use a new block for local vars
word size = serRxBuf.data.memread.size;
word address = serRxBuf.data.memread.address;
word offset;
txACK();
HaltCPU();
if (size > sizeof(serTxBuf.data.memdata.data)) {
size = sizeof(serTxBuf.data.memdata.data);
}
if (address <= 0xff) { //peripherals in bytemode
for (offset = 0; offset < size; offset++) {
serTxBuf.data.memdata.data[offset] = ReadMem(F_BYTE, address+offset);
}
} else { //peripherals in wordmode as well as RAM and Flash
address = address & 0xfffe; //startaddress has to be even!
for (offset = 0; offset < size/2; offset++) {
((word *)serTxBuf.data.memdata.data)[offset] = ReadMem(F_WORD, address+offset*2);
}
if (size & 1) {
//odd size, read last byte separate
//odd sizes on word-mode peripherals yield wrong results
//in the last word!!
serTxBuf.data.memdata.data[size-1] = ReadMem(F_BYTE, address+size-1);
}
}
serTxBuf.data.memdata.address = address;
serTxBuf.header.type = T_MEMDATA;
serTxBuf.header.size = 2+size;
sendMessage(&serTxBuf);
}
break;
case T_MEMWRITE: //write target memory (Peripherals, RAM, Flash)
{
word offset;
word size = serRxBuf.header.size - 2;
HaltCPU();
if ((serRxBuf.data.memwrite.address >= 0x100) &&
(serRxBuf.data.memwrite.address <= 0x1ff)) { //peripherals in wordmode
for (offset = 0; offset < size; offset+=2) {
WriteMem(F_WORD,
serRxBuf.data.memwrite.address+offset,
((word*)serRxBuf.data.memwrite.data)[offset/2]
);
}
} else if (serRxBuf.data.memwrite.address < 0x1000) { //ram + peripherals, bytemode
for (offset = 0; offset < size; offset++) {
WriteMem(F_BYTE,
serRxBuf.data.memwrite.address+offset,
serRxBuf.data.memwrite.data[offset]
);
}
} else { //flash memory, wordmode
WriteFLASH(serRxBuf.data.memwrite.address,
size/2,
(word *)serRxBuf.data.memwrite.data
);
}
txACK();
}
break;
case T_EXEC: //execute target program located at given address
ReleaseDevice(serRxBuf.data.exec.address);
txACK();
break;
case T_MEMERASE: //erase target flash (Segment, Main or All)
HaltCPU();
EraseFLASH(
serRxBuf.data.memerase.mode,
serRxBuf.data.memerase.address
);
txACK();
break;
case T_MCLK: //provide MCLKs, allows sort of single stepping
ClrTCLK();
IR_Shift(IR_CNTRL_SIG_16BIT);
DR_Shift16(0x3401); //lch
while (serRxBuf.data.step.numsteps--) {
SetTCLK();
ClrTCLK();
}
SetTCLK();
txACK();
break;
case MEMREAD: //host memory read
{
word size = serRxBuf.data.memread.size;
byte *address = (byte*)serRxBuf.data.memread.address;
word offset;
txACK();
if (size > sizeof(serTxBuf.data.memdata.data)) {
size = sizeof(serTxBuf.data.memdata.data);
}
if (address <= (byte *)0xff) { //bytemode
for (offset = 0; offset < size; offset++) {
serTxBuf.data.memdata.data[offset] = address[offset];
}
} else { //wordmode
address = (byte *)((word)address & 0xfffe); //startaddress has to be even!
size &= 0xfffe; //size has to be even
for (offset = 0; offset < size/2; offset++) {
((word *)serTxBuf.data.memdata.data)[offset] = ((word *)address)[offset];
}
}
serTxBuf.data.memdata.address = (word)address;
serTxBuf.header.type = MEMDATA;
serTxBuf.header.size = 2+size;
sendMessage(&serTxBuf);
}
break;
case MEMWRITE: //host memory write, used to download user programs
{
void *adr = (byte *)serRxBuf.data.memwrite.address;
word offset;
word size = serRxBuf.header.size - 2;
if ((adr >= (void *)0x100) && (adr <= (void *)0x1ff)) { //peripherals, wordmode
for (offset = 0; offset < size/2; offset++) {
((word *)adr)[offset] = ((word *)serRxBuf.data.memwrite.data)[offset];
}
txACK();
return;
}
if (adr < (void *)0x1000) { //ram + peripherals, bytemode
for (offset = 0; offset < size; offset++) {
((byte *)adr)[offset] = serRxBuf.data.memwrite.data[offset];
}
} else { //flash
flashWriteBlock(
serRxBuf.data.memwrite.data,
(void *)serRxBuf.data.memwrite.address,
size);
}
txACK();
}
break;
case MEMERASE: //erase one segemnt on host
flashErase((void *)serRxBuf.data.memerase.address);
txACK();
break;
//~ case MEMEXEC: //exec code on host
//~ serRxBuf.memexec.function(
//~ serRxBuf.memexec.arg1,
//~ serRxBuf.memexec.arg2
//~ );
//~ txACK();
//~ break;
case STARTBSL: //start BSL for firmware upgrade
txACK();
while((UTCTL0 & TXEPT) == 0) {} //wait until last byte is sent
FCTL3 = 0; //generate a flash key violation -> POR reset, see main()
break;
default:
txNACKstr("unknown command"); //serialComm error: unknown command
}
}
