Subversion Repositories z80soc

#include <de2115.h>
#include <z80soc.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
void delay(int count) {
	if (count > 0) {
		for (count; count>0; count--) {
			readMemory(0x0000);
		}
	}
}
 
// blink leds until pushbutton 0 is pressed
void waitToExit(void) {
    while (pushButton() != 0b00000001) {
        greenLeds(0xFF);
        delay(5000);
        greenLeds(0x00);
        delay(5000);
    }
}
 
unsigned char testmodule(unsigned int baseAddress, unsigned int endAddress, short int baseAddressL, short int baseAddressH) {
 
    unsigned char currdip = dipSwitchA();
    unsigned char mychar  = 0;
 
    while (baseAddress < endAddress) {
        hexlsb0(baseAddressL);
        hexmsb0(baseAddressH);
 
        mychar = 0x41;
        hexmsb1(mychar);
        writeMemory(baseAddress, mychar);
 
        mychar = 0xAA;
        mychar = readMemory(baseAddress);
        hexlsb1(mychar);
 
        if ( mychar == 0x41) {
            greenLeds(readMemory(baseAddress));
            baseAddressL++;
            baseAddress++;
            if (baseAddressL > 0xFF) {
                baseAddressL = 0x00;
                baseAddressH++;
            }
        } else {
            waitToExit();
            return 0xFF;
        }
    }
 
    waitToExit();
    return 0xAA;
}
 
unsigned char testvram(void) {
    unsigned char nchar = 0;
    unsigned int addr = readMemoryInt(0x57D4);
    unsigned int endaddr = addr + 4800;
 
    hexlsb0(readMemory(0x57D4));
    hexmsb0(readMemory(0x57D5));
    while (addr < endaddr) {
        writeMemory(addr,nchar);
        nchar++;
        if (nchar == 255) nchar = 0;
        addr++;
    }
    waitToExit();
    return 0xAA;
}
 
unsigned char testlcd(void) {
    unsigned char nchar = 0;
    unsigned int addr = readMemoryInt(0x57DC);
 
    hexlsb0(readMemory(0x57DC));
    hexmsb0(readMemory(0x57DD));
 
    printlcd(0,"**** Z80SoC ****");
    printlcd(16,"  Retro-CPU.run ");
 
    waitToExit();
    return 0xAA;
}
 
unsigned char lcdcls(void) {
    unsigned char nchar = 0;
    unsigned int addr = readMemoryInt(0x57DC);
 
    hexlsb0(readMemory(0x57DC));
    hexmsb0(readMemory(0x57DD));
    while (nchar < 32) {
        writeMemory(addr,32);
        nchar++;
        addr++;
    }
    return 0xAA;
}
 
unsigned char testCharRam(void) {
    // will redefine char with ascii codes 1 to 4
    unsigned int baseAddress = readMemoryInt(0x57D6) + 8;
    short int i;
    unsigned char hero_bits[] = {
        0x01,0x01,0x03,0x13,0x13,0x97,0x97,0x9e,
        0x80,0x80,0xc0,0xc8,0xc8,0xe9,0xe9,0x79,
        0xbc,0xbd,0xff,0xff,0xfb,0xf3,0xe1,0xc1,
        0x3d,0xbd,0xff,0xff,0xdf,0xcf,0x87,0x83
    };
 
    for (i = 0; i < 32; i++) {
        writeMemory(baseAddress + i, hero_bits[i]);
    }
 
    writeMemory(readMemoryInt(0x57D4) + 10*80 + 31,1);
    writeMemory(readMemoryInt(0x57D4) + 10*80 + 32,2);
    writeMemory(readMemoryInt(0x57D4) + 11*80 + 31,3);
    writeMemory(readMemoryInt(0x57D4) + 11*80 + 32,4);
 
    waitToExit();
    return 0xAA;
}
 
unsigned char testprintf(char s[]) {
    // set device output to video
    writeMemory(0x57CD,0);
 
    hexlsb0(readMemory(0x57D0));
    hexmsb0(readMemory(0x57D1));
 
    printf(s);
 
    return 0xAA;
}
 
