int main(int argc, char *argv[]){
char test_str[] = "Hello World";
int bytes = strlen(test_str); // get number of bytes in test string
char buf[BUF_SIZE];
int ret; // return value
int bus; // which bus to use
// Parse arguments
if(argc!=2){ //argc==2 actually means one argument given
print_usage();
return -1;
}
else bus = atoi(argv[1]);
if(!(bus==0||bus==1||bus==2||bus==5)){
print_usage();
return -1;
}
// Initialization
initialize_board();
printf("\ntesting UART bus %d\n\n", bus);
if(initialize_uart(bus, BAUDRATE, TIMEOUT_S)){
printf("Failed to initialize_uart%d\n", bus);
cleanup_board();
return -1;
}
// Flush and Write
printf("Sending %d bytes: %s \n", bytes, test_str);
flush_uart(bus);
uart_send_bytes(bus, bytes, &test_str[0]);
// Read
memset(buf, 0, BUF_SIZE);
ret = uart_read_bytes(bus, bytes, &buf[0]);
if(ret<0) printf("Error reading bus\n");
else if(ret==0)printf("timeout reached, %d bytes read\n", ret);
else printf("Received %d bytes: %s \n", ret, buf);
// close up
close_uart(bus);
cleanup_board();
return 0;
}
int
main(void)
{
unsigned int pot_value;
unsigned int counter = 0;
initialize_board();
initialize_led();
initialize_uart();
initialize_adc(MODE_ANALOG0);
initialize_pwm();
uart_printf("Hello, world!\n");
while(1)
{
pot_value = adc_get_reading();
//UARTprintf ("Temperature = %3d*C \r", adc_get_temp ());
uart_printf ("AIN0 (PE3) = %3d Duty value = %d\r", pot_value,
pot_value/4);
led_toggle (GREEN_LED);
counter += 100;
if (counter > 1000)
counter = 0;
pwm_set_duty (pot_value/4);
//
// This function provides a means of generating a constant length
// delay. The function delay (in cycles) = 3 * parameter. Delay
// 250ms arbitrarily.
//
SysCtlDelay(SysCtlClockGet() / 12);
}
}
/**
*
* Main function
*
* This function is the main entry of the interrupt test. It does the following:
* Initialize the audio
* Initialize the debug uart
* Enable the interrupts
*
* @param None
*
* @return
* - XST_SUCCESS if example finishes successfully
* - XST_FAILURE if example fails.
*
* @note None.
*
******************************************************************************/
int main(void)
{
init_platform();
InitMotorBoard();
xil_printf("\r\n--- Entering main() --- \r\n");
int status = XST_SUCCESS;
status |= initialize_audio(&sIic, &sAxiAudioDma);
status |= fnInitInterruptController(&sIntc);
status |= initialize_uart(&sUartLite);
status |= initialize_video(&sVideoCapt, &sIntc);
status |= initialize_targeting(&sAxiTargetingDma);
status |= SetupSdGpio(&sGpio);
if (status != XST_SUCCESS) {
xil_printf("Failed to initialize system.\r\n");
return XST_FAILURE;
}
// Initialize static variables.
for (int i = 0; i < FILE_ID_MAX; i++) {
sSdFileBoard[i].loaded = false;
}
sSdFileMemTip = (u32 *) AUDIO_BASE_ADDR;
sButtonState = 0;
sLoopSelect = DEFAULT_LOOP;
fnEnableInterrupts(&sIntc, &ivt[0], sizeof(ivt)/sizeof(ivt[0]));
register_uart_response("test", test_fcn);
register_uart_response("record", uart_rec_audio);
register_uart_response("play", uart_play_audio);
register_uart_response("kill", end_fcn);
register_uart_response("exit", end_fcn);
register_uart_response("dump", dump_mem);
// Commands to run self-tests
register_uart_response("lowlevel", LowLevelTest);
register_uart_response("highlevel", HighLevelTest);
register_uart_response("lasertest", EnterLaserTest);
register_uart_response("motortest", EnterMotorTest);
register_uart_response("stop", stopTest);
register_uart_response("load_sounds", loadSounds);
register_uart_response("load_images", loadImages);
register_uart_response("still_alive", playPortalSong);
register_uart_response("gun", playGunSound);
register_uart_response("portal_gun", playPortalGunSound);
register_uart_response("target", playTargetAcquired);
register_uart_response("playpos", playPos);
register_uart_response("playneg", playNeg);
register_uart_response("manual", EnterManualMainLoop);
register_uart_response("auto", EnterAutomaticMainLoop);
register_uart_response("passthrough", passthroughHdmi);
register_uart_response("runip", EnterIpTest);
register_uart_response("videoinfo", print_video_info);
register_uart_response("df1", df1);
register_uart_response("df2", df2);
register_uart_response("df0", df0);
register_uart_response("vf1", vf1);
register_uart_response("vf2", vf2);
register_uart_response("vf0", vf0);
register_uart_response("ipinfo", print_ip_info);
register_uart_response("ipouttoggle", toggle_ip_output);
register_uart_response("dummytarget", setDummyTarget);
register_uart_response("lemon", DisplayLemon);
register_uart_response("heman", DisplayHeman);
register_uart_response("pass", SetPassthroughMode);
register_uart_response("gray", SetGrayscaleMode);
register_uart_response("sobel", SetSobelMode);
register_uart_response("thresh", SetThresholdMode);
register_uart_response("label", SetLabelMode);
register_uart_response("colour", SetColourMode);
register_uart_response("laser", SetLaserMode);
register_uart_response("flood1", SetFlood1Mode);
register_uart_response("flood2", SetFlood2Mode);
register_uart_response("laseron", LaserOn);
register_uart_response("laseroff", LaserOff);
register_uart_response("redthresh", SetRedThreshold);
register_uart_response("sobelthresh", SetSobelThreshold);
register_uart_response("f1thresh", SetFlood1Threshold);
register_uart_response("f2thresh", SetFlood2Threshold);
register_uart_response("setminsize", SetSizeThreshold);
register_uart_response("setobjid", SetObjId);
register_uart_response("test_args", TestArgs);
xil_printf("\r\n--- Done registering UART commands --- \r\n");
initialSetup();
xil_printf(PROMPT_STRING);
while (do_run) {
switch (sLoopSelect) {
case MANUAL_MODE: ManualMainLoop(); break;
case AUTOMATIC_MODE: AutoMainLoop(); break;
case LASER_TEST: LaserTest(); break;
case MOTOR_TEST: MotorPatternTest(); break;
case IP_TEST: runImageProcessing(); sLoopSelect = DEFAULT_LOOP; break;
default: MB_Sleep(100); break;
}
}
xil_printf("\r\n--- Exiting main() --- \r\n");
return XST_SUCCESS;
}
void main() {
int fd = initialize_uart(UART_PORT, UART_BAUD);
srand(0);
// Command Seed # accesses Offset
//send_cmd(fd, TCMD_Fill, 1000, 1 << 20, 1024);
//send_cmd(fd, TCMD_CmdRnd_AddrRnd, 1002, 1 << 20, 0);
//
// SPEC TRACES
//
/* int num_valid_blocks = 1 << 20;
//send_cmd(fd, TCMD_Fill, 1000, num_valid_blocks, 1024);
int MAX = 300000;
FILE* file = fopen("trace_hmmer_pruned.csv", "rt"); int MAX_read = 1 << 20;
//FILE* file = fopen("trace_libquantum.csv", "rt"); int MAX_read = 307607;
//FILE* file = fopen("trace_gcc_2006_pruned.csv", "rt"); int MAX_read = 1 << 20;
//FILE* file = fopen("trace_sjeng_pruned.csv", "rt"); int MAX_read = 702033;
//FILE* file = fopen("trace_bzip2_pruned.csv", "rt"); int MAX_read = 384355;
#define CHUNK 12
char buf[CHUNK];
size_t nread;
int sent_before[num_valid_blocks];
int * read_trace = (int*) malloc(sizeof(int) * num_valid_blocks);
int j;
for (j = 0; j < num_valid_blocks; j++) {
sent_before[j] = 0;
}
if (file) {
int i = 0;
int address;
char type;
int writes = 0;
int reads = 0;
int skipped = 0;
while(i < MAX && fgets(buf, CHUNK, file) != NULL) {
sscanf (buf, "%c %x\n", &type, &address);
if (address > num_valid_blocks) {
printf("WARNING: access=%d addr %x too large\n", i, address);
address = 0;
}
else if (sent_before[address] == 0) {
printf ("sent write %x\n", address);
send_cmd(fd, CMD_Update, address, 0, 0);
sent_before[address] = 1;
writes++;
}
read_trace[i] = address;
//send_cmd(fd, CMD_Read, address, 0, 0);
i++;
}
i = 0;
while (reads < MAX_read && i < MAX) {
int caddr = read_trace[i];
if (caddr) {
printf ("%d: sent read %x\n", reads, caddr);
send_cmd(fd, CMD_Read, caddr, 0, 0);
reads++;
} else printf ("WARNING: skipped read %d\n", i);
i++;
}
printf("Done; writes=%d, reads=%d\n", writes, reads);
fclose(file);
}
*/
// Random accesses
int num_valid = 1 << 13;
int i;
int Nread = num_valid;
for (i = 0; i < Nread; i++) {
send_cmd(fd, CMD_Update, i, 0, 0);
}
int Nwrite = Nread << 0;
for (i = 0; i < Nwrite; i++) {
send_cmd(fd, CMD_Read, rand() % Nread, i, 0);
}
// Simple stride
/*
int i;
int Nread = 1 << 15;
for (i = 0; i < Nread; i++) {
send_cmd(fd, CMD_Update, i, 0, 0);
if (i % 100000 == 0) printf("Wrote %d\n", i);
}
int Nwrite = Nread << 0;
for (i = 0; i < Nwrite; i++) {
send_cmd(fd, CMD_Read, i % Nread, i, 0);
if (i % 100000 == 0) printf("Read %d\n", i);
}
*/
// Access same place always
// Status: fine
/*
int i;
int Nread = 1000;
for (i = Nread; i >= 0; i--) {
send_cmd(fd, CMD_Update, i, 0, 0);
}
int Nwrite = 1000;
for (i = 0; i < Nwrite; i++) {
send_cmd(fd, CMD_Read, 0, i, 0);
}
*/
// Ask the FPGA board to send the histogram
send_start_cmd(fd);
}
/*
* Sets up the device to use STDIO over serial.
*/
void set_up_stdio_over_serial() {
initialize_uart();
set_up_special_files();
}
