//====================================================
// enables/disables cache
//====================================================
void caching(Xuint8 Enable) {
if (Enable) {
/*
* Enable and initialize cache
*/
#if XPAR_MICROBLAZE_0_USE_ICACHE
xil_printf("Enabling and initializing instruction cache\r\n");
microblaze_enable_icache();
#endif
#if XPAR_MICROBLAZE_0_USE_DCACHE
xil_printf("Enabling and initializing data cache\r\n");
microblaze_enable_dcache();
#endif
} else {
#if XPAR_MICROBLAZE_0_USE_DCACHE
xil_printf("Disabling data cache\r\n");
microblaze_disable_dcache();
#endif
#if XPAR_MICROBLAZE_0_USE_ICACHE
xil_printf("Disabling instruction cache\r\n");
microblaze_disable_icache();
#endif
}
}
// Main event loop
int main()
{
proc_interface_t hwti;
// Get HWTI base address from user PVR register
int hwti_base;
getpvr(1,hwti_base);
// Enable instruction cache (reduce PLB load)
microblaze_init_icache_range(0, 8192);
microblaze_enable_icache();
while(1)
{
// Setup interface
// * Perform this upon each iteration, just in case the memory
// map for the MB-HWTI is corrupted.
initialize_interface(&hwti,(int*)(hwti_base));
// Wait to be "reset"
// -- NOTE: Ignore reset as it has no meaning to the MB-HWTI
// and it seems causes a race, as the controlling processor
// sends a reset, immediately followed by a "go" command. Therefore
// the "reset" command can be missed.
//wait_for_reset_command(&hwti);
// Wait to be "started"
wait_for_go_command(&hwti);
//xil_printf("Thread started (fcn @ 0x%08x), arg = 0x%08x!!!\r\n",*(hwti.fcn_reg), *(hwti.arg_reg));
// Setup r20 for thread (only needed for PIC code, i.e. print-related functions)
mtgpr(r20, *(hwti.fcn_reg));
// Boostrap thread
// * Pull out thread argument, and thread start function
_bootstrap_thread(&hwti, *(hwti.fcn_reg), *(hwti.arg_reg));
//_bootstrap_thread(&hwti, factorial_thread, *(hwti.arg_reg)); // Use this when hard-coding functionality
}
return 0;
}
void
enable_caches()
{
#ifdef __PPC__
XCache_EnableICache(CACHEABLE_REGION_MASK);
XCache_EnableDCache(CACHEABLE_REGION_MASK);
#elif __MICROBLAZE__
#ifdef XPAR_MICROBLAZE_USE_ICACHE
microblaze_invalidate_icache();
microblaze_enable_icache();
#endif
#ifdef XPAR_MICROBLAZE_USE_DCACHE
microblaze_invalidate_dcache();
microblaze_enable_dcache();
#endif
#endif
}
int main() {
proc_interface_t hwti;
// Get HWTI base address from user PVR register
int hwti_base;
getpvr(1,hwti_base);
// Enable instruction cache (reduce PLB load)
microblaze_invalidate_icache();
microblaze_enable_icache();
microblaze_invalidate_dcache();
microblaze_disable_dcache();
// Nano-kernel loop...
while(1) {
// Setup interface
// * Perform this upon each iteration, just in case the memory
// map for the MB-HWTI is corrupted.
initialize_interface(&hwti,(int*)(hwti_base));
#if 0 // Commented out as this is not necessary and it creates the opportunity for a race between reset and start commands
// Wait to be "reset"
// -- NOTE: Ignore reset as it has no meaning to the MB-HWTI
// and it seems causes a race, as the controlling processor
// sends a reset, immediately followed by a "go" command. Therefore
// the "reset" command can be missed.
wait_for_reset_command(&hwti);
#endif
// Wait to be "started"
wait_for_go_command(&hwti);
//xil_printf("Thread started (fcn @ 0x%08x), arg = 0x%08x!!!\r\n",*(hwti.fcn_reg), *(hwti.arg_reg));
// Setup r20 for thread, this can be used to enforce -fPIC (Position-independent code) for the MB
// (r20 is used as part of the GOT, to make things PC-relative)
mtgpr(r20, *(hwti.fcn_reg));
// Boostrap thread (wraps up thread execution with a thread exit)
// * Pull out thread argument, and thread start function
_bootstrap_thread(&hwti, *(hwti.fcn_reg), *(hwti.arg_reg));
}
return 0;
}
int main_SDHCExample()
{
unsigned int j;
char *filters[] = {".JPG", ".PNG", NULL};
int status;
#if 0
#ifdef XPAR_MICROBLAZE_USE_ICACHE
microblaze_invalidate_icache();
microblaze_enable_icache();
#endif
#ifdef XPAR_MICROBLAZE_USE_DCACHE
microblaze_invalidate_dcache();
microblaze_enable_dcache();
#endif
#endif
status = is_sd_accessible();
if(status == -1)
{
xil_printf("SD card is not accessible.. insert properly and rerun\n");
return -1;
}
/* Initialize FATFS and timer */
f_mount(0, &fs);
#ifdef MEASURE_SPEED
swConfig_initTimerSubsystem();
#endif
/* Scan file structure */
scan_files_recursive(""); // param: parent path
xil_printf("total files: %d\n", file_counter);
filter_file_list(filters, filter_filename_string, MAX_NUM_OF_FILES_TO_COPY,32);
#ifdef COPY_FILES
/* Copy and verify all scanned files */
for(j = 0;j < file_counter; j++)
{
//xil_printf("%s\n", in_filename_string[j]);
#if 0
PRINT("\n\rCopying file %d of %d...\n\r", (j + 1), file_counter);
if((strlen(in_filename_string[j]) > (8 + 3 + 1)) || (strlen(out_filename_string[j]) > (8 + 3 + 1)))
{
PRINT("\n\rFilename %s is to long for filesystem!\n\r", out_filename_string[j]);
PRINT("Only filenames of max 8 + 3 characters(xxxxxxxx.yyy) are supported\n\r\n\r");
}
else
{
copy_file(in_filename_string[j], out_filename_string[j]);
}
#endif
}
#endif
#ifdef MEASURE_SPEED
printf("Top write speed = %8.2f for data size = %8d\n\r", top_write_speed, top_write_data_size);
printf("Top read speed = %8.2f for data size = %8d\n\r", top_read_speed, top_read_data_size);
#endif
f_mount(0, (FATFS *)0);
PRINT("SD Card test end\n\r");
//while(1);
return 0;
}
int main(void)
{
int Status;
/*
* Enable and initialize cache
*/
#if !SIM
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_invalidate_icache();
microblaze_enable_icache();
#endif
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_invalidate_dcache();
microblaze_enable_dcache();
#endif
#endif
XUartNs550_SetBaud(UART_BASEADDR, UART_CLOCK, UART_BAUDRATE);
XUartNs550_SetLineControlReg(UART_BASEADDR, XUN_LCR_8_DATA_BITS);
xil_printf("\n\r********************************************************");
xil_printf("\n\r********************************************************");
xil_printf("\n\r** SP605 - Temac Test **");
xil_printf("\n\r********************************************************");
xil_printf("\n\r********************************************************\r\n");
printf("Setting Temac and DMA\r\n");
printf("\r\n");
/*
* Call the Temac SGDMA interrupt example , specify the parameters generated
* in xparameters.h
*/
Status = TemacSgDmaIntrExample(&IntcInstance,
&TemacInstance,
&DmaInstance,
TEMAC_DEVICE_ID,
TEMAC_IRPT_INTR,
DMA_RX_IRPT_INTR, DMA_TX_IRPT_INTR);
if (Status != XST_SUCCESS) {
TemacUtilErrorTrap("Failure in Examples");
return XST_FAILURE;
}
printf("Received Packet!\r\n");
printf("\r\n");
#if !SIM
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_disable_dcache();
microblaze_invalidate_dcache();
#endif
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_disable_icache();
microblaze_invalidate_icache();
#endif
#endif
return_to_loader();
return 0;
}
int main() {
XStatus Status;
u32 btnsw = 0x00000000, old_btnsw = 0x000000FF, diff_btnsw;
u32 leds;
int rotcnt, old_rotcnt;
Test_t test;
ParamSel_t param_select;
bool wrlcd_dynamic;
bool wrlcd_static;
// initialize devices and set up interrupts, etc.
Status = do_init();
if (Status != XST_SUCCESS) {
LCD_setcursor(1, 0);
LCD_wrstring("****** ERROR *******");
LCD_setcursor(2, 0);
LCD_wrstring("INIT FAILED- EXITING");
exit(XST_FAILURE);
}
// initialize the global variables
timestamp = 0;
pwm_freq = PWM_FREQUENCY_HZ;
pwm_duty = PWM_STEPDC_MIN;
// initialize the local variables
btnsw = 0x00;
old_btnsw = 0x00;
rotcnt = 0;
old_rotcnt = 0;
param_select = SLCT_GP;
wrlcd_dynamic = true;
wrlcd_static = true;
leds = LEDS_ALLOFF;
_prev_button_down_count = 0;
// Enable the Microblaze caches and
// kick off the processing by enabling the Microblaze interrupt
// this starts the FIT timer which updates the timestamp.
if (USE_ICACHE == 1) {
microblaze_invalidate_icache();
microblaze_enable_icache();
}
if (USE_DCACHE == 1) {
microblaze_invalidate_dcache();
microblaze_enable_dcache();
}
microblaze_enable_interrupts();
// display the greeting
LCD_setcursor(1, 0);
LCD_wrstring("ECE544 Project 2");
LCD_setcursor(2, 0);
LCD_wrstring("Starter App-R5.0");
NX3_writeleds(LEDS_ALLON);
delay_msecs(2000);
NX3_writeleds(LEDS_ALLOFF);
// Set the PWM and ADC min and max counts by forcing a characterization
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Characterizing..");
DoTest_Characterize();
LCD_setcursor(2, 0);
LCD_wrstring("...Done ");
//*****GAIN AND OFFSET ARE HARDWIRED IN THE STARTER APP *****
// initialize the control parameters
// start the set point in the middle of the range
setpoint = (ADC_max_cnt - ADC_min_cnt) / 2;
offset = 100;
GP = 10;
GD = 5;
GI = 5;
init_high = false;
//*****GAIN AND OFFSET ARE HARDWIRED IN THE STARTER APP *****
// main loop - there is no exit except by hardware reset
while (1) {
// write static portion of output to display
if (wrlcd_static) {
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("G|Pxxx Ixxx Dxxx");
LCD_setcursor(2, 0);
LCD_wrstring("SP:+x.xx OFF:xxx");
wrlcd_static = false;
}
// write the dynamic portion of output to display
if (wrlcd_dynamic) {
Xfloat32 v;
u16 count;
char s[20];
u32 row, col;
// display GP, GI, and GD
LCD_setcursor(1, 3);
LCD_wrstring(" ");
LCD_setcursor(1, 3);
LCD_putnum(GP, 10);
LCD_setcursor(1, 8);
LCD_wrstring(" ");
LCD_setcursor(1, 8);
LCD_putnum(GI, 10);
LCD_setcursor(1, 13);
LCD_wrstring(" ");
LCD_setcursor(1, 13);
LCD_putnum(GD, 10);
LCD_setcursor(2, 13);
LCD_wrstring(" ");
LCD_setcursor(2, 13);
LCD_putnum(offset, 10);
// display the setpoint in volts
count = setpoint;
v = PmodCtlSys_ADCVolts(count);
voltstostrng(v, s);
LCD_setcursor(2, 3);
LCD_wrstring(" ");
LCD_setcursor(2, 3);
LCD_wrstring(s);
// place the cursor under the currently selected parameter
LCD_docmd(LCD_DISPLAYONOFF, LCD_CURSOR_OFF);
switch (param_select) {
case SLCT_OFFSET:
row = 2;
col = 13;
break;
case SLCT_GP:
row = 1;
col = 3;
break;
case SLCT_GD:
row = 1;
col = 13;
break;
case SLCT_GI:
row = 1;
col = 8;
break;
case SLCT_INVALID:
break;
}
if (param_select != SLCT_INVALID) {
LCD_setcursor(row, col);
LCD_docmd(LCD_DISPLAYONOFF, LCD_CURSOR_ON);
}
wrlcd_dynamic = false;
}
// read switches and buttons to get the test to perform and its initial value
// display the selected test on the LEDs
NX3_readBtnSw(&btnsw);
init_high = (btnsw & SW_INIT_HILO) ? true : false;
test = btnsw & SW_TEST_SELECT;
//update the HI/LO and TEST LEDs
leds &= ~(LEDS_HILO | LEDS_TEST);
leds |= (init_high == true) ? LEDS_HILO : 0;
leds |= test << 3;
NX3_writeleds(leds);
// read rotary count and handle setpoint changes
// accelerate setpoint if speedup threshold has been exceeded
// Use MIN and MAX to keep scaled ADC count within range
ROT_readRotcnt(&rotcnt);
if (rotcnt != old_rotcnt) {
if (abs(rotcnt - old_rotcnt) > ROTCNT_SPEEDUP_GATE) {
setpoint += (rotcnt - old_rotcnt) * ROTCNT_DELTA
* ROTCNT_SPEEDUP_FACTOR;
} else {
setpoint += (rotcnt - old_rotcnt) * ROTCNT_DELTA;
}
setpoint = MAX(ADC_min_cnt, MIN(setpoint, ADC_max_cnt));
old_rotcnt = rotcnt;
wrlcd_dynamic = true;
} // rotary count changed
//***** NOTE: User interface handling should go in this section. *****
//***** The starter app just lets the user select the setpoint and *****
//***** run the test selected by the switches *****
// look at the buttons and take action on the rising edge of a button press
bool north_button = btnsw & msk_BTN_NORTH;
bool east_button = btnsw & msk_BTN_EAST;
bool west_button = btnsw & msk_BTN_WEST;
bool button_down = north_button || east_button || west_button;
if (button_down)
{
_prev_button_down_count++;
if (_prev_button_down_count > 5)
_prev_button_down_count = 5;
if (north_button) {
switch (param_select) {
case SLCT_GP:
param_select = SLCT_GI;
break;
case SLCT_GI:
param_select = SLCT_GD;
break;
case SLCT_GD:
param_select = SLCT_OFFSET;
break;
case SLCT_OFFSET:
param_select = SLCT_GP;
break;
}
wrlcd_dynamic = true;
}
if (east_button) {
switch (param_select) {
case SLCT_GP:
GP+=_prev_button_down_count;
break;
case SLCT_GI:
GI+=_prev_button_down_count;
break;
case SLCT_GD:
GD+=_prev_button_down_count;
break;
case SLCT_OFFSET:
offset+=_prev_button_down_count;
break;
}
wrlcd_dynamic = true;
}
if (west_button) {
switch (param_select) {
case SLCT_GP:
GP-=_prev_button_down_count;
break;
case SLCT_GI:
GI-=_prev_button_down_count;
break;
case SLCT_GD:
GD-=_prev_button_down_count;
break;
case SLCT_OFFSET:
offset-=_prev_button_down_count;
break;
}
wrlcd_dynamic = true;
}
} else {
_prev_button_down_count = 0;
}
btnsw &= BTN_MSK_ALLBUTTONS;
diff_btnsw = (btnsw ^ old_btnsw) & btnsw;
old_btnsw = btnsw;
if (diff_btnsw & BTN_RUN_XFER) // run a test
{
Xfloat32 vADC, vSP; // VADC from circuit and Vsetpoint
char s1[20], s2[30]; // display and print strings
int (*funcPtr)(void); // pointer to test function
int n; // number of samples to transfer (returned by test functions)
switch (test) // set up for the selected test
{
case TEST_BB: // Bit Bang control
strcpy(s1, "|BB |Press RBtn");
strcpy(s2, "Bit Bang Control Test Data");
funcPtr = DoTest_BB;
break;
case TEST_PID: // PID control
strcpy(s1, "|PID |Press RBtn");
strcpy(s2, "PID Control Test Data");
funcPtr = DoTest_PID;
break;
case TEST_CHARACTERIZE: // characterize control system simulator
strcpy(s1, "|CHAR|Press RBtn");
strcpy(s2, "Characterization Test Data");
funcPtr = DoTest_Characterize;
break;
default: // no test to run
strcpy(s1, "");
strcpy(s2, "");
funcPtr = NULL;
break;
}
// Change the display to indicate that a test will be run
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring(s1);
LCD_setcursor(2, 0);
LCD_wrstring("LED OFF-Release ");
// turn on Run LED to show the test has begun
// and do the test. The test will return when the ADC samples array
// has been filled. Turn off the rightmost LED after the data has been
// captured to let the user know he/she can release the button
if (funcPtr != NULL) {
leds |= LEDS_RUN;
NX3_writeleds(leds);
n = funcPtr();
leds &= ~LEDS_RUN;
NX3_writeleds(leds);
// wait for the Rotary Encoder button to be released
// and then send the sample data to stdout
do {
NX3_readBtnSw(&btnsw);
delay_msecs(10);
} while (btnsw & BTN_RUN_XFER);
// turn on Transfer LED to indicate that data is being transmitted
// Show the transfer traffic on the LCD
leds |= LEDS_XFER;
NX3_writeleds(leds);
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Sending Data....");
LCD_setcursor(2, 0);
LCD_wrstring("S: DATA: ");
// transfer the descriptive heading followed by the data
xil_printf("\n\r%s\tAppx. Sample Interval: %d msec\n\r", s2,
adc_smple_interval);
xil_printf("sample\tADCCount\tVout\tsetpoint\tPWMCount\n\r");
// tell SerialCharter to start gathering data)
xil_printf("===STARTPLOT===\n");
for (smpl_idx = 2; smpl_idx < n; smpl_idx++) {
u16 count;
count = sample[smpl_idx];
vADC = PmodCtlSys_ADCVolts(count);
vSP = PmodCtlSys_ADCVolts(setpoint);
voltstostrng(vADC, s1);
voltstostrng(vSP, s2);
xil_printf("%d\t%d\t%s\t%s\t%d\n\r", smpl_idx, count, s1,
s2, PIDdebug[smpl_idx].pwm_count);
LCD_setcursor(2, 2);
LCD_wrstring(" ");
LCD_setcursor(2, 2);
LCD_putnum(smpl_idx, 10);
LCD_setcursor(2, 11);
LCD_wrstring(" ");
LCD_setcursor(2, 11);
LCD_putnum(count, 10);
}
// tell SeriaCharter to stop gathering data and display the graph
xil_printf("===ENDPLOT===\n");
// transfer complete - turn Transfer LED off and wrap up command processing
leds &= ~LEDS_XFER;
NX3_writeleds(leds);
wrlcd_static = true;
wrlcd_dynamic = true;
}
} // run a test
// wait a bit and start again
delay_msecs(100);
} // while(1) loop
} // end main()
int main(int argc, char *argv[])
{
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_init_icache_range(0, XPAR_MICROBLAZE_0_CACHE_BYTE_SIZE);
microblaze_enable_icache();
#endif
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_init_dcache_range(0, XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
microblaze_enable_dcache();
#endif
rows imago;
int crom_flag,i,j,lvl,temprows,tempblocks,offset[]={0,4,32,36},simb,size;
int luminance_table[]={16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 60, 55,
14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62,
18, 22, 37, 56, 68, 109, 103, 77,
24, 35, 55, 64, 81, 104, 113, 92,
49, 64, 78, 87, 103, 121, 120, 101,
72, 92, 95, 98, 112, 100, 103, 99};
int crominance_table[]={17, 18, 24, 47, 99, 99, 99, 99,
18, 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,};
int lum_tab_corr[64], crom_tab_corr[64];
info infoimago;
int_rows intimago;
huffman_tab tbl_dclum, tbl_aclum, tbl_dccrom, tbl_accrom;
FILE *file_in, *file_out;
unsigned char buffer,field_free_space=8;
buffer = 0x0; //UCCIDI UCCIDI UCCIDI
/*
xil_printf("\n\rINIZIO COMPRESSIONE!!!");
*/
if (argc > 1)
{
file_in=fopen(argv[1],"r");
}
else
file_in=fopen("./software/apps/jpeg/img.ppm","r"); //binario?
if (!file_in) return(0);
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
imago=rdppm(&infoimago, file_in);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rlettura file: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
if (imago==NULL) return(0);
fclose(file_in);
intimago=(p_intblock *) malloc (infoimago.numrows*sizeof(p_intblock));
for (i=0;i<infoimago.numrows;i++)
*(intimago+i)=(intblock *) malloc (infoimago.numblocks*sizeof(intblock));
if (infoimago.color==1)
{
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
RGBtoYUV(&(*(imago+i)+j)->comp1[0],&(*(imago+i)+j)->comp2[0],&(*(imago+i)+j)->comp3[0]);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rrgb to yuv: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
}
if (infoimago.color==1)
{
rows tempimago;
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
tempimago=expand_image(imago,infoimago.numrows,infoimago.numblocks,&temprows,&tempblocks);
for (i=0;i<temprows;i++)
for (j=0;j<tempblocks;j++)
downsample((*(tempimago+i)+j),(*(imago+i/2)+j/2),offset[j%2+(i%2)*2]);
for (i=0;i<temprows;i++)
free(*(tempimago+i));
free(tempimago);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rdownsample e espandsione: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
}
lvl= 80;
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
set_quantization_tbl(lvl, &luminance_table[0]);
set_quantization_tbl(lvl, &crominance_table[0]);
correct_quantization_tbl(luminance_table, lum_tab_corr);
correct_quantization_tbl(crominance_table, crom_tab_corr);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rrset quantization table: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
//Avvio del timer
/*
XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
{
if ((infoimago.color==1)&&(i<temprows/2)&&(j<tempblocks/2)) crom_flag=1;
else crom_flag=0;
DCT_and_quantization(*(imago+i)+j,lum_tab_corr,crom_tab_corr,*(intimago+i)+j,crom_flag);
}
for (i=0;i<infoimago.numrows;i++)
free(*(imago+i));
free(imago);
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
arrange(*(intimago+i)+j);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rdct and quantization: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
*/
//Avvio del timer
/*XTmrCtr_mLoadTimerCounterReg( XPAR_OPB_TIMER_1_BASEADDR, 0);
XTmrCtr_mSetControlStatusReg( XPAR_OPB_TIMER_1_BASEADDR, 0, XTC_CSR_ENABLE_TMR_MASK );
*/
initialize_huff_tbl(&tbl_dclum,0);
initialize_huff_tbl(&tbl_aclum,16);
initialize_huff_tbl(&tbl_dccrom,1);
initialize_huff_tbl(&tbl_accrom,17);
arrange_table(&luminance_table[0]);
arrange_table(&crominance_table[0]);
if (argc > 2)
file_out=fopen(argv[2],"w");
else
file_out=fopen("img_out.jpg","w"); //binario??
writeheaders (file_out, infoimago, &luminance_table[0], &crominance_table[0],
tbl_aclum,tbl_accrom,tbl_dclum,tbl_dccrom);
if (infoimago.color==1)
{
int oldlum=0, oldcrom1=0, oldcrom2=0;
for (i=0;i<infoimago.numrows;i+=2)
for (j=0;j<infoimago.numblocks;j+=2)
{
writescan(oldlum,(*(intimago+i)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
if ((j+1)<infoimago.numblocks)
{
writescan((*(intimago+i)+j)->intcomp1[0],(*(intimago+i)+j+1)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
if ((i+1)<infoimago.numrows)
{
writescan((*(intimago+i)+j+1)->intcomp1[0],(*(intimago+i+1)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
writescan((*(intimago+i+1)+j)->intcomp1[0],(*(intimago+i+1)+j+1)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
oldlum=(*(intimago+i+1)+j+1)->intcomp1[0];
}
else
{
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
oldlum=(*(intimago+i)+j+1)->intcomp1[0];
}
}
else
{
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
if ((i+1)<infoimago.numrows)
{
writescan((*(intimago+i)+j)->intcomp1[0],(*(intimago+i+1)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
oldlum=(*(intimago+i+1)+j)->intcomp1[0];
}
else
{
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_dclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
simb=findcode(0,tbl_aclum,&size);
wrbuffer(file_out,simb,&field_free_space,&buffer,size,0,0);
}
}
writescan(oldcrom1,(*(intimago+i/2)+j/2)->intcomp2,&field_free_space,&buffer,file_out,tbl_accrom,tbl_dccrom,infoimago);
writescan(oldcrom2,(*(intimago+i/2)+j/2)->intcomp3,&field_free_space,&buffer,file_out,tbl_accrom,tbl_dccrom,infoimago);
oldcrom1=(*(intimago+i/2)+j/2)->intcomp2[0];
oldcrom2=(*(intimago+i/2)+j/2)->intcomp3[0];
}
}
else
{
int oldlum=0;
for (i=0;i<infoimago.numrows;i++)
for (j=0;j<infoimago.numblocks;j++)
{
writescan(oldlum,(*(intimago+i)+j)->intcomp1,&field_free_space,&buffer,file_out,tbl_aclum,tbl_dclum,infoimago);
oldlum=(*(intimago+i)+j)->intcomp1[0];
}
}
write_end_of_image(file_out);
fclose(file_out);
// Stop timer e stampa dei cicli di computazione
/*
XTmrCtr_mDisable(XPAR_OPB_TIMER_1_BASEADDR,0);
xil_printf("\n\rcodifiche entropiche: %d\n\r",XTmrCtr_mGetTimerCounterReg(XPAR_OPB_TIMER_1_BASEADDR,0));
xil_printf("\n\rFINE COMPRESSIONE!!!");
*/
return 0;
}
int main()
{
XStatus Status;
u32 btnsw = 0x00000000, old_btnsw = 0x000000FF;
int rotcnt, old_rotcnt = 0x1000;
Test_t test, next_test;
is_scaled = false;
bool lcd_initial = true;
char sp[20];
u16 row = 1;
u16 col = 2;
bool calc_done = false;
freq_min_cnt = 3000;
// initialize devices and set up interrupts, etc.
Status = do_init();
if (Status != XST_SUCCESS)
{
LCD_setcursor(1,0);
LCD_wrstring("****** ERROR *******");
LCD_setcursor(2,0);
LCD_wrstring("INIT FAILED- EXITING");
exit(XST_FAILURE);
}
// initialize the variables
timestamp = 0;
pwm_freq = PWM_FREQUENCY;
next_test = TEST_INVALID;
prop_gain = PROP_INIT_GAIN;
integral_gain = INT_INIT_GAIN;
deriv_gain = DERIV_INIT_GAIN;
// Enable the Microblaze caches and kick off the processing by enabling the Microblaze
// interrupt. This starts the FIT timer which updates the timestamp.
if (USE_ICACHE == 1)
{
microblaze_invalidate_icache();
microblaze_enable_icache();
}
if (USE_DCACHE == 1)
{
microblaze_invalidate_dcache();
microblaze_enable_dcache();
}
microblaze_enable_interrupts();
// display the greeting
LCD_setcursor(1,0);
LCD_wrstring("PWM Ctrl sys");
LCD_setcursor(2,0);
LCD_wrstring("Erik R, Caren Z");
NX3_writeleds(0xFF);
//delay_msecs(2500);
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring("Characterizing..");
//Run the LED characterization routine to establish sensor min's and max's
DoTest_Characterize();
LCD_setcursor(2,0);
LCD_wrstring("Done.");
NX3_writeleds(0x00);
delay_msecs(500);
//set initial screen
// main loop - there is no exit except by hardware reset
while (1)
{
//set Vin to min or max depending on switch 3 value
if (btnsw & msk_SWITCH3)
{
pwm_duty = MAX_DUTY;
dc_start = MAX_DUTY;
}
else
{
pwm_duty = MIN_DUTY;
dc_start = MIN_DUTY;
}
// Write values to display when in "idle" state
if (lcd_initial)
{
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring("P: I: D: ");
LCD_setcursor(1,2);
LCD_setcursor(2,0);
LCD_wrstring("SP:+ OFF: ");
lcd_initial = false;
LCD_setcursor(1,2);
}
no_test_LCD();
NX3_readBtnSw(&btnsw);
// Set which control measurement we're using
if (btnsw & msk_BTN_NORTH)
{
// increment to the next selection. If we're at the last enum, set it to the 1st (proportional)
if (PID_current_sel == OFFSET) PID_current_sel = PROPORTIONAL;
else PID_current_sel = (Control_t)((int)(PID_current_sel+1)); //casting to allow increment
// cursor control logic
if (PID_current_sel == PROPORTIONAL)
{
row = 1;
col = 2;
}
else if (PID_current_sel == INTEGRAL)
{
row = 1;
col = 7;
}
else if (PID_current_sel == DERIVATIVE)
{
row = 1;
col = 12;
}
else if (PID_current_sel == OFFSET)
{
row = 2;
col = 13;
}
}
delay_msecs(20);
//set cursor location and turn on cursor
LCD_setcursor(row,col);
LCD_docmd(LCD_DISPLAYONOFF, LCD_CURSOR_ON);
if (btnsw & msk_BTN_EAST)
{
if (PID_current_sel == PROPORTIONAL) prop_gain += GAIN_INCREMENT;
else if (PID_current_sel == INTEGRAL) integral_gain += GAIN_INCREMENT;
else if (PID_current_sel == DERIVATIVE) deriv_gain += GAIN_INCREMENT;
else offset += GAIN_INCREMENT;
}
if (btnsw & msk_BTN_WEST)
{
if (PID_current_sel == PROPORTIONAL) prop_gain -= GAIN_INCREMENT;
else if (PID_current_sel == INTEGRAL) integral_gain -= GAIN_INCREMENT;
else if (PID_current_sel == DERIVATIVE) deriv_gain -= GAIN_INCREMENT;
else offset -= GAIN_INCREMENT;
}
// read sw[1:0] to get the test to perform.
NX3_readBtnSw(&btnsw);
test = btnsw & (msk_SWITCH1 | msk_SWITCH0);
ROT_readRotcnt(&rotcnt);
if (rotcnt != old_rotcnt)
{
//scale rotary count to setpoint values
LCD_docmd(LCD_DISPLAYONOFF, LCD_CURSOR_OFF);
setpoint = MAX(VOLT_MIN, MIN((rotcnt/SETPOINT_SCALE), VOLT_MAX));
voltstostrng(setpoint, sp);
old_rotcnt = rotcnt;
LCD_setcursor(2, 3);
LCD_wrstring(sp);
LCD_setcursor(2, 3);
LCD_wrstring('+');
}
if (test == TEST_T_CALLS) //unused
{
next_test = TEST_INVALID;
lcd_initial = true;
delay_msecs(3000);
}
else if ((test == TEST_BANG ) || (test == TEST_PID)) // Test 1 & 2 - control methods Bang Bang and PID
{
Xfloat32 v;
char s[20];
// start the test on the rising edge of the Rotary Encoder button press
// the test will write the light detector samples into the global "sample[]"
// the samples will be sent to stdout when the Rotary Encoder button
// is released
//
// NOTE ON DETECTING BUTTON CHANGES:
// btnsw ^ old_btnsw will set the bits for all of the buttons and switches that
// have changed state since the last time the buttons and switches were read
// msk_BTN_ROT & btnsw will test whether the rotary encoder was one of the
// buttons that changed from 0 -> 1
if ((btnsw ^ old_btnsw) && (msk_BTN_ROT & btnsw)) // do the step test and dump data
{
/*Running Test (rotary pushbutton pushed): Show which control algorithm is running and
display instructions for running test and uploading data.*/
if (test != next_test)
{
if (test == TEST_BANG)
{
strcpy(s, "|BANG|Long Press");
}
else
{
strcpy(s, "|PID|Long Press");
}
delay_msecs(100);
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring(s);
LCD_setcursor(2,0);
LCD_wrstring("RotBtn to start");
}
NX3_writeleds(0x01);
if (test == TEST_BANG) // perform bang bang calculations
{
calc_bang();
}
else // perform PID tests
{
calc_PID();
}
NX3_writeleds(0x00);
//FEATURE: wait for user input to send data over
NX3_readBtnSw(&btnsw);
if ((btnsw ^ old_btnsw) && (msk_BTN_ROT & btnsw))
{
// light "Transfer" LED to indicate that data is being transmitted
// Show the traffic on the LCD
NX3_writeleds(0x02);
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Sending Data....");
LCD_setcursor(2, 0);
LCD_wrstring("S: DATA: ");
// print the descriptive heading followed by the data
if (test == TEST_BANG)
{
xil_printf("\n\rBang Bang! Test Data\t\tAppx. Sample Interval: %d msec\n\r", frq_smple_interval);
}
else
{
xil_printf("\n\rPID Test Data\t\tAppx. Sample Interval: %d msec\n\r", frq_smple_interval);
}
// trigger the serial charter program)
xil_printf("===STARTPLOT===\n");
// start with the second sample. The first sample is not representative of
// the data. This will pretty-up the graph a bit
for (smpl_idx = 1; smpl_idx < NUM_FRQ_SAMPLES; smpl_idx++)
{
u16 count;
count = sample[smpl_idx];
if (count > 4096)
count = 4095;
v = (-3.3 / 4095.0) * (count) + 3.3;
voltstostrng(v, s);
xil_printf("%d\t%d\t%s\n\r", smpl_idx, count, s);
LCD_setcursor(2, 2);
LCD_wrstring(" ");
LCD_setcursor(2, 2);
LCD_putnum(smpl_idx, 10);
LCD_setcursor(2, 11);
LCD_wrstring(" ");
LCD_setcursor(2, 11);
LCD_putnum(count, 10);
}
// stop the serial charter program
xil_printf("===ENDPLOT===\n");
NX3_writeleds(0x00);
old_btnsw = btnsw;
next_test = TEST_INVALID;
lcd_initial = true;
delay_msecs(3000);
}
} // do the step test and dump data
}
else if (test == TEST_CHARACTERIZE) // Test 3 - Characterize Response
{
// start the test on the rising edge of the Rotary Encoder button press
// the test will write the samples into the global "sample[]"
// the samples will be sent to stdout when the Rotary Encoder button
// is released
NX3_readBtnSw(&btnsw);
if ((btnsw ^ old_btnsw) && (msk_BTN_ROT & btnsw))
{
LCD_docmd(LCD_DISPLAYONOFF, LCD_CURSOR_OFF);
// light "Run" (rightmost) LED to show the test has begun
// and do the test. The test will return when the measured samples array
// has been filled. Turn off the rightmost LED after the data has been
if (test != next_test)
{
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring("|CHAR|Long Press");
LCD_setcursor(2,0);
LCD_wrstring("RotBtn to start");
}
// captured to let the user know he/she can release the button
NX3_readBtnSw(&btnsw);
if ((msk_BTN_ROT & btnsw) && (!calc_done))
{
NX3_writeleds(0x01);
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring("Characterizing..");
DoTest_Characterize();
LCD_setcursor(2,0);
LCD_wrstring("Done.");
NX3_writeleds(0x00);
delay_msecs(750);
LCD_setcursor(2,8);
LCD_wrstring("<OK>");
calc_done = true;
next_test = test;
}
NX3_readBtnSw(&btnsw);
if (msk_BTN_ROT & btnsw)
{
// light "Transfer" LED to indicate that data is being transmitted
// Show the traffic on the LCD
NX3_writeleds(0x02);
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Sending Data....");
LCD_setcursor(2, 0);
LCD_wrstring("S: DATA: ");
xil_printf("\n\rCharacterization Test Data\t\tAppx. Sample Interval: %d msec\n\r", frq_smple_interval);
// trigger the serial charter program)
xil_printf("===STARTPLOT===\n\r");
for (smpl_idx = STEPDC_MIN; smpl_idx <= STEPDC_MAX; smpl_idx++)
{
u16 count;
Xfloat32 v;
char s[10];
count = sample[smpl_idx];
if (count > 4096)
count = 4095;
v = (-3.3 / 4095.0) * (count) + 3.3;
voltstostrng(v, s);
xil_printf("%d\t%d\t%s\n\r", smpl_idx, count, s);
LCD_setcursor(2, 2);
LCD_wrstring(" ");
LCD_setcursor(2, 2);
LCD_putnum(smpl_idx, 10);
LCD_setcursor(2, 11);
LCD_wrstring(" ");
LCD_setcursor(2, 11);
LCD_putnum(count, 10);
}
// stop the serial charter program
xil_printf("===ENDPLOT===\n\r");
NX3_writeleds(0x00);
old_btnsw = btnsw;
next_test = TEST_INVALID;
delay_msecs(1000);
lcd_initial = true;
delay_msecs(3000);
}
} // do the step test and dump data
} // Test 3 - Characterize Response
else // outside the current test range - blink LED's and hang
{
// should never get here but just in case
NX3_writeleds(0xFF);
delay_msecs(2000);
NX3_writeleds(0x00);
}
// wait a bit and start again
delay_msecs(100);
} // while(1) loop
} // end main()
int main()
{
XStatus Status;
u32 btnsw = 0x00000000, old_btnsw = 0x000000FF;
int rotcnt, old_rotcnt = 0x1000;
Test_t test, next_test;
is_scaled = false;
// initialize devices and set up interrupts, etc.
Status = do_init();
if (Status != XST_SUCCESS)
{
LCD_setcursor(1,0);
LCD_wrstring("****** ERROR *******");
LCD_setcursor(2,0);
LCD_wrstring("INIT FAILED- EXITING");
exit(XST_FAILURE);
}
// initialize the variables
timestamp = 0;
pwm_freq = PWM_FREQUENCY;
pwm_duty = STEPDC_MIN;
next_test = TEST_INVALID;
// Enable the Microblaze caches and kick off the processing by enabling the Microblaze
// interrupt. This starts the FIT timer which updates the timestamp.
if (USE_ICACHE == 1)
{
microblaze_invalidate_icache();
microblaze_enable_icache();
}
if (USE_DCACHE == 1)
{
microblaze_invalidate_dcache();
microblaze_enable_dcache();
}
microblaze_enable_interrupts();
// display the greeting
LCD_setcursor(1,0);
LCD_wrstring("PmodCtlSys Test ");
LCD_setcursor(2,0);
LCD_wrstring("R3.0 by Robin M.");
NX3_writeleds(0xFF);
//Run the LED characterization routine to establish sensor min's and max's
DoTest_Characterize();
NX3_writeleds(0x00);
// main loop - there is no exit except by hardware reset
while (1)
{
// read sw[1:0] to get the test to perform.
NX3_readBtnSw(&btnsw);
test = btnsw & (msk_SWITCH1 | msk_SWITCH0);
if (test == TEST_TRACKING) // Test 0 = Track PWM voltage
{
// write the static info to display if necessary
if (test != next_test)
{
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring("| TRK| Vi: sx.xx");
LCD_setcursor(2,0);
LCD_wrstring("Vo:sx.xx C:sxxxx");
}
// read rotary count and handle duty cycle changes
// limit duty cycle to between STEPDC_MIN and STEPDC_MAX
// PWM frequency does not change in this test
ROT_readRotcnt(&rotcnt);
if (rotcnt != old_rotcnt)
{
pwm_duty = MAX(STEPDC_MIN, MIN(rotcnt, STEPDC_MAX));
old_rotcnt = rotcnt;
}
DoTest_Track();
next_test = TEST_TRACKING;
} // Test 0 = Track PWM voltage
else if ((test == TEST_STEPHILO) || (test == TEST_STEPLOHI)) // Test 1 & 2 - Step response
{
Xfloat32 v;
char s[20];
// write the static info to the display if necessary
if (test != next_test)
{
if (test == TEST_STEPHILO)
{
strcpy(s, "|HILO|Press RBtn");
}
else
{
strcpy(s, "|LOHI|Press RBtn");
}
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring(s);
LCD_setcursor(2,0);
LCD_wrstring("LED OFF-Release ");
}
// start the test on the rising edge of the Rotary Encoder button press
// the test will write the light detector samples into the global "sample[]"
// the samples will be sent to stdout when the Rotary Encoder button
// is released
//
// NOTE ON DETECTING BUTTON CHANGES:
// btnsw ^ old_btnsw will set the bits for all of the buttons and switches that
// have changed state since the last time the buttons and switches were read
// msk_BTN_ROT & btnsw will test whether the rotary encoder was one of the
// buttons that changed from 0 -> 1
if ((btnsw ^ old_btnsw) && (msk_BTN_ROT & btnsw)) // do the step test and dump data
{
// light "Run" (rightmost) LED to show the test has begun
// and do the test. The test will return when the measured samples array
// has been filled. Turn off the rightmost LED after the data has been
// captured to let the user know he/she can release the button
NX3_writeleds(0x01);
if (test == TEST_STEPHILO) // perform High->Low step test
{
DoTest_Step(STEPDC_MAX);
}
else // perform Low->High step
{
DoTest_Step(STEPDC_MIN);
}
NX3_writeleds(0x00);
// wait for the Rotary Encoder button to be released
// and then send the sample data to stdout
do
{
NX3_readBtnSw(&btnsw);
delay_msecs(10);
} while ((btnsw & msk_BTN_ROT) == 0x80);
// light "Transfer" LED to indicate that data is being transmitted
// Show the traffic on the LCD
NX3_writeleds(0x02);
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Sending Data....");
LCD_setcursor(2, 0);
LCD_wrstring("S: DATA: ");
// print the descriptive heading followed by the data
if (test == TEST_STEPHILO)
{
xil_printf("\n\rHigh->Low Test Data\t\tAppx. Sample Interval: %d msec\n\r", frq_smple_interval);
}
else
{
xil_printf("\n\rLow->High Test Data\t\tAppx. Sample Interval: %d msec\n\r", frq_smple_interval);
}
// trigger the serial charter program)
xil_printf("===STARTPLOT===\n");
// start with the second sample. The first sample is not representative of
// the data. This will pretty-up the graph a bit
for (smpl_idx = 1; smpl_idx < NUM_FRQ_SAMPLES; smpl_idx++)
{
u16 count;
count = sample[smpl_idx];
//ECE544 Students:
//Convert from count to 'volts'
v = LIGHTSENSOR_Count2Volts(count);
voltstostrng(v, s);
xil_printf("%d\t%d\t%s\n\r", smpl_idx, count, s);
LCD_setcursor(2, 2);
LCD_wrstring(" ");
LCD_setcursor(2, 2);
LCD_putnum(smpl_idx, 10);
LCD_setcursor(2, 11);
LCD_wrstring(" ");
LCD_setcursor(2, 11);
LCD_putnum(count, 10);
}
// stop the serial charter program
xil_printf("===ENDPLOT===\n");
NX3_writeleds(0x00);
old_btnsw = btnsw;
next_test = TEST_INVALID;
} // do the step test and dump data
else
{
next_test = test;
}
} // Test 1 & 2 - Step response
else if (test == TEST_CHARACTERIZE) // Test 3 - Characterize Response
{
if (test != next_test)
{
LCD_clrd();
LCD_setcursor(1,0);
LCD_wrstring("|CHAR|Press RBtn");
LCD_setcursor(2,0);
LCD_wrstring("LED OFF-Release ");
}
// start the test on the rising edge of the Rotary Encoder button press
// the test will write the samples into the global "sample[]"
// the samples will be sent to stdout when the Rotary Encoder button
// is released
if ((btnsw ^ old_btnsw) && (msk_BTN_ROT & btnsw)) // do the step test and dump data
{
// light "Run" (rightmost) LED to show the test has begun
// and do the test. The test will return when the measured samples array
// has been filled. Turn off the rightmost LED after the data has been
// captured to let the user know he/she can release the button
NX3_writeleds(0x01);
DoTest_Characterize();
NX3_writeleds(0x00);
// wait for the Rotary Encoder button to be released
// and then send the sample data to stdout
do
{
NX3_readBtnSw(&btnsw);
delay_msecs(10);
} while ((btnsw & msk_BTN_ROT) == 0x80);
// light "Transfer" LED to indicate that data is being transmitted
// Show the traffic on the LCD
NX3_writeleds(0x02);
LCD_clrd();
LCD_setcursor(1, 0);
LCD_wrstring("Sending Data....");
LCD_setcursor(2, 0);
LCD_wrstring("S: DATA: ");
xil_printf("\n\rCharacterization Test Data\t\tAppx. Sample Interval: %d msec\n\r", frq_smple_interval);
// trigger the serial charter program)
xil_printf("===STARTPLOT===\n\r");
for (smpl_idx = STEPDC_MIN; smpl_idx <= STEPDC_MAX; smpl_idx++)
{
u16 count;
Xfloat32 v;
char s[10];
count = sample[smpl_idx];
//ECE544 Students:
//Convert from count to 'volts'
v = LIGHTSENSOR_Count2Volts((Xuint32)count);
voltstostrng(v, s);
xil_printf("%d\t%d\t%s\n\r", smpl_idx, count, s);
LCD_setcursor(2, 2);
LCD_wrstring(" ");
LCD_setcursor(2, 2);
LCD_putnum(smpl_idx, 10);
LCD_setcursor(2, 11);
LCD_wrstring(" ");
LCD_setcursor(2, 11);
LCD_putnum(count, 10);
}
// stop the serial charter program
xil_printf("===ENDPLOT===\n\r");
NX3_writeleds(0x00);
old_btnsw = btnsw;
next_test = TEST_INVALID;
} // do the step test and dump data
else
{
next_test = test;
}
} // Test 3 - Characterize Response
else // outside the current test range - blink LED's and hang
{
// should never get here but just in case
NX3_writeleds(0xFF);
delay_msecs(2000);
NX3_writeleds(0x00);
}
// wait a bit and start again
delay_msecs(100);
} // while(1) loop
} // end main()
int main (void) {
static XIntc intc;
/*
* Enable and initialize cache
*/
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_init_icache_range(0, XPAR_MICROBLAZE_0_CACHE_BYTE_SIZE);
microblaze_enable_icache();
#endif
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_init_dcache_range(0, XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
microblaze_enable_dcache();
#endif
static XEmacLite Ethernet_MAC_EmacLite;
print("-- Entering main() --\r\n");
{
XStatus status;
print("\r\n Runnning IntcSelfTestExample() for xps_intc_0...\r\n");
status = IntcSelfTestExample(XPAR_XPS_INTC_0_DEVICE_ID);
if (status == 0) {
print("IntcSelfTestExample PASSED\r\n");
}
else {
print("IntcSelfTestExample FAILED\r\n");
}
}
{
XStatus Status;
Status = IntcInterruptSetup(&intc, XPAR_XPS_INTC_0_DEVICE_ID);
if (Status == 0) {
print("Intc Interrupt Setup PASSED\r\n");
}
else {
print("Intc Interrupt Setup FAILED\r\n");
}
}
/*
* Peripheral SelfTest will not be run for RS232_Uart_1
* because it has been selected as the STDOUT device
*/
{
Xuint32 status;
print("\r\nRunning GpioOutputExample() for LEDs_8Bit...\r\n");
status = GpioOutputExample(XPAR_LEDS_8BIT_DEVICE_ID,8);
if (status == 0) {
print("GpioOutputExample PASSED.\r\n");
}
else {
print("GpioOutputExample FAILED.\r\n");
}
}
{
XStatus status;
print("\r\nRunning EMACLiteSelfTestExample() for Ethernet_MAC...\r\n");
status = EMACLiteSelfTestExample(XPAR_ETHERNET_MAC_DEVICE_ID);
if (status == 0) {
print("EMACLiteSelfTestExample PASSED\r\n");
}
else {
print("EMACLiteSelfTestExample FAILED\r\n");
}
}
{
XStatus Status;
print("\r\n Running Interrupt Test for Ethernet_MAC...\r\n");
Status = EmacLiteExample(&intc, &Ethernet_MAC_EmacLite, \
XPAR_ETHERNET_MAC_DEVICE_ID, \
XPAR_XPS_INTC_0_ETHERNET_MAC_IP2INTC_IRPT_INTR);
if (Status == 0) {
print("EmacLite Interrupt Test PASSED\r\n");
}
else {
print("EmacLite Interrupt Test FAILED\r\n");
}
}
{
XStatus status;
print("\r\n Running TmrCtrSelfTestExample() for xps_timer_1...\r\n");
status = TmrCtrSelfTestExample(XPAR_XPS_TIMER_1_DEVICE_ID, 0x0);
if (status == 0) {
print("TmrCtrSelfTestExample PASSED\r\n");
}
else {
print("TmrCtrSelfTestExample FAILED\r\n");
}
}
{
XStatus status;
print("\r\nRunning UartLiteSelfTestExample() for debug_module...\r\n");
status = UartLiteSelfTestExample(XPAR_DEBUG_MODULE_DEVICE_ID);
if (status == 0) {
print("UartLiteSelfTestExample PASSED\r\n");
}
else {
print("UartLiteSelfTestExample FAILED\r\n");
}
}
/*
* Disable cache and reinitialize it so that other
* applications can be run with no problems
*/
#if XPAR_MICROBLAZE_0_USE_DCACHE
microblaze_disable_dcache();
microblaze_init_dcache_range(0, XPAR_MICROBLAZE_0_DCACHE_BYTE_SIZE);
#endif
#if XPAR_MICROBLAZE_0_USE_ICACHE
microblaze_disable_icache();
microblaze_init_icache_range(0, XPAR_MICROBLAZE_0_CACHE_BYTE_SIZE);
#endif
print("-- Exiting main() --\r\n");
return 0;
}
int main() {
proc_interface_t hwti;
// Get HWTI base address from user PVR register
int hwti_base;
unsigned char cpu_id; // only 8bits
getpvr(1,hwti_base);
// Disable instruction and data cache
microblaze_invalidate_icache();
microblaze_enable_icache();
microblaze_invalidate_dcache();
microblaze_disable_dcache();
//Determine if uB is first on bus
getpvr(0, cpu_id);
// Timer pointers
volatile unsigned long long * timer = (unsigned long long *) LOCAL_TIMER;
volatile unsigned int * timer_reset = (unsigned int *) (LOCAL_TIMER + RESET_REG);
// Reset timer
*timer_reset = CMD_RESET;
// Indicate to CoreTest.c running on host that this processor is running
volatile unsigned int * check = (unsigned int *) EXTRA_BRAM;
// assign cpus_per_bus offset
check = (unsigned int *)
((unsigned int) check + ( ((unsigned int) cpu_id) * 0x100));
// write OKAY_VALUE to common memory (extra_bram)
*check = OKAY_VALUE;
// Nano-kernel loop...
while(1) {
// Setup interface
// * Perform this upon each iteration, just in case the memory
// map for the MB-HWTI is corrupted.
initialize_interface(&hwti,(int*)(hwti_base));
#if 0 // Commented out as this is not necessary and it creates the opportunity for a race between reset and start commands
// Wait to be "reset"
// -- NOTE: Ignore reset as it has no meaning to the MB-HWTI
// and it seems causes a race, as the controlling processor
// sends a reset, immediately followed by a "go" command. Therefore
// the "reset" command can be missed.
wait_for_reset_command(&hwti);
#endif
// Wait to be "started"
wait_for_go_command(&hwti);
//xil_printf("Thread started (fcn @ 0x%08x), arg = 0x%08x!!!\r\n",*(hwti.fcn_reg), *(hwti.arg_reg));
// Setup r20 for thread, this can be used to enforce -fPIC (Position-independent code) for the MB
// (r20 is used as part of the GOT, to make things PC-relative)
mtgpr(r20, *(hwti.fcn_reg));
// Boostrap thread (wraps up thread execution with a thread exit)
// * Pull out thread argument, and thread start function
_bootstrap_thread(&hwti, *(hwti.fcn_reg), *(hwti.arg_reg));
}
return 0;
}