void dig_to_disp(uint32_t out_dig, Val_on_disp *odl_f){
switch (counter){
case 0:
tmp = out_dig;
dig = tmp%10;
tmp = tmp/10;
init_disp();
on_seg_3();
dig_to_port(dig, dp);
break;
case 1:
dig = tmp%10;
tmp = tmp/10;
init_disp();
on_seg_2();
if ( (error_type == E_I || error_type == ELI || chanel == _I_) && *odl_f == e_cnl){
dp = 1;
}
dig_to_port(dig, dp);
break;
case 2:
dig = tmp%10;
init_disp();
on_seg_1();
if (*odl_f == e_r_timer) dp = 1;
dig_to_port(tmp, dp);
dp = 0;
break;
}
dp = 0;
counter++;
if (counter > 2) counter = 0;
}
int disp_g(char *tetri, int **tab, int y, int x)
{
t_var var;
var = init_disp(var);
while (var.j != y)
{
while (tetri[var.z] != 0)
{
if (tetri[var.z] == '\n')
{
var.l = 1;
var.m += 1;
}
else if (tetri[var.z] == '*')
{
tab[var.m][((x / 2) + var.l)] = 3;
var.l += 1;
}
else
var.l += 1;
var.z += 1;
}
var.j += 1;
tab = now_down(tab, y, x);
}
}
int main(void){
init_ran_num();
init_disp();
while(1){
if(title())break;
game_main();
}
return 0;
}
/*****************************************************************************
Name: void init_BSP(void)
Parameters:
Returns:
Description: Intializes borad support firmware.
*****************************************************************************/
void init_BSP(void)
{
ENABLE_LEDS
#if USE_LCD_DISPLAY == 1
init_disp();
#endif
init_Task_Timers();
ALL_LED_ON
t1ck1 = 0; t1ck0 = 1; // Set Timer 1 count source to 1/8
pre1 = 100; // Load prescaler with 1
t1 = 82; // load t1 with 4 2 x 5 = 10 :// 32.768 KHz / 32 / 10 = 102.4 times a second = 10 msec
DISABLE_INTS
t1ic = 0x01; // timer 1 underflow interrut. (S4).
ENABLE_INTS
#if USE_KEY_INPUT_BUFFER == 1
addTask(Keyinput_task, 5,(MAX_TASKS-1)); // Sample key input every 25 ms.
#endif
ALL_LED_OFF
}
/*--------------------------------------------------------------------------
* initialize and enter main event loop
*--------------------------------------------------------------------------
*/
int main(int argc, char **argv) {
/* initialize openGL stuff
*/
printf("QRSIM (c) Embedded Systems Lab, TU Delft\n");
menu();
printf("qrsim control mode %d\n",userstate.control_mode);
init_disp(argc, argv);
/* initialize quad rotor stuff
*/
qr_init(&qrstate, Z_AT_GND);
user_init(&userstate, CONTROL_NONE);
js_init();
/* start simulation
*/
simulations = 0;
start_disp();
return 0;
}
//Initialize LCD display
void init_disp (void)
{
static const gpio_map_t DIP204_SPI_GPIO_MAP =
{
{DIP204_SPI_SCK_PIN, DIP204_SPI_SCK_FUNCTION }, // SPI Clock.
{DIP204_SPI_MISO_PIN, DIP204_SPI_MISO_FUNCTION}, // MISO.
{DIP204_SPI_MOSI_PIN, DIP204_SPI_MOSI_FUNCTION}, // MOSI.
{DIP204_SPI_NPCS_PIN, DIP204_SPI_NPCS_FUNCTION} // Chip Select NPCS.
};
// add the spi options driver structure for the LCD DIP204
spi_options_t spiOptions =
{
.reg = DIP204_SPI_NPCS,
.baudrate = 1000000,
.bits = 8,
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 1,
.spi_mode = 0,
.modfdis = 1
};
// Assign I/Os to SPI
gpio_enable_module(DIP204_SPI_GPIO_MAP,
sizeof(DIP204_SPI_GPIO_MAP) / sizeof(DIP204_SPI_GPIO_MAP[0]));
// Initialize as master
spi_initMaster(DIP204_SPI, &spiOptions);
// Set selection mode: variable_ps, pcs_decode, delay
spi_selectionMode(DIP204_SPI, 0, 0, 0);
// Enable SPI
spi_enable(DIP204_SPI);
// setup chip registers
spi_setupChipReg(DIP204_SPI, &spiOptions, FOSC0);
// initialize LCD
dip204_init(backlight_IO, true);
dip204_hide_cursor();
}
int main (void)
{
// Switch the CPU main clock to oscillator 0
pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP);
board_init();
init_disp();
U32 x = 12345678;
U32 y = 87654321;
U64 z =0;
F32 a = 1234.5678;
F32 b = 8765.4321;
F32 c = 0;
U32 calc_time_z = 0;
U32 calc_time_c = 0;
U32 cnt_1 = 0;
U32 cnt_2 = 0;
U32 cnt_3 = 0;
U32 cnt_res_z = 0;
U32 cnt_res_c = 0;
char cycl_str_z[9];
char cycl_str_c[9];
char result[19];
char cycl_c[9];
char cycl_z[9];
//Calculation:
//Cycle count 1
cnt_1 = Get_sys_count();
//Calculation part 1:
z = x*y;
//Cycle count 2
cnt_2 = Get_sys_count();
//Calculation part 2:
c = a*b;
//Cycle count 3
cnt_3 = Get_sys_count();
//Cycle count result
cnt_res_z = cnt_2 - cnt_1 ;
cnt_res_c = cnt_3 - cnt_2 ;
//Use cycle count result to find calculation time
calc_time_c = (cnt_res_c * 1000000 + FOSC0 - 1) / FOSC0;
calc_time_z = (cnt_res_z * 1000000 + FOSC0 - 1) / FOSC0;
//Compose strings for display output
sprintf(result, "%f", c);
sprintf(cycl_str_z, "%lu", calc_time_z);
sprintf(cycl_str_c, "%lu", calc_time_c);
sprintf(cycl_c, "%lu", cnt_res_c);
sprintf(cycl_z, "%lu", cnt_res_z);
//Display calculation time, cycles and multiplication result on monitor
dip204_clear_display();
dip204_set_cursor_position(1,1);
dip204_write_string("x*y=z");
dip204_set_cursor_position(1,2);
dip204_write_string("Time:");
dip204_set_cursor_position(7,2);
dip204_write_string(cycl_str_z);
dip204_set_cursor_position(1,3);
dip204_write_string("Cycles:");
dip204_set_cursor_position(9,3);
dip204_write_string(cycl_z);
dip204_set_cursor_position(11,1);
dip204_write_string("a*b=c");
dip204_set_cursor_position(11,2);
dip204_write_string("Time:");
dip204_set_cursor_position(17,2);
dip204_write_string(cycl_str_c);
dip204_set_cursor_position(11,3);
dip204_write_string("Cycles:");
dip204_set_cursor_position(19,3);
dip204_write_string(cycl_c);
while (1)
{
}
}
int main(int argc, char* argv[]) {
char const* image_path = argv[1];
char const* image_path2 = argv[2];
std::clock_t start;
double duration;
start = std::clock();
ImageProc::Image* img = new ImageProc::Image(image_path);
ImageProc::Image* img2 = new ImageProc::Image(image_path);
ImageProc::Image* img3 = new ImageProc::Image(image_path);
// t_2DPoint* uLC = new t_2DPoint[1];
// t_2DPoint* lRC = new t_2DPoint[1];
// imgintf::readImage(img,image_path);
// imgintf::readImage(img2,image_path);
// uLC->x = img->getHeight()/2;
// uLC->y = 0;
// lRC->x = img->getHeight();
// lRC->y = img->getWidth();
// ImageProc::Square ROI(uLC,lRC);
// ImageProc::Image* img2 = new ImageProc::Image(lRC->x - uLC->x,lRC->y - uLC->y);
ImageProc::gaussian_filter(img3,3);
// ImageProc::crop(img,img2,ROI);
ImageProc::sobel(img2);
ImageProc::sobel(img3);
// ImageProc::bilateral_filterGray(img3,21);
// imgintf::saveImageGray(img2,image_path2);
// imgintf::readImage(img2,image_path);
// imgintf::readImage(img3,image_path);
// ImageProc::gaussian_filter(img,3);
// ImageProc::rotate(img,30);
// ImageProc::rotate(img,45);
// ImageProc::impulse_filter(img2,3);
// ImageProc::bilateral_filterGray(img,21);
// ImageProc::bilateral_filterColor(img,21,0);
// ImageProc::bilateral_filterColor(img,21,1);
// ImageProc::bilateral_filterColor(img,21,2);
// ImageProc::gaussian_filter(img,5);
// ImageProc::unsharp_masking_test(img,img2);
// ImageProc::rotate(img,45)
// ImageProc::rotBlnInt(img,45);
// img3 = img_rotBlnInt_test(img,45);
// ImageProc::equalizeHistogramCumulative(img2);
// ImageProc::equalizeHistogramRemap(img3);
// ImageProc::sobel(img,img2);
ImageProc::computeHistogram(img);
ImageProc::computeHistogram(img2);
ImageProc::v_computeNormalizedHistogram(img3);
ImageProc::otsu_binary_segmentation(img3);
ImageProc::computeHistogram(img3);
// ImageProc::v_computeNormalizedHistogram(img2);
//
// ImageProc::computeHistogram(&img3);
// ImageProc::v_computeNormalizedHistogram(&img3);
// ImageProc::computeHistogram(img2);
// ImageProc::computeHistogram(img3);
// printf("%f",img->normHist[10]);
cimg_library::CImgDisplay init_disp(imgintf::displayImageGray(img));
cimg_library::CImgDisplay init2_disp(imgintf::displayHist(img));
cimg_library::CImgDisplay init3_disp(imgintf::displayImageGray(img2));
cimg_library::CImgDisplay init4_disp(imgintf::displayHist(img2));
cimg_library::CImgDisplay init5_disp(imgintf::displayImageGray(img3));
cimg_library::CImgDisplay init6_disp(imgintf::displayHist(img3));
duration = (std::clock() - start) / (double)CLOCKS_PER_SEC;
std::cout << "Time: " << duration << '\n';
while (!init_disp.is_closed() && !init2_disp.is_closed()) {
init_disp.wait();
}
// delete[] uLC;
// delete[] lRC;
delete img;
delete img2;
delete img3;
return 0;
}