void main(void) {
 
    unsigned char SW = 0;
    short int LEDCOUNT = 0;
    short int baseAddressL;
    short int baseAddressH;
    unsigned int baseAddress = 0;
    unsigned int endAddress = 0;
    unsigned int myvramaddr;
    int i;
    int direction;
 
    myvramaddr = readMemoryInt(0x57D4) + (5 * 32);
    writeMemoryInt(0x57D0, myvramaddr);
 
    cls();
    lcdonoff(1);
 
    printlcd(0,"TestSys Z80SoC  ");
    if (readMemory(0x57DF) == 0) {
        printlcd(16,"  running on DE1");
    } else if (readMemory(0x57DF) == 1) {
        printlcd(16,"  running on S3E");
    } else if (readMemory(0x57DF) == 2) {
        printlcd(16,"  running on DE2");
    }
 
    while (1) {
 
    cursorxy(15,3);
    printf("TestSys - A hardware test program for the Z80SoC");
 
    redLedsA(LEDCOUNT);
    LEDCOUNT++;
 
    SW = dipSwitchA();
 
     switch (SW) {
        case 1:
            // test sram
            printf("\n\n\n      Testing RAM. Check the address being tested on the 7SEG Display");
            baseAddressL = readMemory(0x57D8);
            baseAddressH = readMemory(0x57D9);
            baseAddress = readMemoryInt(0x57D8);
            endAddress = readMemoryInt(0x57DA) - 0x100;
            hexmsb1(testmodule(baseAddress, endAddress, baseAddressL, baseAddressH));
            waitToExit();
            break;
        case 2:
            // test vram
            //hexmsb1(testvram());
             baseAddressL = readMemory(0x57D4);
             baseAddressH = readMemory(0x57D5);
             baseAddress = readMemoryInt(0x57D4);
             endAddress = readMemoryInt(0x57D8);
             hexmsb1(testmodule(baseAddress, endAddress, baseAddressL, baseAddressH));
             waitToExit();
             cls();
            break;
        case 4:
             // test lcd
             if (readMemory(0x57DF) == 0) {
                 printf("\n\n\n     DE1 platform don't have LCD display");
                 waitToExit();
                 cls();
             } else {
                     printf("\n\n\n      Check the LCD display");
                     lcdonoff(0);
                     waitToExit();
                     lcdonoff(1);
                    }
             break;
        case 8:
             // test lcd
             if (readMemory(0x57DF) == 0) {
                 printf("\n\n\n     DE1 platform don't have LCD display");
                 waitToExit();
                 cls();
             } else {
                     printf("\n\n\n      Check the LCD display");
                     hexmsb1(testlcd());
                     waitToExit();
                     printlcd(0,"TestSys Z80SoC  ");
 
                    if (readMemory(0x57DF) == 1) {
                        printlcd(16,"  running on S3E");
                    } else if (readMemory(0x57DF) == 2) {
                              printlcd(16,"  running on DE2");
                           }
              }
             break;
        case 16:
            // test charram
            hexlsb0(readMemory(0x57D6));
            hexmsb0(readMemory(0x57D7));
            hexmsb1(testCharRam());
            waitToExit();
            cls();
            break;
         case 32:
             printf("\n\n\n              Testing the printf C function and newlines \\n");
             cursorxy(10,10);
             printf("1******************** Z80SoC ********************");
             cursorxy(10,11);
             printf("2******************** Z80SoC ********************");
             cursorxy(10,12);
             printf("3******************** Z80SoC ********************");
             printf("<< end>>");
 
             printf("\n>>>printing after\n\n\n\n>>>four new lines\n");
 
             hexlsb0(readMemory(0x57D0));
             hexmsb0(readMemory(0x57D1));
 
             printf("    1\n");
             printf("    2\n");
             printf("    3\n\n");
             printf("    4\n");
 
             waitToExit();
             cls();
             break;
         case 64:
             cls();
             cursorxy(5,2);
             printf("Testing char type storage and retrieve using writeMemory() function\n");
             cursorxy(5,3);
             printf("Confirms that a single byte is being written");
             baseAddress = readMemoryInt(0x57D8);
             for (i=0; i<10; i++) {
                 writeMemory(baseAddress + i, i);
                 writeMemory(baseAddress + 20 + 9 - i, 9 - i);
             }
 
             cursorxy(5,5);
             printf("written up down");
             cursorxy(40,5);
             printf("written down up");
 
             for (i=0; i<10; i++) {
                 cursorxy(5,6+i);
                 printf("%d",readMemory(baseAddress + i));
                 cursorxy(40,6+i);
                 printf("%d",readMemory(baseAddress + 20 + i));
             }
 
             waitToExit();
             cls();
             break;
         case 128:
             // random number generator test
             printf("\n    Testing the random integer number generator implemented inside thr FPGA (0xFFCA)");
             cursorxy(5,5);
             for (i=0; i<2000; i++) {
                 direction = readMemoryInt(0x57C9); // get a rumdom number - integer
                 printf("%i ",direction);
             }
             waitToExit();
             cls();
             break;
     }
   }
}