void associateObjects(QImage *threshed, QImage *associated) // For use with Lab 5 // Assign a unique color to each object in the thresholded image, // and change all pixels in each object to the color. { int height,width; int red, green, blue; QRgb *pfirstthreshedrgb, *pfirstassociatedrgb, *rgbaddress; QRgb pixel; height = threshed->height(); width = threshed->width(); pfirstthreshedrgb=(QRgb*)threshed->bits(); pfirstassociatedrgb=(QRgb*)associated->bits(); // initialize an array of labels, assigning a label number to each pixel in the image int ** pixellabel = new int*[height]; for (int i=0;i<height;i++) { pixellabel[i] = new int[width]; } for(int row=0; row<height; row++) { for(int col=0; col<width; col++) { // read red, green, blue values of pixel in threshed image rgbaddress=pfirstthreshedrgb+row*width+col; pixel = *(rgbaddress); red = qRed(pixel); // note: r=g=b= {255 or 0} if (red==0x00) pixellabel[row][col]=0; // object/foreground else pixellabel[row][col]=-1; // background } } int label[2000]; int *equiv[2000]; for (int i = 0 ; i<2000 ; i++) { label[i]= 0; equiv[i] = &label[i]; } int labelnum=1; //----------------------------FIRST RASTER SCAN---------------------------------// // assign the same label to all pixels in each object, a unique label for each object for(int row=0; row<height; row++) { for(int col=0; col<width; col++) { int pixel = pixellabel[row][col]; int left=-1; int above =-1; if (col !=0) left = pixellabel[row][col-1]; if (row != 0) above = pixellabel[row-1][col]; if (pixel != -1) { if((left ==-1) && (above==-1)) { pixellabel[row][col]=labelnum; label[labelnum]= labelnum; labelnum++; } else if ((left !=-1) && (above ==-1)) pixellabel[row][col] = left; else if ((left==-1) && (above != -1 )) pixellabel[row][col] = above; else if ((left !=-1 ) && (above != -1)) { int min =0; int max =0; int smallerbaselabel = -9999; if (*(equiv[left])<*(equiv[above])) smallerbaselabel = *equiv[left]; else smallerbaselabel= *equiv[above]; if (smallerbaselabel == *equiv[left]) { min =left; } else { min = above; } if (min == left) max = above; else max = left; pixellabel[row][col] = smallerbaselabel; *equiv[max] = *equiv[min]; equiv[max]=equiv[min]; } } } } //--------------SECOND RASTER for (int row = 0 ; row <height ; row ++) { for (int col = 0 ; col<width; col++) { int pixel = pixellabel[row][col]; if (pixel != -1 ) pixellabel[row][col] = *equiv[pixel]; } } if (DEBUG_LABELS) { console_printf("generating label debugging text file RELEASE/DEBUGFILE.TXT"); FILE *debugfile; fopen_s(&debugfile,"debugfile1.txt","w"); for(int row=0; row<height; row++) { for(int col=0; col<width; col++) fprintf(debugfile,"%3d",pixellabel[row][col]); fprintf(debugfile,"\n"); } fclose(debugfile); } // determine number of objects in the image // specify a unique color for each object // assign color to all pixels in each objet int arr_objpixcount [2000]; int arr_objpixcount_cent_x [2000]; int arr_objpixcount_cent_y [2000]; int arr_REAL_objpixcount [2000]; for (int i = 0 ; i<2000; i++) { arr_objpixcount[i]=0; arr_REAL_objpixcount[i]=0; arr_objpixcount_cent_x[i]=0; arr_objpixcount_cent_y[i]=0; } for (int row = 0 ; row<height; row++) { for(int col =0 ; col<width; col++) { if(pixellabel[row][col] != -1) { int label = pixellabel[row][col]; arr_objpixcount[label]++; } } } int count=1; int numobj=0; for (int i = 0 ; i<2000; i++) { if(arr_objpixcount[i]<500 && arr_objpixcount[i]>120) { arr_REAL_objpixcount[count] = arr_objpixcount[i]; arr_objpixcount[i]=count; numobj++; count++; } else { arr_objpixcount[i]=0; } } for (int row = 0 ; row<height; row++) { for(int col =0 ; col<width; col++) { if(pixellabel[row][col] !=-1){ if(arr_objpixcount[pixellabel[row][col]]!=0) { pixellabel[row][col]= arr_objpixcount[pixellabel[row][col]]; arr_objpixcount_cent_x[pixellabel[row][col]] += col; arr_objpixcount_cent_y[pixellabel[row][col]] += row; } else pixellabel[row][col]=-1; } } } for (int i = 1; i < (numobj+1); i++) { arr_objpixcount_cent_x[i] = arr_objpixcount_cent_x[i]/arr_REAL_objpixcount[i]; arr_objpixcount_cent_y[i] = arr_objpixcount_cent_y[i]/arr_REAL_objpixcount[i]; double xw = arr_objpixcount_cent_x[i]*.0829 - arr_objpixcount_cent_y[i]*.2612+27.5039; double yw = arr_objpixcount_cent_x[i]*-.2639 -arr_objpixcount_cent_y[i]*.0784+73.7124; console_printf("Object %d Centroid: (%d, %d), world: %lf %lf\n", i, arr_objpixcount_cent_x[i], arr_objpixcount_cent_y[i],xw,yw); } console_printf("The number of Dan Blocks are %d\n", numobj); // assign UNIQUE color to each object for(int row=0; row<height; row++) { for(int col=0; col<width; col++) { switch ((pixellabel[row][col]%3)+1) { case 1: red = 255; green = 0; blue = 0; break; case 2: red = 0; green = 255; blue = 0; break; case 3: red = 0; green = 0; blue = 255; break; default: red = 255; green = 255; blue = 255; break; } rgbaddress=pfirstassociatedrgb+row*width+col; *(rgbaddress)=qRgb(red,green,blue); } } //crosshairs for(int row=0; row<height; row++) { for(int col=0; col<width; col++) { for (int i = 1; i < (numobj+1); i++) { if((arr_objpixcount_cent_x[i] == col) || (arr_objpixcount_cent_y[i] == row)) { red = 0; green = 0; blue = 0; rgbaddress=pfirstassociatedrgb+row*width+col; *(rgbaddress)=qRgb(red,green,blue); } } } } // prints the array of pixel labels to a text file RELEASE/DEBUGFILE.TXT for you to view if (DEBUG_LABELS) { console_printf("generating label debugging text file RELEASE/DEBUGFILE.TXT"); console_printf("Width is %d , Height is %d \n", width, height); FILE *debugfile; fopen_s(&debugfile,"debugfile2.txt","w"); for(int row=0; row<height; row++) { for(int col=0; col<width; col++) fprintf(debugfile,"%3d",pixellabel[row][col]); fprintf(debugfile,"\n"); } fclose(debugfile); } // clean up memory for (int i=0;i<height;i++) { delete pixellabel[i]; } delete pixellabel; }
static void print_lame_tag_leading_info(lame_global_flags * gf) { if (lame_get_bWriteVbrTag(gf)) console_printf("Writing LAME Tag..."); }
void user_init(void) { int i; uint8_t buffer[16]; loop_size = rand(); // Data to write uint8_t msg1[] = "Test Message #1"; uint8_t msg2[] = "Test Message #2"; uint8_t msg3[] = "Hello world!"; //Init uart uart_init(BIT_RATE_115200, BIT_RATE_115200); sleepms(1); console_printf("Booting...\r\n"); console_printf("-----------------------------------------------\r\n"); console_printf("AT24C512 Library Benchmark\r\n"); console_printf("-----------------------------------------------\r\n"); // i2c init i2c_init(); // Erase memory eeprom_erase(DEVICEADDRESS, 0, 224); console_printf("-----------------------------------------------\r\n"); // Write some stuff to EEPROM if(!eeprom_writePage(DEVICEADDRESS, 0x00, msg1, sizeof(msg1))) console_printf("Failed write, address: %d, data: %s\r\n", 0x00, msg1); else console_printf("Message 1 stored in the memory.\r\n"); if(!eeprom_writePage(DEVICEADDRESS, 0x40, msg2, sizeof(msg2))) console_printf("Failed write, address: %d, data: %s\r\n", 0x40, msg2); else console_printf("Message 2 stored in the memory.\r\n"); if(!eeprom_writePage(DEVICEADDRESS, 0x80, msg3, sizeof(msg3))) console_printf("Failed write, address: %d, data: %s\r\n", 0x80, msg3); else console_printf("Message 3 stored in the memory.\r\n"); console_printf("-----------------------------------------------\r\n"); // Read the first page in EEPROM memory, a byte at a time console_printf("EEPROM read byte, starting at 0x000:\r\n"); for (i = 0; i < sizeof(msg1)-1; i++) { uint8_t b = eeprom_readByte(DEVICEADDRESS, i); console_printf("0x%02x ", b); } console_printf("\r\n"); for (i = 0; i < sizeof(msg1)-1; i++) { uint8_t b = eeprom_readByte(DEVICEADDRESS, i); console_printf("%c ", isprint(b) ? b : '.'); } console_printf("\r\n"); console_printf("-----------------------------------------------\r\n"); console_printf("EEPROM read buffer, starting at 0x000:\r\n"); os_sprintf(buffer, "%s", eeprom_readPage(DEVICEADDRESS, 0, sizeof(buffer)), sizeof(buffer)); //First print the hex bytes on this row for (i = 0; i < sizeof(buffer)-1; i++) { char outbuf[6]; console_printf("0x%02x ", buffer[i]); } console_printf("\r\n"); for (i = 0; i < sizeof(buffer)-1; i++) { char outbuf[6]; console_printf("%c ", isprint(buffer[i]) ? buffer[i] : '.'); } console_printf("\r\n"); console_printf("-----------------------------------------------\r\n"); // Now dump 224 bytes console_printf("EEPROM dump:\r\n"); eeprom_dump(DEVICEADDRESS, 0, 224); // Start write benchmark test writeByByteTest(); // Start read benchmark test readByByteTest(); system_os_task(user_procTask, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen); }
static int cc_get(const char **argv, int argc) { if (argc > 0) { if (strcmp(argv[0], "park_rating") == 0) { console_printf("park_rating %d", RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_PARK_RATING, sint16)); } else if (strcmp(argv[0], "money") == 0) { console_printf("money %d.%d0", DECRYPT_MONEY(RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_MONEY_ENCRYPTED, money32)) / 10, DECRYPT_MONEY(RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_MONEY_ENCRYPTED, money32)) % 10); } else if (strcmp(argv[0], "current_loan") == 0) { console_printf("current_loan %d", RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_LOAN, money32) / 10); } else if (strcmp(argv[0], "max_loan") == 0) { console_printf("max_loan %d", RCT2_GLOBAL(RCT2_ADDRESS_MAXIMUM_LOAN, money32) / 10); } else if (strcmp(argv[0], "guest_initial_cash") == 0) { console_printf("guest_initial_cash %d.%d0", RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_CASH, money16) / 10, RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_CASH, money16) % 10); } else if (strcmp(argv[0], "guest_initial_happiness") == 0) { uint32 current_happiness = RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_HAPPINESS, uint8); for (int i = 15; i <= 99; i++) { if (i == 99) { console_printf("guest_initial_happiness %d%% (%d)", 15, RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_HAPPINESS, uint8)); } else if (current_happiness == calculate_guest_initial_happiness(i)) { console_printf("guest_initial_happiness %d%% (%d)", i, RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_HAPPINESS, uint8)); break; } } } else if (strcmp(argv[0], "guest_initial_hunger") == 0) { console_printf("guest_initial_hunger %d%% (%d)", ((255 - RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_HUNGER, uint8)) * 100) / 255, RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_HUNGER, uint8)); } else if (strcmp(argv[0], "guest_initial_thirst") == 0) { console_printf("guest_initial_thirst %d%% (%d)", ((255 - RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_THIRST, uint8)) * 100) / 255, RCT2_GLOBAL(RCT2_ADDRESS_GUEST_INITIAL_THIRST, uint8)); } else if (strcmp(argv[0], "guest_prefer_less_intense_rides") == 0) { console_printf("guest_prefer_less_intense_rides %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PREF_LESS_INTENSE_RIDES) != 0); } else if (strcmp(argv[0], "guest_prefer_more_intense_rides") == 0) { console_printf("guest_prefer_more_intense_rides %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PREF_MORE_INTENSE_RIDES) != 0); } else if (strcmp(argv[0], "forbid_marketing_campagns") == 0) { console_printf("forbid_marketing_campagns %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_FORBID_MARKETING_CAMPAIGN) != 0); } else if (strcmp(argv[0], "forbid_landscape_changes") == 0) { console_printf("forbid_landscape_changes %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_FORBID_LANDSCAPE_CHANGES) != 0); } else if (strcmp(argv[0], "forbid_tree_removal") == 0) { console_printf("forbid_tree_removal %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_FORBID_TREE_REMOVAL) != 0); } else if (strcmp(argv[0], "forbid_high_construction") == 0) { console_printf("forbid_high_construction %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_FORBID_HIGH_CONSTRUCTION) != 0); } else if (strcmp(argv[0], "pay_for_rides") == 0) { console_printf("pay_for_rides %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PARK_FREE_ENTRY) != 0); } else if (strcmp(argv[0], "no_money") == 0) { console_printf("no_money %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_NO_MONEY) != 0); } else if (strcmp(argv[0], "difficult_park_rating") == 0) { console_printf("difficult_park_rating %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_DIFFICULT_PARK_RATING) != 0); } else if (strcmp(argv[0], "difficult_guest_generation") == 0) { console_printf("difficult_guest_generation %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_DIFFICULT_GUEST_GENERATION) != 0); } else if (strcmp(argv[0], "park_open") == 0) { console_printf("park_open %d", (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PARK_OPEN) != 0); } else if (strcmp(argv[0], "land_rights_cost") == 0) { console_printf("land_rights_cost %d.%d0", RCT2_GLOBAL(RCT2_ADDRESS_LAND_COST, money16) / 10, RCT2_GLOBAL(RCT2_ADDRESS_LAND_COST, money16) % 10); } else if (strcmp(argv[0], "construction_rights_cost") == 0) { console_printf("construction_rights_cost %d.%d0", RCT2_GLOBAL(RCT2_ADDRESS_CONSTRUCTION_RIGHTS_COST, money32) / 10, RCT2_GLOBAL(RCT2_ADDRESS_CONSTRUCTION_RIGHTS_COST, money32) % 10); } else if (strcmp(argv[0], "climate") == 0) { const char* climate_names[] = { "cool_and_wet", "warm", "hot_and_dry", "cold" }; console_printf("climate %s (%d)", climate_names[RCT2_GLOBAL(RCT2_ADDRESS_CLIMATE, sint8)], RCT2_GLOBAL(RCT2_ADDRESS_CLIMATE, sint8)); } else if (strcmp(argv[0], "game_speed") == 0) { console_printf("game_speed %d", gGameSpeed); } else if (strcmp(argv[0], "console_small_font") == 0) { console_printf("console_small_font %d", gConfigInterface.console_small_font); } else if (strcmp(argv[0], "test_unfinished_tracks") == 0) { console_printf("test_unfinished_tracks %d", gConfigGeneral.test_unfinished_tracks); } else if (strcmp(argv[0], "no_test_crashes") == 0) { console_printf("no_test_crashes %d", gConfigGeneral.no_test_crashes); } else { console_writeline_warning("Invalid variable."); } } return 0; }
static int tcc_compile_and_run(char* filename) { console_printf("Compiling script %s...\n", filename); void* tcc = NULL; TCCState * script_state = NULL; void* script_buf = NULL; tcc = module_load("ML/MODULES/tcc.mo"); if (!tcc) { console_printf("Could not load TCC compiler.\n"); goto err; } script_state = (void*) module_exec(tcc, "tcc_new", 0); if (!script_state) { console_printf("Could not initialize TCC compiler.\n"); goto err; } module_exec(tcc, "tcc_set_options", 2, script_state, "-nostdlib"); module_exec(tcc, "tcc_set_options", 2, script_state, "-Wall"); module_exec(tcc, "tcc_set_options", 2, script_state, "-IML/scripts"); module_exec(tcc, "tcc_set_output_type", 2, script_state, TCC_OUTPUT_MEMORY); int ret_compile = module_exec(tcc, "tcc_add_file", 2, script_state, filename); if (ret_compile < 0) { console_printf("Compilation error.\n"); goto err; } script_load_symbols(tcc, script_state, "ML/modules/5D3_113.sym"); int size = module_exec(tcc, "tcc_relocate", 2, script_state, NULL); if (size <= 0) { console_printf("Linking error.\n"); goto err; } script_buf = (void*) tcc_malloc(size); if (!script_buf) { console_printf("Malloc error.\n"); goto err; } int ret_link = module_exec(tcc, "tcc_relocate", 2, script_state, script_buf); if (ret_link < 0) { console_printf("Relocate error.\n"); goto err; } void (*script_main)() = (void*) module_exec(tcc, "tcc_get_symbol", 2, script_state, "main"); if (!script_main) { console_printf("Your script should have a main function.\n"); goto err; } script_define_param_variables(tcc, script_state); module_exec(tcc, "tcc_delete", 1, script_state); script_state = NULL; module_unload(tcc); tcc = NULL; console_printf("Running script %s...\n", filename); /* http://repo.or.cz/w/tinycc.git/commit/6ed6a36a51065060bd5e9bb516b85ff796e05f30 */ sync_caches(); script_main(); tcc_free(script_buf); script_buf = NULL; return 0; err: if (script_buf) tcc_free(script_buf); if (script_state) module_exec(tcc, "tcc_delete", 1, script_state); if (tcc) module_unload(tcc); return 1; }
void schedule(void) { pid_t pid = current->p_pid; unsigned int lowest = 0xffffffff; // initialized to INTMAX switch (scheduling_algorithm) { case 0: // round-robin scheduling while (1) { pid = (pid + 1) % NPROCS; // Run the selected process, but skip // non-runnable processes. // Note that the 'run' function does not return. if (proc_array[pid].p_state == P_RUNNABLE) run(&proc_array[pid]); } break; case 1: // pid-priority scheduling while (1) { // run highest-priority, runnable process for (pid = 0; pid < NPROCS; pid++) if (proc_array[pid].p_state == P_RUNNABLE) run(&proc_array[pid]); } break; case 2: // set-priority scheduling while (1) { // get highest-priority number pid_t i; for (i = 0; i < NPROCS; i++) if (proc_array[i].p_state == P_RUNNABLE && proc_array[i].p_priority < lowest) lowest = proc_array[i].p_priority; // search first highest-priority task pid = (pid + 1) % NPROCS; // to alternate, start with next proc if (proc_array[pid].p_state == P_RUNNABLE && proc_array[pid].p_priority <= lowest) run(&proc_array[pid]); } break; case 3: // proportional-share scheduling while (1) { if (proc_array[pid].p_state == P_RUNNABLE) { // skip if run more than share if (proc_array[pid].p_run_t >= proc_array[pid].p_share) { proc_array[pid].p_run_t = 0; } else { proc_array[pid].p_run_t++; run(&proc_array[pid]); } } pid = (pid + 1) % NPROCS; // don't change procs until share up } break; default: break; }; // If we get here, we are running an unknown scheduling algorithm. cursorpos = console_printf(cursorpos, 0x100, "\nUnknown scheduling algorithm %d\n", scheduling_algorithm); while (1) /* do nothing */; }
int main(void) { /* generic hw init */ hw_init(); /* init uart */ uart_init(); #ifdef DEBUG_INIT printf("AlceOSD hw%dv%d fw%d.%d.%d\r\n", hw_rev >> 4, hw_rev & 0xf, VERSION_MAJOR, VERSION_MINOR, VERSION_DEV); if (RCONbits.WDTO) printf("watchdog reset\r\n"); if (RCONbits.EXTR) printf("external reset\r\n"); if (RCONbits.SWR) printf("software reset\r\n"); if (RCONbits.IOPUWR) printf("ill opcode / uninit W reset\r\n"); if (RCONbits.WDTO) printf("trap conflict reset\r\n"); #endif /* real time clock init */ clock_init(); /* adc init */ adc_init(); /* init video driver */ init_video(); /* try to load config from flash */ config_init(); /* init widget modules */ widgets_init(); /* setup tabs */ tabs_init(); /* welcome message */ console_printf("AlceOSD hw%dv%d fw%d.%d.%d\n", hw_rev >> 4, hw_rev & 0xf, VERSION_MAJOR, VERSION_MINOR, VERSION_DEV); /* init home tracking */ init_home(); /* init flight status tracking */ init_flight_stats(); /* init mavlink module */ mavlink_init(); /* init uavtalk module */ uavtalk_init(); /* link serial ports to processes */ uart_set_config_clients(1); /* enable all interrupts */ _IPL = 0; _IPL3 = 1; console_printf("Processes running...\n"); /* main loop */ process_run(); return 0; }
void cmd_line_help(const char *args) { console_printf("help:\nAvailable terminal commands:\n"); print_all_functions(); console_printf("\nFor help with a specific command, type \"<command> --help\"\n"); }
void keyboard_handler(struct isr_registers regs) { char c = inb(60); console_printf(&c); }
/** * cmd bat help * * Help for the bat command. * */ static void cmd_bat_help(void) { console_printf("Usage: bat <cmd> [options]\n"); console_printf("Available bat commands:\n"); console_printf(" pollrate <time_in_s>\n"); console_printf(" monitor [<prop>] [off]\n"); console_printf(" list\n"); console_printf(" read [<prop>] | all\n"); console_printf(" write <prop> <value>\n"); console_printf("Examples:\n"); console_printf(" list\n"); console_printf(" monitor VoltageADC\n"); console_printf(" monitor off\n"); console_printf(" read Voltage\n"); console_printf(" read all\n"); console_printf(" write VoltageLoAlarmSet\n"); }
void cmd_line_show_prompt() { console_set_fgcolor(255, 100, 100); console_printf("%s > ", get_cur_path()); console_set_fgcolor(255, 255, 255); }
void lightHashSortPrune(lightlistdist_t * list, const vec_t lmaxdist, const unsigned int max){ unsigned int count = list->count; unsigned int bucketcount = (count / 10) +1; // console_printf("bucketcount is %i\n", bucketcount); //todo fix this? vec_t bucketsize = lmaxdist / (vec_t)(bucketcount-1); lightbuckethead_t * table = malloc(bucketcount * sizeof(lightbuckethead_t)); memset(table, 0 , bucketcount * sizeof(lightbuckethead_t)); // int lighthash = dist / bucketsize; unsigned int i; vec_t * dist = list->dist; light_t ** tlist = list->list; //fill table for(i = 0; i < count; i++){ unsigned int lighthash = (int)(dist[i] / bucketsize); if(lighthash > bucketcount) console_printf("u dun goofed now! %i:%i:%i:%i\n", lighthash, dist, bucketsize, bucketcount); // printf("lighthash is %i\n", lighthash); lightbuckethead_t * h = &table[lighthash]; lightbucket_t * j = malloc(sizeof(lightbucket_t)); j->l = tlist[i]; j->dist = dist[i]; j->next = 0; if(h->tail){ lightbucket_t *l = h->tail; l->next = j; } else { h->next = j; } h->tail = j; h->count++; } //dont need to keep that extra data around, so im gonna prune it off now list->list = realloc(list->list, max * sizeof(light_t *)); list->dist = realloc(list->dist, max * sizeof(vec_t)); list->count = max; //go through table, find the "pivot" slot unsigned int lcount = 0; unsigned int pivot = 0; for(pivot = 0; pivot < bucketcount; pivot++){ lcount+=table[pivot].count; if(lcount >= max) break; } //i should be at the pivot slot lightlistdist_t tosort = {0, 0, 0, 0}; if(lcount != max){ //organize pivot slot into a new lightlistdist tosort.count = table[pivot].count; tosort.list = malloc(tosort.count * sizeof(light_t *)); tosort.dist = malloc(tosort.count * sizeof(vec_t)); lightbucket_t * b = table[pivot].next; for(i = 0; i < tosort.count; i++){ tosort.list[i] = b->l; tosort.dist[i] = b->dist; b = b->next; } //sort my new lightlistdist lightQuickSort(tosort, 0 , tosort.count-1); } else { // buckets lined up perfectly so that pivot slot can be full pivot++; } // go through buckets, pushing their data into my output list unsigned int outarrayloc = 0; for(i=0; i < pivot; i++){ lightbucket_t * b = table[i].next; for(; b; b = b->next){ list->list[outarrayloc] = b->l; list->dist[outarrayloc] = b->dist; outarrayloc++; } } //now copy over the temporary list if(lcount != max){ unsigned int tlistlength = max - outarrayloc; memcpy(&list->list[outarrayloc], tosort.list, tlistlength * sizeof(light_t *)); memcpy(&list->dist[outarrayloc], tosort.dist, tlistlength * sizeof(vec_t)); } //at this point my input list should be pruned and fixed //free temp lightlistdist if(tosort.list) free(tosort.list); if(tosort.dist) free(tosort.dist); //walk and free table for(i=0; i < bucketcount; i++){ lightbucket_t * b = table[i].next; lightbucket_t * next; for(; b; b = next){ next = b->next; free(b); } } if(table)free(table); }
void lab_help() { console_printf("find get color information for a pixel in any of the four images\n"); console_printf("pick click on an object to direct the Rhino to pick it up\n"); console_printf("place click on a location for the Rhino to place the object in its gripper\n"); }
void thresholdImage(QImage *gray, QImage *threshed) // For use with Lab 5 // Take a grayscale bitmap and threshold it. // The image pointer has dimension width by height pixels. { int totalpixels; uchar graylevel; // think of the uchar datatype as an integer that occupies only one byte in memory. uchar *pfirstgraybyte, *pgraybyte; QRgb *pfirstthreshedrgb; totalpixels = gray->numBytes()/4; // total number of pixels in image pfirstgraybyte = gray->bits(); // address of first byte of pixel data in image gray pfirstthreshedrgb = (QRgb*)threshed->bits();// address of first RGBA triplet in image threshed int zt=0; // threshold grayscale value int hist [256]; for (int i = 0 ; i<256 ; i++) { hist[i]=0; } for (int i = 0 ; i<totalpixels; i++) { int pix_val = (*(pfirstgraybyte+4*i)+*(pfirstgraybyte+4*i+1)+*(pfirstgraybyte+4*i+2))/3; hist[pix_val]+=1; } int max = -999; for (int i = 0 ; i<256 ; i++) { int test_z = i; double q0=0; double q1=0; double u0 = 0; double u1 = 0; int t1 = 0; int t0 = 0; for (int j=0 ;j<=test_z; j++) { q0 = q0+hist[j]; u0 = u0+j*hist[j]; t0 = t0+hist[j]; } for (int j=test_z+1; j<256 ; j++) { q1 = q1+hist[j]; u1 = u1+j*hist[j]; t1 = t1+hist[j]; } q0 = q0/totalpixels; q1 = q1/totalpixels; if(t0==0) u0 = u0/.0001; else u0 = u0/t0; if(t1==0) u1 = u1/.0001; else u1 = u1/t1; double sigmab = q0*(1-q0)*(u0-u1)*(u0-u1); if(sigmab>max) { zt = i; max =sigmab; } } console_printf("The threshold is zt %d\n",zt); // 1. build a histogram for the gray image // 2. select value of zt that minimizes the within-group variance // zt = 127; // blantantly wrong, just here as an example // threshold the image for(int i=0; i<totalpixels; i++) { pgraybyte = pfirstgraybyte+i*4; graylevel = *(pgraybyte); if(graylevel>zt) *(pfirstthreshedrgb+i)=0xffffffff; // set rgb to 255 (white) else *(pfirstthreshedrgb+i)=0x00000000; // set rgb to 0 (black) } }
/** * Returns true if the touchscreen was touched */ bool sense_touch_screen( uint_fast8_t tile_width, uint_fast8_t *tile_row_p, uint_fast8_t *tile_column_p) { # define XDELTA_MAX 16 //32 //100 # define YDELTA_MAX 12 //24 //100 # define NUM_SAMPLES 4 //4 //2 # define RESOLUTION_BITS 10 # define SETTLING_DELAY() delay_loop(10000) /* * Approx. 50000 CPU clock cycles. If The CPU clock frequency is 72MHz, * there are 72000 CPU clock cycles in 1 ms. So the settling delay is less * than 1 ms. */ uint_fast16_t x_samples[NUM_SAMPLES*2]; uint_fast16_t y_samples[NUM_SAMPLES*2]; uint_fast16_t x_reading; uint_fast16_t y_reading; uint_fast8_t i; uint_fast16_t yvalue_min = 1023; uint_fast16_t yvalue_max = 0; uint_fast16_t xvalue_min = 1023; uint_fast16_t xvalue_max = 0; uint_fast16_t xdelta, ydelta; uint_fast16_t ts_max_value = 2 <<(RESOLUTION_BITS-1); for (i = 0; i < NUM_SAMPLES; i++) { /* * Power the "x-axis" layer of the touch panel, and use the "y-axis" * layer to measure voltage corresponding to the x-axis position: */ touch_screen_polarize_X1_X2(); select_input_pin_adc_channel(TOUCH_SCREEN_Y_ADC_CHANNEL); SETTLING_DELAY(); x_samples[i*2] = read_adc_channel(g_adc_device_p, TOUCH_SCREEN_Y_ADC_CHANNEL); /* * Power the "y-axis" layer of the touch panel, and use the "x-axis" * layer to measure voltage corresponding to the y-axis position: */ touch_screen_polarize_Y1_Y2(); select_input_pin_adc_channel(TOUCH_SCREEN_X_ADC_CHANNEL); SETTLING_DELAY(); y_samples[i*2] = read_adc_channel(g_adc_device_p, TOUCH_SCREEN_X_ADC_CHANNEL); /* * Power the "x-axis" layer of the touch panel, and use the "y-axis" * layer to measure voltage corresponding to the x-axis position: */ touch_screen_polarize_X2_X1(); select_input_pin_adc_channel(TOUCH_SCREEN_Y_ADC_CHANNEL); SETTLING_DELAY(); x_samples[(i*2)+1] = read_adc_channel(g_adc_device_p, TOUCH_SCREEN_Y_ADC_CHANNEL); /* * Power the "y-axis" layer of the touch panel, and use the "x-axis" * layer to measure voltage corresponding to the y-axis position: */ touch_screen_polarize_Y2_Y1(); select_input_pin_adc_channel(TOUCH_SCREEN_X_ADC_CHANNEL); SETTLING_DELAY(); y_samples[(i*2)+1] = read_adc_channel(g_adc_device_p, TOUCH_SCREEN_X_ADC_CHANNEL); } x_reading = 0; y_reading = 0; for (i = 0; i < NUM_SAMPLES; i ++) { uint_fast16_t tempyval = ts_max_value - y_samples[i*2+1]; uint_fast16_t tempxval = ts_max_value - x_samples[i*2+1]; x_reading += x_samples[i*2]; y_reading += y_samples[i*2]; x_reading += (ts_max_value - x_samples[(i*2)+1]); y_reading += (ts_max_value - y_samples[(i*2)+1]); if (yvalue_min > y_samples[i*2]) { yvalue_min = y_samples[i*2]; } if (yvalue_max < y_samples[i*2]) { yvalue_max = y_samples[i*2]; } if (yvalue_min > tempyval) { yvalue_min = tempyval; } if (yvalue_min < tempyval) { yvalue_max = tempyval; } if (xvalue_min > x_samples[i*2]) { xvalue_min = x_samples[i*2]; } if (xvalue_max < x_samples[i*2]) { xvalue_max = x_samples[i*2]; } if (xvalue_min > tempxval) { xvalue_min = tempxval; } if (xvalue_min < tempxval) { xvalue_max = tempxval; } } x_reading /= NUM_SAMPLES*2; y_reading /= NUM_SAMPLES*2; xdelta = xvalue_max - xvalue_min; ydelta = yvalue_max - yvalue_min; if (x_reading < 1022 && y_reading > 1 && xdelta < XDELTA_MAX && ydelta < YDELTA_MAX) { #if 0 // XXX extern volatile uint32_t tile_cursor_index; extern volatile uint32_t same_tile_count; console_printf( "tile_cursor_index: %u, same_tile_count: %u, x_reading: %u, y_reading: %u\n", tile_cursor_index, same_tile_count, x_reading, y_reading); ATOMIC_POST_INCREMENT_UINT32(&same_tile_count); #endif // XXX map_xy_reading_to_tile( x_reading, y_reading, tile_width, tile_row_p, tile_column_p); return true; } return false; }
static void timestatus(const lame_global_flags * const gfp) { timestatus_t* real_time = &global_encoder_progress.real_time; timestatus_t* proc_time = &global_encoder_progress.proc_time; int percent; double tmx, delta; int samp_rate = lame_get_out_samplerate(gfp) , frameNum = lame_get_frameNum(gfp) , totalframes = lame_get_totalframes(gfp) , framesize = lame_get_framesize(gfp) ; if (totalframes < frameNum) { totalframes = frameNum; } if (global_encoder_progress.time_status_init == 0) { real_time->last_time = GetRealTime(); proc_time->last_time = GetCPUTime(); real_time->elapsed_time = 0; proc_time->elapsed_time = 0; } /* we need rollover protection for GetCPUTime, and maybe GetRealTime(): */ tmx = GetRealTime(); delta = tmx - real_time->last_time; if (delta < 0) delta = 0; /* ignore, clock has rolled over */ real_time->elapsed_time += delta; real_time->last_time = tmx; tmx = GetCPUTime(); delta = tmx - proc_time->last_time; if (delta < 0) delta = 0; /* ignore, clock has rolled over */ proc_time->elapsed_time += delta; proc_time->last_time = tmx; if (global_encoder_progress.time_status_init == 0) { console_printf("\r" " Frame | CPU time/estim | REAL time/estim | play/CPU | ETA \n" " 0/ ( 0%%)| 0:00/ : | 0:00/ : | " SPEED_CHAR "| : \r" /* , Console_IO.str_clreoln, Console_IO.str_clreoln */ ); global_encoder_progress.time_status_init = 1; return; } ts_calc_times(real_time, samp_rate, frameNum, totalframes, framesize); ts_calc_times(proc_time, samp_rate, frameNum, totalframes, framesize); if (frameNum < totalframes) { percent = (int) (100. * frameNum / totalframes + 0.5); } else { percent = 100; } console_printf("\r%6i/%-6i", frameNum, totalframes); console_printf(percent < 100 ? " (%2d%%)|" : "(%3.3d%%)|", percent); ts_time_decompose(proc_time->elapsed_time, '/'); ts_time_decompose(proc_time->estimated_time, '|'); ts_time_decompose(real_time->elapsed_time, '/'); ts_time_decompose(real_time->estimated_time, '|'); console_printf(proc_time->speed_index <= 1. ? "%9.4f" SPEED_CHAR "|" : "%#9.5g" SPEED_CHAR "|", SPEED_MULT * proc_time->speed_index); ts_time_decompose((real_time->estimated_time - real_time->elapsed_time), ' '); }
void task1_handler(void *arg) { int i; int rc; uint16_t rxval; uint8_t last_val; uint8_t spi_nb_cntr; uint8_t spi_b_cntr; /* Set the led pin for the E407 devboard */ g_led_pin = LED_BLINK_PIN; hal_gpio_init_out(g_led_pin, 1); /* Use SS pin for testing */ hal_gpio_init_out(SPI_SS_PIN, 1); sblinky_spi_cfg(0); hal_spi_set_txrx_cb(0, NULL, NULL); hal_spi_enable(0); /* * Send some bytes in a non-blocking manner to SPI using tx val. The * slave should send back 0x77. */ g_spi_tx_buf[0] = 0xde; g_spi_tx_buf[1] = 0xad; g_spi_tx_buf[2] = 0xbe; g_spi_tx_buf[3] = 0xef; hal_gpio_write(SPI_SS_PIN, 0); for (i = 0; i < 4; ++i) { rxval = hal_spi_tx_val(0, g_spi_tx_buf[i]); assert(rxval == 0x77); g_spi_rx_buf[i] = (uint8_t)rxval; } hal_gpio_write(SPI_SS_PIN, 1); ++g_spi_xfr_num; /* Set up the callback to use when non-blocking API used */ hal_spi_disable(0); spi_cb_arg = &spi_cb_obj; spi_cb_obj.txlen = 32; hal_spi_set_txrx_cb(0, sblinky_spi_irqm_handler, spi_cb_arg); hal_spi_enable(0); spi_nb_cntr = 0; spi_b_cntr = 0; while (1) { /* Wait one second */ os_time_delay(OS_TICKS_PER_SEC); /* Toggle the LED */ hal_gpio_toggle(g_led_pin); /* Get random length to send */ g_last_tx_len = spi_cb_obj.txlen; spi_cb_obj.txlen = (rand() & 0x1F) + 1; memcpy(g_spi_last_tx_buf, g_spi_tx_buf, g_last_tx_len); last_val = g_spi_last_tx_buf[g_last_tx_len - 1]; for (i= 0; i < spi_cb_obj.txlen; ++i) { g_spi_tx_buf[i] = (uint8_t)(last_val + i); } if (g_spi_xfr_num & 1) { /* Send non-blocking */ ++spi_nb_cntr; assert(hal_gpio_read(SPI_SS_PIN) == 1); hal_gpio_write(SPI_SS_PIN, 0); #if 0 if (spi_nb_cntr == 7) { g_spi_null_rx = 1; rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, NULL, 32); } else { g_spi_null_rx = 0; rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, g_spi_rx_buf, 32); } assert(!rc); #else g_spi_null_rx = 0; rc = hal_spi_txrx_noblock(0, g_spi_tx_buf, g_spi_rx_buf, spi_cb_obj.txlen); assert(!rc); console_printf("a transmitted: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_tx_buf[i]); } console_printf("\n"); console_printf("received: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_rx_buf[i]); } console_printf("\n"); #endif } else { /* Send blocking */ ++spi_b_cntr; assert(hal_gpio_read(SPI_SS_PIN) == 1); hal_gpio_write(SPI_SS_PIN, 0); #if 0 if (spi_b_cntr == 7) { g_spi_null_rx = 1; rc = hal_spi_txrx(0, g_spi_tx_buf, NULL, 32); spi_b_cntr = 0; } else { g_spi_null_rx = 0; rc = hal_spi_txrx(0, g_spi_tx_buf, g_spi_rx_buf, 32); } assert(!rc); hal_gpio_write(SPI_SS_PIN, 1); spitest_validate_last(spi_cb_obj.txlen); #else rc = hal_spi_txrx(0, g_spi_tx_buf, g_spi_rx_buf, spi_cb_obj.txlen); assert(!rc); hal_gpio_write(SPI_SS_PIN, 1); console_printf("b transmitted: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_tx_buf[i]); } console_printf("\n"); console_printf("received: "); for (i = 0; i < spi_cb_obj.txlen; i++) { console_printf("%2x ", g_spi_rx_buf[i]); } console_printf("\n"); spitest_validate_last(spi_cb_obj.txlen); ++g_spi_xfr_num; #endif } } }
static void timestatus_finish(void) { console_printf("\n"); }
camera_t * camera_open(const char *portname, int highres) { camera_internal_t *camera = (camera_internal_t*)malloc(sizeof(camera_internal_t)); camera->reader = NULL; if (highres) { console_printf("camera: highres is not supported on windows (yet).\n"); highres = 0; } HRESULT hr = S_OK; // Initialize Media Foundation if (SUCCEEDED(hr)) { hr = MFStartup(MF_VERSION); } /////////////////////////////////////////// IMFAttributes *pAttributes = NULL; UINT32 m_cDevices = 0; IMFActivate **m_ppDevices = NULL; // Initialize an attribute store. We will use this to // specify the enumeration parameters. hr = MFCreateAttributes(&pAttributes, 1); // Ask for source type = video capture devices if (SUCCEEDED(hr)) { hr = pAttributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); } // Enumerate devices. if (SUCCEEDED(hr)) { hr = MFEnumDeviceSources(pAttributes, &m_ppDevices, &m_cDevices); } SafeRelease(&pAttributes); ///////////////////////////////////////////////// IMFActivate *pActivate = NULL; if (m_cDevices) { console_printf("camera: there are %d camera devices connected (0..%d).\n", m_cDevices, m_cDevices > 0 ? m_cDevices - 1 : 0); int device = strtol(portname, 0, 10); if (device < 0 || device >= m_cDevices) console_printf("camera: device %d does not exist.\n", device); else pActivate = m_ppDevices[device]; } else { console_printf("camera: could not find a device\n"); } ///////////////////////////////////////////////// IMFMediaSource *pSource = NULL; //EnterCriticalSection(&m_critsec); // Create the media source for the device. hr = pActivate->ActivateObject( __uuidof(IMFMediaSource), (void**)&pSource ); /////////////////////////////////////////// //IMFAttributes *pAttributes = NULL; /*hr = MFCreateAttributes(&pAttributes, 2); if (SUCCEEDED(hr)) { hr = pAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this); }*/ if (SUCCEEDED(hr)) { hr = MFCreateSourceReaderFromMediaSource( pSource, NULL,//pAttributes, &camera->reader ); } //SafeRelease(&pAttributes); //////////////////////////////////////////////////// // The list of acceptable types. GUID subtypes[] = { MFVideoFormat_NV12, MFVideoFormat_YUY2, MFVideoFormat_UYVY, MFVideoFormat_RGB32, MFVideoFormat_RGB24, MFVideoFormat_IYUV }; //HRESULT hr = S_OK; BOOL bUseNativeType = FALSE; GUID subtype = { 0 }; IMFMediaType *pType = NULL; UINT32 width = 0, height = 0; int selectedSubtype = -1; // If the source's native format matches any of the formats in // the list, prefer the native format. // Note: The camera might support multiple output formats, // including a range of frame dimensions. The application could // provide a list to the user and have the user select the // camera's output format. That is outside the scope of this // sample, however. DWORD selectedStreamIndex = MF_SOURCE_READER_FIRST_VIDEO_STREAM; //while (true) //{ hr = camera->reader->GetNativeMediaType( selectedStreamIndex, 0, // Type index &pType ); if (FAILED(hr)) { console_printf("camera: could not get media type\n"); goto done; } hr = ::MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &width, &height); if (FAILED(hr)) { console_printf("camera: could not get resolution\n"); goto done; } //if (width != 1280 || height != 960) //{ console_printf("camera: found resolution %dx%d\n", width, height); //selectedStreamIndex++; //continue; //} camera->size.width = width; camera->size.height = height; //break; //} /*UINT32 num = 0, denom = 0; hr = ::MFGetAttributeRatio(pType, MF_MT_FRAME_RATE_RANGE_MAX, &num, &denom); if (FAILED(hr)) { goto done; }*/ //hr = ::MFSetAttributeSize(pType, MF_MT_FRAME_SIZE, 1280, 960); //if (FAILED(hr)) { goto done; } /*hr = ::MFSetAttributeRatio(pType, MF_MT_FRAME_RATE, num, denom); if (FAILED(hr)) { goto done; }*/ hr = pType->GetGUID(MF_MT_SUBTYPE, &subtype); if (FAILED(hr)) { console_printf("camera: could not get stream type(1)\n"); goto done; } for (UINT32 i = 0; i < ARRAYSIZE(subtypes); i++) { if (subtype == subtypes[i]) { hr = camera->reader->SetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, pType ); bUseNativeType = TRUE; selectedSubtype = i; break; } } if (!bUseNativeType) { // None of the native types worked. The camera might offer // output a compressed type such as MJPEG or DV. // Try adding a decoder. for (UINT32 i = 0; i < ARRAYSIZE(subtypes); i++) { hr = pType->SetGUID(MF_MT_SUBTYPE, subtypes[i]); if (FAILED(hr)) { console_printf("camera: could not get stream type(2)\n"); goto done; } hr = camera->reader->SetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, pType ); if (SUCCEEDED(hr)) { selectedSubtype = i; break; } } } /* hr = ::MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &width, &height); WIDTH = width; HEIGHT = height;*/ if (FAILED(hr)) { console_printf("camera: could not find stream type\n"); goto done; } done: SafeRelease(&pType); console_printf("camera: selected type: %d, native: %s, resolution: %dx%d\n", selectedSubtype, bUseNativeType ? "yes" : "no", camera->size.width, camera->size.height); /////////////////////////////////////// /*if (SUCCEEDED(hr)) { hr = camera->reader->GetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, &pType ); } if (SUCCEEDED(hr)) { // Register the color converter DSP for this process, in the video // processor category. This will enable the sink writer to enumerate // the color converter when the sink writer attempts to match the // media types. hr = MFTRegisterLocalByCLSID( __uuidof(CColorConvertDMO), MFT_CATEGORY_VIDEO_PROCESSOR, L"", MFT_ENUM_FLAG_SYNCMFT, 0, NULL, 0, NULL ); }*/ ///////////////////////////////////////////////// /* IMFSample *pSample = NULL; DWORD streamIndex = 0, flags = 0; LONGLONG llTimeStamp = 0; hr = camera->reader->ReadSample( (DWORD)MF_SOURCE_READER_ANY_STREAM, // Stream index. 0, // Flags. &streamIndex, // Receives the actual stream index. &flags, // Receives status flags. &llTimeStamp, // Receives the time stamp. &pSample // Receives the sample or NULL. );*/ if (selectedSubtype != 4) { console_printf("camera: unexpected stream type.\n"); SafeRelease(&camera->reader); free(camera); return 0; } return (camera_t*)camera; }
void encoder_progress_begin( lame_global_flags const* gf , char const* inPath , char const* outPath ) { brhist_init_package(gf); global_encoder_progress.time_status_init = 0; global_encoder_progress.last_time = 0; global_encoder_progress.last_frame_num = 0; if (global_ui_config.silent < 9) { char* i_file = 0; char* o_file = 0; #if defined( _WIN32 ) && !defined(__MINGW32__) inPath = i_file = utf8ToLocal8Bit(inPath); outPath = o_file = utf8ToConsole8Bit(outPath); #endif lame_print_config(gf); /* print useful information about options being used */ console_printf("Encoding %s%s to %s\n", strcmp(inPath, "-") ? inPath : "<stdin>", strlen(inPath) + strlen(outPath) < 66 ? "" : "\n ", strcmp(outPath, "-") ? outPath : "<stdout>"); free(i_file); free(o_file); console_printf("Encoding as %g kHz ", 1.e-3 * lame_get_out_samplerate(gf)); { static const char *mode_names[2][4] = { {"stereo", "j-stereo", "dual-ch", "single-ch"}, {"stereo", "force-ms", "dual-ch", "single-ch"} }; switch (lame_get_VBR(gf)) { case vbr_rh: console_printf("%s MPEG-%u%s Layer III VBR(q=%g) qval=%i\n", mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)], 2 - lame_get_version(gf), lame_get_out_samplerate(gf) < 16000 ? ".5" : "", lame_get_VBR_quality(gf), lame_get_quality(gf)); break; case vbr_mt: case vbr_mtrh: console_printf("%s MPEG-%u%s Layer III VBR(q=%g)\n", mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)], 2 - lame_get_version(gf), lame_get_out_samplerate(gf) < 16000 ? ".5" : "", lame_get_VBR_quality(gf)); break; case vbr_abr: console_printf("%s MPEG-%u%s Layer III (%gx) average %d kbps qval=%i\n", mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)], 2 - lame_get_version(gf), lame_get_out_samplerate(gf) < 16000 ? ".5" : "", 0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5), lame_get_VBR_mean_bitrate_kbps(gf), lame_get_quality(gf)); break; default: console_printf("%s MPEG-%u%s Layer III (%gx) %3d kbps qval=%i\n", mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)], 2 - lame_get_version(gf), lame_get_out_samplerate(gf) < 16000 ? ".5" : "", 0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5), lame_get_brate(gf), lame_get_quality(gf)); break; } } if (global_ui_config.silent <= -10) { lame_print_internals(gf); } } }
static int lis2dw12_shell_cmd_dump(int argc, char **argv) { uint8_t val; if (argc > 2) { return lis2dw12_shell_err_too_many_args(argv[1]); } /* Dump all the register values for debug purposes */ val = 0; assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_TEMP_L, &val)); console_printf("0x%02X (OUT_TEMP_L): 0x%02X\n", LIS2DW12_REG_OUT_TEMP_L, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_TEMP_H, &val)); console_printf("0x%02X (OUT_TEMP_H): 0x%02X\n", LIS2DW12_REG_OUT_TEMP_H, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_WHO_AM_I, &val)); console_printf("0x%02X (WHO_AM_I): 0x%02X\n", LIS2DW12_REG_WHO_AM_I, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG1, &val)); console_printf("0x%02X (CTRL1): 0x%02X\n", LIS2DW12_REG_CTRL_REG1, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG2, &val)); console_printf("0x%02X (CTRL2): 0x%02X\n", LIS2DW12_REG_CTRL_REG2, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG3, &val)); console_printf("0x%02X (CTRL3): 0x%02X\n", LIS2DW12_REG_CTRL_REG3, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG4, &val)); console_printf("0x%02X (CTRL4): 0x%02X\n", LIS2DW12_REG_CTRL_REG4, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG5, &val)); console_printf("0x%02X (CTRL5): 0x%02X\n", LIS2DW12_REG_CTRL_REG5, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG6, &val)); console_printf("0x%02X (CTRL6): 0x%02X\n", LIS2DW12_REG_CTRL_REG6, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TEMP_OUT, &val)); console_printf("0x%02X (TEMP_OUT): 0x%02X\n", LIS2DW12_REG_TEMP_OUT, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_STATUS_REG, &val)); console_printf("0x%02X (STATUS): 0x%02X\n", LIS2DW12_REG_STATUS_REG, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_X_L, &val)); console_printf("0x%02X (OUT_X_L): 0x%02X\n", LIS2DW12_REG_OUT_X_L, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_X_H, &val)); console_printf("0x%02X (OUT_X_H): 0x%02X\n", LIS2DW12_REG_OUT_X_H, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Y_L, &val)); console_printf("0x%02X (OUT_Y_L): 0x%02X\n", LIS2DW12_REG_OUT_Y_L, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Y_H, &val)); console_printf("0x%02X (OUT_Y_H): 0x%02X\n", LIS2DW12_REG_OUT_Y_H, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Z_L, &val)); console_printf("0x%02X (OUT_Z_L): 0x%02X\n", LIS2DW12_REG_OUT_Z_L, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_OUT_Z_H, &val)); console_printf("0x%02X (OUT_Z_H): 0x%02X\n", LIS2DW12_REG_OUT_Z_H, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_FIFO_CTRL, &val)); console_printf("0x%02X (FIFO_CTRL): 0x%02X\n", LIS2DW12_REG_FIFO_CTRL, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_FIFO_SAMPLES, &val)); console_printf("0x%02X (FIFO_SAMPLES): 0x%02X\n", LIS2DW12_REG_FIFO_SAMPLES, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TAP_THS_X, &val)); console_printf("0x%02X (TAP_THS_X): 0x%02X\n", LIS2DW12_REG_TAP_THS_X, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TAP_THS_Y, &val)); console_printf("0x%02X (TAP_THS_Y): 0x%02X\n", LIS2DW12_REG_TAP_THS_Y, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_TAP_THS_Z, &val)); console_printf("0x%02X (TAP_THS_Z): 0x%02X\n", LIS2DW12_REG_TAP_THS_Z, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_INT_DUR, &val)); console_printf("0x%02X (INT_DUR): 0x%02X\n", LIS2DW12_REG_INT_DUR, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_FREEFALL, &val)); console_printf("0x%02X (FREEFALL): 0x%02X\n", LIS2DW12_REG_FREEFALL, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_INT_SRC, &val)); console_printf("0x%02X (INT_SRC): 0x%02X\n", LIS2DW12_REG_INT_SRC, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_X_OFS, &val)); console_printf("0x%02X (X_OFS): 0x%02X\n", LIS2DW12_REG_X_OFS, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_Y_OFS, &val)); console_printf("0x%02X (Y_OFS): 0x%02X\n", LIS2DW12_REG_Y_OFS, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_Z_OFS, &val)); console_printf("0x%02X (Z_OFS): 0x%02X\n", LIS2DW12_REG_Z_OFS, val); assert(0 == lis2dw12_read8(&g_sensor_itf, LIS2DW12_REG_CTRL_REG7, &val)); console_printf("0x%02X (CTRL7): 0x%02X\n", LIS2DW12_REG_CTRL_REG7, val); return 0; }
void decoder_progress_finish(DecoderProgress dp) { (void) dp; console_printf("\n"); }
static int script_load_symbols(void* tcc, void* script_state, char *filename) { uint32_t size = 0; FILE* file = NULL; char *buf = NULL; uint32_t count = 0; uint32_t pos = 0; if( FIO_GetFileSize( filename, &size ) != 0 ) { console_printf("Error loading '%s': File does not exist\n", filename); return -1; } buf = fio_malloc(size); if(!buf) { console_printf("Error loading '%s': File too large\n", filename); return -1; } file = FIO_OpenFile(filename, O_RDONLY | O_SYNC); if(!file) { console_printf("Error loading '%s': File does not exist\n", filename); fio_free(buf); return -1; } FIO_ReadFile(file, buf, size); FIO_CloseFile(file); while(buf[pos]) { char address_buf[16]; char symbol_buf[128]; uint32_t length = 0; uint32_t address = 0; while(buf[pos + length] && buf[pos + length] != ' ' && length < sizeof(address_buf)) { address_buf[length] = buf[pos + length]; length++; } address_buf[length] = '\000'; pos += length + 1; length = 0; while(buf[pos + length] && buf[pos + length] != '\r' && buf[pos + length] != '\n' && length < sizeof(symbol_buf)) { symbol_buf[length] = buf[pos + length]; length++; } symbol_buf[length] = '\000'; pos += length + 1; length = 0; while(buf[pos + length] && (buf[pos + length] == '\r' || buf[pos + length] == '\n')) { pos++; } sscanf(address_buf, "%x", &address); module_exec(tcc, "tcc_add_symbol", 3, script_state, symbol_buf, (void*)address); count++; } /* ToDo: parse the old plugin sections as all needed OS stubs are already described there */ module_exec(tcc, "tcc_add_symbol", 3, script_state, "strcpy", &strcpy); module_exec(tcc, "tcc_add_symbol", 3, script_state, "strlen", &strlen); fio_free(buf); return 0; }
void schedule(void) { pid_t pid = current->p_pid; if (scheduling_algorithm == 0) while (1) { pid = (pid + 1) % NPROCS; // Run the selected process, but skip // non-runnable processes. // Note that the 'run' function does not return. if (proc_array[pid].p_state == P_RUNNABLE) run(&proc_array[pid]); } // priority scheduling else if(scheduling_algorithm == __EXERCISE_2__) { for(pid = 1; pid < NPROCS ; pid++) { if (proc_array[pid].p_state == P_RUNNABLE) break; } run(&proc_array[pid]); } else if(scheduling_algorithm == __EXERCISE_4A__) { int topPriority = 0; pid_t j; // get the top priority number for(j = 1; j < NPROCS ; j++) { if (proc_array[j].p_state == P_RUNNABLE) { topPriority = (topPriority >= proc_array[j].p_priority) ? topPriority : proc_array[j].p_priority; } } // alternate the processes if there are more than one with top priority while (1) { pid = (pid + 1) % NPROCS; if (proc_array[pid].p_state == P_RUNNABLE && proc_array[pid].p_priority == topPriority) break; } run(&proc_array[pid]); // proportional-share scheduling } else if(scheduling_algorithm == __EXERCISE_4B__) { int largest = -1; pid_t j; pid_t proc = 1; proc_array[pid].p_share_count--; //cursorpos = console_printf(cursorpos, 0x200, "pid=%d ", pid ); if(proc_array[pid].p_state == P_RUNNABLE && proc_array[pid].p_share_count > 0) { // cursorpos = console_printf(cursorpos, 0x200, "c=%d ", proc_array[pid].p_share_count ); run(&proc_array[pid]); } else { // find largest share that has not gone through in this turn for(j = 1; j < NPROCS ; j++) { if (proc_array[j].p_state == P_RUNNABLE && (proc_array[j].p_share_count > 1|| (proc_array[j].p_share == 1 && proc_array[j].p_share_count == 1))) { largest = (largest >= proc_array[j].p_share) ? largest : proc_array[j].p_share; } } // cursorpos = console_printf(cursorpos, 0x200, "L=%d ", largest); // current pid has share_count == 0, reinitialize it to its share value //proc_array[pid].p_share_count = proc_array[pid].p_share; // cant' find largeset? // that means every process went through a cycle(they all took turn printing out letters already.) if(largest == -1) { // reset all counts to share for(j=1; j < NPROCS ; j++) { if (proc_array[j].p_state == P_RUNNABLE) { proc_array[j].p_share_count = proc_array[j].p_share; // proc = (proc_array[proc].p_share >= proc_array[j].p_share) ? proc] : j; largest = (largest >= proc_array[j].p_share) ? largest : proc_array[j].p_share; } } } // cursorpos = console_printf(cursorpos, 0x200, "A=%d ", largest); // get pid from largest for(j = 1; j < NPROCS ; j++) { if (proc_array[j].p_state == P_RUNNABLE && proc_array[j].p_share == largest) { break; } } // cursorpos = console_printf(cursorpos, 0x200, "j=%d ", j); run(&proc_array[j]); } } else if(scheduling_algorithm == __EXERCISE_7__) { } // If we get here, we are running an unknown scheduling algorithm. cursorpos = console_printf(cursorpos, 0x100, "\nUnknown scheduling algorithm %d\n", scheduling_algorithm); while (1) /* do nothing */; }
int lame_decoder(lame_global_flags * gfp, FILE * outf, int skip_start, char *inPath, char *outPath, int *enc_delay, int *enc_padding) { short int Buffer[2][1152]; int iread; int skip_end = 0; double wavsize; int i; void (*WriteFunction) (FILE * fp, char *p, int n); int tmp_num_channels = lame_get_num_channels(gfp); if (silent < 10) console_printf("\rinput: %s%s(%g kHz, %i channel%s, ", strcmp(inPath, "-") ? inPath : "<stdin>", strlen(inPath) > 26 ? "\n\t" : " ", lame_get_in_samplerate(gfp) / 1.e3, tmp_num_channels, tmp_num_channels != 1 ? "s" : ""); switch (input_format) { case sf_mp123: /* FIXME: !!! */ error_printf("Internal error. Aborting."); exit(-1); case sf_mp3: if (skip_start == 0) { if (*enc_delay > -1 || *enc_padding > -1) { if (*enc_delay > -1) skip_start = *enc_delay + 528 + 1; if (*enc_padding > -1) skip_end = *enc_padding - (528 + 1); } else skip_start = lame_get_encoder_delay(gfp) + 528 + 1; } else { /* user specified a value of skip. just add for decoder */ skip_start += 528 + 1; /* mp3 decoder has a 528 sample delay, plus user supplied "skip" */ } if (silent < 10) console_printf("MPEG-%u%s Layer %s", 2 - lame_get_version(gfp), lame_get_out_samplerate(gfp) < 16000 ? ".5" : "", "III"); break; case sf_mp2: skip_start += 240 + 1; if (silent < 10) console_printf("MPEG-%u%s Layer %s", 2 - lame_get_version(gfp), lame_get_out_samplerate(gfp) < 16000 ? ".5" : "", "II"); break; case sf_mp1: skip_start += 240 + 1; if (silent < 10) console_printf("MPEG-%u%s Layer %s", 2 - lame_get_version(gfp), lame_get_out_samplerate(gfp) < 16000 ? ".5" : "", "I"); break; case sf_raw: if (silent < 10) console_printf("raw PCM data"); mp3input_data.nsamp = lame_get_num_samples(gfp); mp3input_data.framesize = 1152; skip_start = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; case sf_wave: if (silent < 10) console_printf("Microsoft WAVE"); mp3input_data.nsamp = lame_get_num_samples(gfp); mp3input_data.framesize = 1152; skip_start = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; case sf_aiff: if (silent < 10) console_printf("SGI/Apple AIFF"); mp3input_data.nsamp = lame_get_num_samples(gfp); mp3input_data.framesize = 1152; skip_start = 0; /* other formats have no delay *//* is += 0 not better ??? */ break; default: if (silent < 10) console_printf("unknown"); mp3input_data.nsamp = lame_get_num_samples(gfp); mp3input_data.framesize = 1152; skip_start = 0; /* other formats have no delay *//* is += 0 not better ??? */ assert(0); break; } if (silent < 10) { console_printf(")\noutput: %s%s(16 bit, Microsoft WAVE)\n", strcmp(outPath, "-") ? outPath : "<stdout>", strlen(outPath) > 45 ? "\n\t" : " "); if (skip_start > 0) console_printf("skipping initial %i samples (encoder+decoder delay)\n", skip_start); if (skip_end > 0) console_printf("skipping final %i samples (encoder padding-decoder delay)\n", skip_end); } if (0 == disable_wav_header) WriteWaveHeader(outf, 0x7FFFFFFF, lame_get_in_samplerate(gfp), tmp_num_channels, 16); /* unknown size, so write maximum 32 bit signed value */ wavsize = -(skip_start + skip_end); WriteFunction = swapbytes ? WriteBytesSwapped : WriteBytes; mp3input_data.totalframes = mp3input_data.nsamp / mp3input_data.framesize; assert(tmp_num_channels >= 1 && tmp_num_channels <= 2); do { iread = get_audio16(gfp, Buffer); /* read in 'iread' samples */ if (iread >= 0) { mp3input_data.framenum += iread / mp3input_data.framesize; wavsize += iread; if (silent <= 0) { decoder_progress(&mp3input_data); console_flush(); } skip_start -= (i = skip_start < iread ? skip_start : iread); /* 'i' samples are to skip in this frame */ if (skip_end > 1152 && mp3input_data.framenum + 2 > mp3input_data.totalframes) { iread -= (skip_end - 1152); skip_end = 1152; } else if (mp3input_data.framenum == mp3input_data.totalframes && iread != 0) iread -= skip_end; for (; i < iread; i++) { if (disable_wav_header) { WriteFunction(outf, (char *) &Buffer[0][i], sizeof(short)); if (tmp_num_channels == 2) WriteFunction(outf, (char *) &Buffer[1][i], sizeof(short)); } else { Write16BitsLowHigh(outf, Buffer[0][i]); if (tmp_num_channels == 2) Write16BitsLowHigh(outf, Buffer[1][i]); } } if (flush_write == 1) { fflush(outf); } } } while (iread > 0); i = (16 / 8) * tmp_num_channels; assert(i > 0); if (wavsize <= 0) { if (silent < 10) error_printf("WAVE file contains 0 PCM samples\n"); wavsize = 0; } else if (wavsize > 0xFFFFFFD0 / i) { if (silent < 10) error_printf("Very huge WAVE file, can't set filesize accordingly\n"); wavsize = 0xFFFFFFD0; } else { wavsize *= i; } /* if outf is seekable, rewind and adjust length */ if (!disable_wav_header && strcmp("-", outPath) && !fseek(outf, 0l, SEEK_SET)) WriteWaveHeader(outf, (int) wavsize, lame_get_in_samplerate(gfp), tmp_num_channels, 16); fclose(outf); if (silent <= 0) decoder_progress_finish(); return 0; }
static int do_adc (int argc, const char* const* argv) { console_printf("%d\n", system_adc_read()); return 0; }
static int lame_decoder(lame_t gfp, FILE * outf, char *inPath, char *outPath) { short int Buffer[2][1152]; int i, iread; double wavsize; int tmp_num_channels = lame_get_num_channels(gfp); int skip_start = samples_to_skip_at_start(); int skip_end = samples_to_skip_at_end(); DecoderProgress dp = 0; if (!(tmp_num_channels >= 1 && tmp_num_channels <= 2)) { error_printf("Internal error. Aborting."); exit(-1); } if (global_ui_config.silent < 9) { console_printf("\rinput: %s%s(%g kHz, %i channel%s, ", strcmp(inPath, "-") ? inPath : "<stdin>", strlen(inPath) > 26 ? "\n\t" : " ", lame_get_in_samplerate(gfp) / 1.e3, tmp_num_channels, tmp_num_channels != 1 ? "s" : ""); printInputFormat(gfp); console_printf(")\noutput: %s%s(16 bit, Microsoft WAVE)\n", strcmp(outPath, "-") ? outPath : "<stdout>", strlen(outPath) > 45 ? "\n\t" : " "); if (skip_start > 0) console_printf("skipping initial %i samples (encoder+decoder delay)\n", skip_start); if (skip_end > 0) console_printf("skipping final %i samples (encoder padding-decoder delay)\n", skip_end); switch (global_reader.input_format) { case sf_mp3: case sf_mp2: case sf_mp1: dp = decoder_progress_init(lame_get_num_samples(gfp), global_decoder.mp3input_data.framesize); break; case sf_raw: case sf_wave: case sf_aiff: default: dp = decoder_progress_init(lame_get_num_samples(gfp), lame_get_in_samplerate(gfp) < 32000 ? 576 : 1152); break; } } if (0 == global_decoder.disable_wav_header) WriteWaveHeader(outf, 0x7FFFFFFF, lame_get_in_samplerate(gfp), tmp_num_channels, 16); /* unknown size, so write maximum 32 bit signed value */ wavsize = 0; do { iread = get_audio16(gfp, Buffer); /* read in 'iread' samples */ if (iread >= 0) { wavsize += iread; if (dp != 0) { decoder_progress(dp, &global_decoder.mp3input_data, iread); } put_audio16(outf, Buffer, iread, tmp_num_channels); } } while (iread > 0); i = (16 / 8) * tmp_num_channels; assert(i > 0); if (wavsize <= 0) { if (global_ui_config.silent < 10) error_printf("WAVE file contains 0 PCM samples\n"); wavsize = 0; } else if (wavsize > 0xFFFFFFD0 / i) { if (global_ui_config.silent < 10) error_printf("Very huge WAVE file, can't set filesize accordingly\n"); wavsize = 0xFFFFFFD0; } else { wavsize *= i; } /* if outf is seekable, rewind and adjust length */ if (!global_decoder.disable_wav_header && strcmp("-", outPath) && !fseek(outf, 0l, SEEK_SET)) WriteWaveHeader(outf, (int) wavsize, lame_get_in_samplerate(gfp), tmp_num_channels, 16); fclose(outf); close_infile(); if (dp != 0) decoder_progress_finish(dp); return 0; }
//=========================================================== // Kosio implementations //=========================================================== int ICACHE_FLASH_ATTR ds18b20() { int r, i, tempLength=0; uint8_t addr[8], data[12]; ds_init(); r = ds_search(addr); if(r) { console_printf("Found Device @ %02x %02x %02x %02x %02x %02x %02x %02x\r\n", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]); if(crc8(addr, 7) != addr[7]) console_printf( "CRC mismatch, crc=%xd, addr[7]=%xd\r\n", crc8(addr, 7), addr[7]); switch(addr[0]) { case 0x10: console_printf("Device is DS18S20 family.\r\n"); break; case 0x28: console_printf("Device is DS18B20 family.\r\n"); break; default: console_printf("Device is unknown family.\r\n"); return 1; } } else { console_printf("No DS18B20 detected, sorry.\r\n"); return 1; } // perform the conversion reset(); select(addr); write(DS1820_CONVERT_T, 1); // perform temperature conversion sleepms(1000); // sleep 1s console_printf("Scratchpad: "); reset(); select(addr); write(DS1820_READ_SCRATCHPAD, 0); // read scratchpad for(i = 0; i < 9; i++) { data[i] = read(); console_printf("%2x ", data[i]); } console_printf("\r\n"); int HighByte, LowByte, TReading, SignBit, Tc_100, Whole, Fract; LowByte = data[0]; HighByte = data[1]; TReading = (HighByte << 8) + LowByte; SignBit = TReading & 0x8000; // test most sig bit if (SignBit) // negative TReading = (TReading ^ 0xffff) + 1; // 2's comp Whole = TReading >> 4; // separate off the whole and fractional portions Fract = (TReading & 0xf) * 100 / 16; //MQTT stuff here console_printf("DS18B20/Temperature: %c%d.%d Celsius\r\n", SignBit ? '-' : '+', Whole, Fract < 10 ? 0 : Fract); if(SignBit){ os_sprintf(DS18B20_Temperature, "%c%d.%d", SignBit ? '-' : '+', Whole, Fract < 10 ? 0 : Fract ); MQTT_Publish(&mqttClient,DS18B20_MQTT_Temperature,DS18B20_Temperature,5,0,0); } else { os_sprintf(DS18B20_Temperature, "%d.%d", Whole, Fract < 10 ? 0 : Fract ); MQTT_Publish(&mqttClient,DS18B20_MQTT_Temperature,DS18B20_Temperature,4,0,0); } // MANUAL MODE LOGICS HERE if (dDEVICE_MODE){ if (Whole>=dBR_BOILER_SET&&GPIO_INPUT_GET(PIN_GPIO14)) { GPIO_OUTPUT_SET(PIN_GPIO14,0); } } return r; }
static void ICACHE_FLASH_ATTR writeByByteTest() { time = system_get_time(); errors = 0; address = 0; console_printf("-----------------------------------------------\r\n"); console_printf("Write byte test:\r\n"); console_printf("Start address: %d, End address: %d\r\n", MIN_ADDRESS, MAX_ADDRESS); console_printf("Writing data: "); for (address = MIN_ADDRESS; address <= MAX_ADDRESS; address++) { wdata = address % loop_size; if(!eeprom_writeByte(DEVICEADDRESS, address, wdata)) console_printf("Failed write, address: %d, data: %d\r\n", address, (uint8_t)wdata); else { if (!(address % 500)) { //console_printf( "Address: %d, data: %d\r\n", address, (uint8_t)wdata); console_printf("..500.."); } } sleepms(3); } finishTime = system_get_time() - time; console_printf("DONE!\r\n"); console_printf("Total Time (seconds): %d\r\n", (uint32_t)(finishTime / 1000000)); console_printf("Write operations per second: %d\r\n", (uint32_t)(MAX_ADDRESS / (finishTime / 1000000))); console_printf("-----------------------------------------------\r\n"); console_printf("\r\n"); }
static int do_chipinfo(int argc, const char* argv[]) { console_printf("id=0x%x\n", system_get_chip_id()); }