int main(int argc, char *argv[]) { int i = 0; char *progname = argv[0]; if (argc < 2) { print_help(progname); exit(EXIT_FAILURE); } int maxSamples = atoi(argv[1]); // check for seed int initSeed = 0; if(argc >= 3) { initSeed = atoi(argv[2]); debug_print(1, "Initial seed of %i provided!\n", initSeed); } else { initSeed = 1000 + (time(NULL) % 9000); debug_print(1, "Using time(NULL) to obtain 4-digit seed\n", ""); } debug_print(1, "Going through %i samples of middle square\n", maxSamples); debug_print(1, "Using initial seed value: %i\n", initSeed); int x = initSeed; int newSeed; int *storageArray; storageArray = (int *) malloc(sizeof(int) * maxSamples); for( i = 0; i < maxSamples; i++) { // take previous seed or initial number newSeed = x * x; debug_print(2, "%i * %i = %i\n", x, x, newSeed); // select the middle four digits as output and next seed int oldSeed = newSeed; newSeed = (newSeed / 100) % 10000; debug_print(2, "(%i / 100) %% 10000 = %i\n", oldSeed, newSeed); // set the new seed as previous seed for next iteration x = newSeed; // store as output as well storageArray[i] = x; debug_print(1, "byte %i of %i: 0x%.2X (%i)\n", i+1, maxSamples, x, x); } for( i = 0; i < maxSamples; i++) { printf(BYTETOBINARYPATTERN, BYTETOBINARY(storageArray[i])); } free(storageArray); storageArray = NULL; exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int i = 0; unsigned long initSeed = 0; char *progname = argv[0]; if (argc < 2) { print_help(progname); exit(EXIT_FAILURE); } int maxSamples = atoi(argv[1]); struct timeval tv_init; struct timeval tv; gettimeofday(&tv_init, NULL); int numOfKeystrokes = 10; if (argc >= 3) { numOfKeystrokes = atoi(argv[2]); } debug_print(2, "UINT_MAX is %lu\n", (unsigned long) UINT_MAX); for (i = 0; i < numOfKeystrokes; ++i) { int tmp = getchar(); gettimeofday(&tv, NULL); debug_print(1, "Got char %i at usec %i\n", tmp, tv.tv_usec); initSeed = ((initSeed ^ tv.tv_usec) * tmp) % UINT_MAX; debug_print(1, "Seed currently %lu at round %i/10\n", initSeed, i+1); } debug_print(1, "Going through %i samples of C-based rand()\n", maxSamples); debug_print(1, "Using initial seed value: %lu\n", initSeed); lab2_srand((unsigned int) initSeed); int *storageArray; storageArray = (int *) malloc(sizeof(int) * maxSamples); for( i = 0; i < maxSamples; i++) { int x = lab2_rand(); debug_print(1, "byte %i of %i: 0x%.2X (%i)\n", i+1, maxSamples, x, x); storageArray[i] = x; } for( i = 0; i < maxSamples; i++) { printf(BYTETOBINARYPATTERN, BYTETOBINARY(storageArray[i])); } free(storageArray); storageArray = NULL; exit(EXIT_SUCCESS); }
__interrupt void ML13_interrupt(void) { char c = *interrupt_address & 0x3F; printf ("Leading text "BYTETOBINARYPATTERN, BYTETOBINARY(c)); puts("\t-Call from interrupt"); if(c & 0x08) { interruptType = SENSOR; }else if(c & 0x01) { interruptType = OPENED_DOOR; } //Clears interrupt register *interrupt_address = 0x01; }
int cmd_hub_knife(struct command_context *ctx) { char * args = command_args(ctx); unsigned int knife; unsigned int channel; unsigned int delay; unsigned int duration; nanohub_knivesdata_t knivesdata; printf("Input knife, channel, delay and duration\r\n"); if (sscanf(args, "%u %u %u %u", &knife,&channel,&delay,&duration) == 4) { if (!hub_knife((uint8_t) knife,(uint8_t) channel, (uint16_t) delay, (uint16_t) duration, &knivesdata)) { printf("Error do deploy\r\n"); return CMD_ERROR_FAIL; }; printf("Knivesdata:\r\n knife %d channel %d is set to deploy in %d with duration %d\r\n",knife, channel,delay,duration); } else { if (!hub_knife(99, 0, 0, 0, &knivesdata)) { printf("Error get deploy\r\n"); return CMD_ERROR_FAIL; } printf("Knivesdata:\r\n"); } printf("Knife0 timer: %"PRIu32" %"PRIu32"\r\n",knivesdata.knife[0].timer[0],knivesdata.knife[0].timer[1]); printf("Knife0 mode: %"PRIu8" %"PRIu8"\r\n",knivesdata.knife[0].mode[0],knivesdata.knife[0].mode[1]); printf("Knife0 burns: %"PRIu8" %"PRIu8"\r\n",knivesdata.knife[0].burns[0],knivesdata.knife[0].burns[1]); printf("Knife1 timer: %"PRIu32" %"PRIu32"\r\n",knivesdata.knife[1].timer[0],knivesdata.knife[1].timer[1]); printf("Knife1 mode: %"PRIu8" %"PRIu8"\r\n",knivesdata.knife[1].mode[0],knivesdata.knife[1].mode[1]); printf("Knife1 burns: %"PRIu8" %"PRIu8"\r\n",knivesdata.knife[1].burns[0],knivesdata.knife[1].burns[1]); printf("Burn status(%X): "BYTETOBINARYPATTERN"\r\n",knivesdata.burn_status, BYTETOBINARY(knivesdata.burn_status)); printf("Sense status: "BYTETOBINARYPATTERN"\r\n", BYTETOBINARY(knivesdata.sense_status)); return CMD_ERROR_NONE; }
int testread() { char *receive; int rec_size = llread(app.fd, &receive); //catch info //char endchar = receive[rec_size - 1]; //receive[rec_size - 1] = 0; printf("\n"); //printf("%s%c - %d", receive, endchar, rec_size);test string int i=0; for(;i<rec_size;++i) printf(PRINTBYTETOBINARY " - " , BYTETOBINARY(receive[i])); printf("%d",rec_size); //gets(receive); if (rec_size>0)free(receive); //catch DISC rec_size = llread(app.fd, &receive); if (rec_size == -2) printf("\ngot disk"); return 0; }
int main(int argc, char **argv){ set_opt(argc, argv); // prepare parameters init_arrays(); // init counters and flags prepare_flags(); // randomize flags int n; fprintf(stderr, "Begin calculation\n"); for (n = 0; n < count; n++){ uint16_t flag = flags[n]; /* in for loop calculation (very slow) (flag & 0x8000 ? counters[0]++ : 0); (flag & 0x4000 ? counters[1]++ : 0); (flag & 0x2000 ? counters[2]++ : 0); (flag & 0x1000 ? counters[3]++ : 0); (flag & 0x0800 ? counters[4]++ : 0); (flag & 0x0400 ? counters[5]++ : 0); (flag & 0x0200 ? counters[6]++ : 0); (flag & 0x0100 ? counters[7]++ : 0); (flag & 0x0080 ? counters[8]++ : 0); (flag & 0x0040 ? counters[9]++ : 0); (flag & 0x0020 ? counters[10]++ : 0); (flag & 0x0010 ? counters[11]++ : 0); (flag & 0x0008 ? counters[12]++ : 0); (flag & 0x0004 ? counters[13]++ : 0); (flag & 0x0002 ? counters[14]++ : 0); (flag & 0x0001 ? counters[15]++ : 0); */ /* simple shift (fast)*/ counters[0] += (flag & 0x8000) >> 15; counters[1] += (flag & 0x4000) >> 14; counters[2] += (flag & 0x2000) >> 13; counters[3] += (flag & 0x1000) >> 12; counters[4] += (flag & 0x0800) >> 11; counters[5] += (flag & 0x0400) >> 10; counters[6] += (flag & 0x0200) >> 9; counters[7] += (flag & 0x0100) >> 8; counters[8] += (flag & 0x0080) >> 7; counters[9] += (flag & 0x0040) >> 6; counters[10] += (flag & 0x0020) >> 5; counters[13] += (flag & 0x0010) >> 4; counters[11] += (flag & 0x0008) >> 3; counters[12] += (flag & 0x0004) >> 2; counters[14] += (flag & 0x0002) >> 1; counters[15] += (flag & 0x0001); /* shift in loops (slow) int k; int shift = 1; for (k = 0; k<16; k++){ counters[k] += (flag & (shift << (15-k))) >> (15-k) ; } */ DEBUG_TRACE(("DEBUG: FLAG[%d] = [%04X]\n", n, flag)); } fprintf(stderr, "End calculation\n"); #ifdef DEBUG int i; for (i = 0; i < 16; i++){ DEBUG_TRACE(("DEBUG: Counter[%d] = [%d]\n", i, counters[i])); } for (i = 0; i < count; i++){ DEBUG_TRACE(("DEBUG: FLAGS[%d] = (%04X)\t"BYTETOBINARYPATTERN"\n", i, flags[i], BYTETOBINARY(flags[i]))); } DEBUG_TRACE(("\n")); DEBUG_TRACE(("DEBUG: COUNT[1..16] =\t\t")); int j; for (j=0; j<16; j++){ ( j!=0 && j%4 == 0 ) ? DEBUG_TRACE((" %d", counters[j])) : DEBUG_TRACE(("%d", counters[j])); } DEBUG_TRACE(("\n\n")); #endif int c; for (c=0; c<16; c++){ printf("Counter(%02d) = %08d\n", c+1, counters[c]); } free(flags); exit(EXIT_SUCCESS); }
/* * Reads a UTF-8 codepoint. The string must be null terminated. */ static inline int read_utf8_codepoint(char *str, uint32_t *codepoint_out) { unsigned char byte; uint32_t codepoint; int bytes, i; byte = *str; if (byte & 0x80) {// UTF-8 multibyte // determine the number of bytes in the multibyte if ((byte & 0xE0) == 0xC0) { bytes = 2; codepoint = ((uint32_t)(byte & 31)) << 6; } else if ((byte & 0xF0) == 0xE0) { bytes = 3; codepoint = ((uint32_t)(byte & 15)) << 12; } else if ((byte & 0xF8) == 0xF0) { bytes = 4; codepoint = ((uint32_t)(byte & 7)) << 18; } else if ((byte & 0xFC) == 0xF8) { bytes = 5; codepoint = ((uint32_t)(byte & 3)) << 24; } else if ((byte & 0xFE) == 0xFC) { bytes = 6; codepoint = ((uint32_t)(byte & 1)) << 30; } else { // bad byte! if ((byte & 0xC0) == 0x80) { fprintf(stderr, "The bit pattern 10xxxxxx is illegal for the first " "byte of a UTF-8 multibyte.\n"); } else if (byte == 0xFE) { fprintf(stderr, "The byte 0xFE is illegal for UTF-8.\n"); } else { fprintf(stderr, "The byte 0xFF is illegal for UTF-8.\n"); } exit(1); // stop compiler complaints bytes = 1; codepoint = 0; } // read the rest of the bytes for (i = 1; i < bytes; i++) { if (str[i] == '\0') { return i - bytes; } byte = str[i]; if ((byte & 0xC0) != 0x80) { fprintf(stderr, "Expected the bit pattern 10xxxxxx for a following " "byte of a UTF-8 multibyte.\n"); exit(1); } codepoint = codepoint | (((uint32_t)(byte & 0x3F)) << (6 * (bytes - i - 1))); } // check for overlong representations by seeing if we could have represented // the number with one less byte if (bytes > 1 && codepoint < (1 << (bytes == 2 ? 7 : (6 * (bytes - 2) + (8 - bytes))))) { fprintf(stderr, "The UTF-8 multibyte uses too many bytes (%d) for the " "codepoint (%zu) it represents.\n", bytes, codepoint); for (i = 0; i < bytes; i++) { fprintf(stderr, BYTETOBINARYPATTERN " ", BYTETOBINARY((unsigned char)str[i])); } fputs("\n", stderr); exit(1); } } else { // ASCII byte bytes = 1; codepoint = byte; } *codepoint_out = codepoint; return bytes; }
/******************************************************************* * Function: void map (void) * Input Variables: none * Output Return: none * Overview: Makes the robot map the world ********************************************************************/ void map (void) { // Initialize State isMapping = 1; // Mapping Loop while(isMapping) { //Sense checkIR(); checkWorld(); //Record setGateways(); //Plan using the Map planMap(); //Act on the Map moveMap(); //Shift the Map currentCellWorld = shiftMap(currentCellWorld, currentMove, currentOrientation); //Break? isMapping = !((currentCellWorldStart == currentCellWorld)&&(currentOrientationStart == currentOrientation)); if(!isMapping){ break; } //Print Map LCD_clear(); LCD_printf(" Move"BYTETOBINARYPATTERN"\n Cell"BYTETOBINARYPATTERN"\n Ornt"BYTETOBINARYPATTERN"\n\n",BYTETOBINARY(currentMove),BYTETOBINARY(currentCellWorld),BYTETOBINARY(currentOrientation)); printMap(currentOrientation,currentCellWorld,RESET); TMRSRVC_delay(500);//wait 3 seconds } }
/******************************************************************* * Function: char getGateways(void) * Input Variables: void * Output Return: void * Overview: Interpolates the list of gateways in the path by using the map and initial conditions ********************************************************************/ void getGateways(void) { // Get the start location of the robot // unsigned char curRow = (currentCellWorld>>2) & 0b1100; // unsigned char curCol = currentCellWorld & 0b0011; unsigned char curRow = currentCellWorld >> 2; unsigned char curCol = currentCellWorld & 0b0011; // Git the start orientation of the robot unsigned char curOrient = currentOrientation; // This will be the gatway the robot will look for unsigned char curCell; // This will be the move the robot will preform unsigned char curMove; // This is the index of the move we are looking at unsigned char j; for (j = 0; j<=MAX_MOVE_SIZE; j++) { // Get the current move curMove = moveCommands[j]; // Get the current cell curCell = ROBOT_WORLD[curRow][curCol]; // Rotate the cell with reference to the robot curCell = rotateCell(curCell,curOrient,1); // Store the cell as a searchable gateway moveGateways[j] = curCell; // If we are moving forward // move to the next cell with respect to our orientation if (curMove == MOVE_FORWARD){ switch(curOrient){ case NORTH: curRow -= 1; break; case EAST: curCol += 1; break; case SOUTH: curRow += 1; break; case WEST: curCol -= 1; break; default: break; } } // If we are turning right // then rotate our map orientation appropriately else if (curMove == MOVE_RIGHT){ curOrient++; curOrient = curOrient&0b11; // LCD_clear(); // LCD_printf("Num:\n%i\curOrient:\n"BYTETOBINARYPATTERN,j,BYTETOBINARY(curOrient)); // TMRSRVC_delay(500);//wait 1/2 seconds } // If we are turning left // then rotate our map orientation appropriately else if (curMove == MOVE_LEFT){ // if(curOrient == 0){ // curOrient = 0b0011; // } curOrient--; curOrient = curOrient&0b11; } } for (j = 0; j<=MAX_MOVE_SIZE; j++) { curCell = moveGateways[j]; LCD_clear(); LCD_printf("Num:\n%i\nCurCell:\n"BYTETOBINARYPATTERN,j,BYTETOBINARY(curCell)); TMRSRVC_delay(1000);//wait 1 second } }
static void pmic_dump_registers(int dump_mask) { int i, retval = 0, ret; uint8_t reg_val; uint16_t chk_reg_addr; uint16_t reg_addr_boot[] = {MSIC_BATT_RESETIRQ1_ADDR, MSIC_BATT_RESETIRQ2_ADDR, MSIC_BATT_CHR_LOWBATTDET_ADDR, MSIC_BATT_CHR_SPCHARGER_ADDR, MSIC_BATT_CHR_CHRTTIME_ADDR, MSIC_BATT_CHR_CHRCTRL1_ADDR, MSIC_BATT_CHR_CHRSTWDT_ADDR, MSIC_BATT_CHR_CHRSAFELMT_ADDR}; char *reg_str_boot[] = {"rirq1", "rirq2", "lowdet", "spchr", "chrtime", "chrctrl1", "chrgwdt", "safelmt"}; uint16_t reg_addr_int[] = {MSIC_BATT_CHR_PWRSRCINT_ADDR, MSIC_BATT_CHR_PWRSRCINT1_ADDR, MSIC_BATT_CHR_CHRINT_ADDR, MSIC_BATT_CHR_CHRINT1_ADDR, MSIC_BATT_CHR_PWRSRCLMT_ADDR}; char *reg_str_int[] = {"pwrint", "pwrint1", "chrint", "chrint1", "pwrsrclmt"}; uint16_t reg_addr_evt[] = {MSIC_BATT_CHR_CHRCTRL_ADDR, MSIC_BATT_CHR_CHRCVOLTAGE_ADDR, MSIC_BATT_CHR_CHRCCURRENT_ADDR, MSIC_BATT_CHR_SPWRSRCINT_ADDR, MSIC_BATT_CHR_SPWRSRCINT1_ADDR, CHR_STATUS_FAULT_REG}; char *reg_str_evt[] = {"chrctrl", "chrcv", "chrcc", "spwrsrcint", "sprwsrcint1", "chrflt"}; uint16_t reg_addr_others[] = {MSIC_BATT_CHR_MPWRSRCINT_ADDR, MSIC_BATT_CHR_MPWRSRCINT1_ADDR, MSIC_BATT_CHR_MCHRINT_ADDR, MSIC_BATT_CHR_MCHRINT1_ADDR, MSIC_BATT_CHR_VBUSDET_ADDR, MSIC_BATT_CHR_WDTWRITE_ADDR}; char *reg_str_others[] = {"chrmpwrsrcint", "chrmpwrsrcint1", "chrmchrint", "chrmchrint1", "chrvbusdet", "chrwdtwrite"}; if (dump_mask & MSIC_CHRG_REG_DUMP_BOOT) { for (i = 0; i < ARRAY_SIZE(reg_addr_boot); i++) { retval = intel_scu_ipc_ioread8(reg_addr_boot[i], ®_val); if (retval) { chk_reg_addr = reg_addr_boot[i]; goto ipcread_err; } BAT_DBG("PMIC(0x%03x)\tval: " BYTETOBINARYPATTERN "\t%s\n", reg_addr_boot[i], BYTETOBINARY(reg_val), reg_str_boot[i]); } } if (dump_mask & MSIC_CHRG_REG_DUMP_INT) { for (i = 0; i < ARRAY_SIZE(reg_addr_int); i++) { retval = intel_scu_ipc_ioread8(reg_addr_int[i], ®_val); if (retval) { chk_reg_addr = reg_addr_int[i]; goto ipcread_err; } BAT_DBG("PMIC(0x%03x)\tval: " BYTETOBINARYPATTERN "\t%s\n", reg_addr_int[i], BYTETOBINARY(reg_val), reg_str_int[i]); } } if (dump_mask & MSIC_CHRG_REG_DUMP_EVENT) { for (i = 0; i < ARRAY_SIZE(reg_addr_evt); i++) { retval = intel_scu_ipc_ioread8(reg_addr_evt[i], ®_val); if (retval) { chk_reg_addr = reg_addr_evt[i]; goto ipcread_err; } BAT_DBG("PMIC(0x%03x)\tval: " BYTETOBINARYPATTERN "\t%s\n", reg_addr_evt[i], BYTETOBINARY(reg_val), reg_str_evt[i]); } } if (dump_mask & MSIC_CHRG_REG_DUMP_OTHERS) { for (i = 0; i < ARRAY_SIZE(reg_addr_others); i++) { retval = intel_scu_ipc_ioread8(reg_addr_others[i], ®_val); if (retval) { chk_reg_addr = reg_addr_others[i]; goto ipcread_err; } BAT_DBG("PMIC(0x%03x)\t val: " BYTETOBINARYPATTERN "\t%s\n", reg_addr_others[i], BYTETOBINARY(reg_val), reg_str_others[i]); } } /*modify MSIC_BATT_CHR_LOWBATTDET_ADDR values [7:6]='11'*/ intel_scu_ipc_ioread8(MSIC_BATT_CHR_LOWBATTDET_ADDR, ®_val); reg_val |= (BIT(6)|BIT(7)); ret = intel_scu_ipc_iowrite8(MSIC_BATT_CHR_LOWBATTDET_ADDR, reg_val); if (ret) { BAT_DBG_E("PMIC register MSIC_BATT_CHR_LOWBATTDET_ADDR Failed to write %d\n", ret); }else { intel_scu_ipc_ioread8(MSIC_BATT_CHR_LOWBATTDET_ADDR, ®_val); BAT_DBG("PMIC register 0x%x Success to write 0x%x.\n", MSIC_BATT_CHR_LOWBATTDET_ADDR, reg_val); } return; ipcread_err: BAT_DBG("ipcread_err: address: 0x%03x!!!", chk_reg_addr); }
int main(void) { // C MUST BE PRIME to ensure that it is co-prime with other values const BYTE C = 0x07; // D MUST be assigned the same value as Y BYTE D = 0x00; // Variable for the X, Y, etc. values calculated by the recipient BYTE calculated_X = 0x00; BYTE calculated_Y = 0x00; BYTE calculated_Q = 0x00; BYTE calculated_R = 0x00; BYTE calculated_Z = 0x00; BYTE calculated_Zprime = 0x00; bool root_found = false; BYTE Q = 0x00; BYTE R = 0x00; BYTE Z1 = 0x00; BYTE Z2 = 0x00; BYTE sender_Z1prime = 0x00; BYTE sender_Z2prime = 0x00; BYTE recipient_Zprime = 0x00; // Iterate through every possible combination of the X and Y byte values to verify // that it is possible to recover X and Y from Z given ANY combinations of values for (BYTE X = 0x00; X < 0x10; ++X) { // For each value of X iterate for each value of Y incremented by 0x01 for (BYTE Y = 0x00; Y < 0x10; ++Y) { /** * Simulate the sender compressing the 2 bytes into a single byte, Z and * then sending Z to the recipient */ D = Y; // D MUST be same value as Y, D is not known to recipient Q = calcQ(&X, &Y, &C); R = calcR(&X, &Y, &D); // Calculate Z using both equivalent methods, Z = R XOR C = Q XOR D Z1 = calcZ(&R, &C); Z2 = calcZ(&Q, &D); // Calcualte Z' using both equivalent methods, Z' = R XNOR C = Q XNOR D sender_Z1prime = calcZprime(&R, &C); sender_Z2prime = calcZprime(&Q, &D); // Verify that Z using both methods is equivalent (This is an AXIOM OF THE // COMPRESSION ALGORITHM) so if it's wrong we have a major flaw if (Z1 != Z2) { printf("Z1 NOT EQUIVALENT TO Z2!\n"); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("Z1:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z1)), 0xF0 ^ Z1); printf("Z2:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z2)), 0xF0 ^ Z2); } // Verify that Z' using both methods is equivalent (This is an AXIOM OF THE // COMPRESSION ALGORITHM) so if it's wrong we have a major flaw if (sender_Z1prime != sender_Z2prime) { printf("Z1 PRIME NOT EQUIVALENT TO Z2 PRIME!\n"); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("Z1 PRIME:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ sender_Z1prime)), 0xF0 ^ sender_Z1prime); printf("Z2 PRIME:\t\t"BYTETOBINARYPATTERN", %d\n\n", BYTETOBINARY((0xF0 ^ sender_Z2prime)), 0xF0 ^ sender_Z2prime); } /** * Simulate the recipient receiving a single byte, Z and getting the original * bytes X and Y from Z, the recipient knows the constant value C, which is prime */ // The user can get Z' which is ~Z, this is the UNIQUE property that makes it // possible to recover X and Y by using the equations of for Z and Z' given the // two values Z and Z' = ~Z recipient_Zprime = ~(Z1); // Verify that the Zprime the recipient gets from ~Z is ACTUALLY, the same Zprime // that the sender calculated using the equations (This is an AXIOM OF THE // COMPRESSION ALGORITHM), so if it's wrong we have a major flaw if (recipient_Zprime != sender_Z1prime) { printf("RECIPIENT'S Z PRIME NOT EQUIVALENT TO SENDER'S Z PRIME!!!\n"); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("Q:\t\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("R:\t\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("SENDER Z PRIME:\t\t"BYTETOBINARYPATTERN", %d\n\n", BYTETOBINARY(sender_Z1prime), sender_Z1prime); printf("RECIPIENT Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(recipient_Zprime), recipient_Zprime); } // Now the user can calculate X very easily given a unique property when C is prime and D == Y // The user has RECEIVED Z and BOTH recipient and sender KNOW C, UNKNOWN is Y == D calculated_X = calcX(&Z1, &C); // Verify that the CALCULATED X IS ACTUALLY EQUAL to the Sender's X value the recipients' // calculated X should ALWAYS be equivalent to the sender's X when Y == D (This is an AXIOM OF THE // COMPRESSION ALGORITHM), so if it's wrong we have a major flaw if (calculated_X != X) { printf("RECIPIENT'S CALCULATED X NOT EQUIVALENT TO SENDER'S X!!!\n"); printf("Q:\t\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("R:\t\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("RECIPIENT X:\t"BYTETOBINARYPATTERN"\t\t: %d\n\n", BYTETOBINARY(calculated_X), calculated_X); } /** calculated_Y = 0x00; calculated_Q = 0x00; calculated_R = 0x00; calculated_Z = 0x00; calculated_Zprime = 0x00; root_found = false; calculated_Q = calcQ(&calculated_X, &Y, &C); calculated_R = calcR(&calculated_X, &Y, &Y); calculated_Z = calcZ(&calculated_R, &C); calculated_Zprime = calcZprime(&calculated_Q, &Y); calculated_Y = calcY(&calculated_Zprime, &calculated_Q); printf("SENDER Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("CALCULATED Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Q)), 0xF0 ^ calculated_Q); printf("SENDER R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("CALCULATED R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_R)), 0xF0 ^ calculated_R); printf("SENDER Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z1)), 0xF0 ^ Z1); printf("CALCULATED Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Z)), 0xF0 ^ calculated_Z); printf("SENDER Z PRIME:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(sender_Z1prime), sender_Z1prime); printf("RECIPIENT Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(recipient_Zprime), recipient_Zprime); printf("CALCULATED Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(calculated_Zprime), calculated_Zprime); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("RECIPIENT X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n\n\n", BYTETOBINARY(calculated_X), BYTETOBINARY(calculated_Y), calculated_X, calculated_Y); */ // Now solve for the unknown value Y, given the Z' value, X, and C, the only way to feasibly solve // for Y is to perform a bruteforce search given the known values and the equations for // Z' and Q. THERE MUST ONLY BE ONE ROOT, Y, GIVEN THE ROOT X , Z' and C (This is an AXIOM OF THE // COMPRESSION ALGORITHM), so if it's wrong we have a major flaw, in fact its IMPOSSIBLE to // reverse the compression unless Y == D is UNIQUE!!!! for (BYTE Y_TEST = 0x00; Y_TEST < 0x10; ++Y_TEST) { calculated_Q = calcQ(&calculated_X, &Y_TEST, &C); calculated_R = calcR(&calculated_X, &Y_TEST, &Y_TEST); calculated_Z = calcZ(&calculated_R, &C); calculated_Zprime = calcZprime(&calculated_Q, &Y_TEST); //printf("Calculated X: %d\n", calculated_X); //printf("Calculated Y: %d\n", Y_TEST); //printf("Calculated Q: %d\n", 0xF0 ^ calculated_Q); //printf("Calculated R: %d\n", 0xF0 ^ calculated_R); //printf("Calculated Z: %d\n", 0xF0 ^ calculated_Z); //printf("Calculated Z PRIME: %d\n\n", calculated_Zprime); /** printf("SENDER Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("CALCULATED Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Q)), 0xF0 ^ calculated_Q); printf("SENDER R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("CALCULATED R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_R)), 0xF0 ^ calculated_R); printf("SENDER Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z1)), 0xF0 ^ Z1); printf("CALCULATED Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Z)), 0xF0 ^ calculated_Z); printf("SENDER Z PRIME:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(sender_Z1prime), sender_Z1prime); printf("RECIPIENT Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(recipient_Zprime), recipient_Zprime); printf("CALCULATED Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(calculated_Zprime), calculated_Zprime); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("RECIPIENT X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n\n\n", BYTETOBINARY(calculated_X), BYTETOBINARY(Y_TEST), calculated_X, Y_TEST); */ // If the calculated Z' given the calculated root Y matches the known Z' which is // Z' = ~Z, then the root Y satisfies the equations and IS THE ROOT. Remember that // for the sender as well as the recipient Y == D, this is the unique property that // makes it possible to avoid the 0000/1111 cancellations of XOR if (calculated_X == calcX(&calculated_Z, &C)) { if (Y_TEST == calcY(&calculated_Zprime, &calculated_Q)) { if (Z1 == calculated_Z && recipient_Zprime == calculated_Zprime) { // X XOR Y SHOULD NOT BE EQUIVALENT TO Z, ONLY THE UNIQUE ROOT IS NOT A COMBINATION // OF X XOR Y = Z //if (Y_TEST == Y) if ((calculated_X ^ Y_TEST) != calculated_Z) { calculated_Y = Y_TEST; root_found = true; break; } } } } } // If the correct root is found I will be DELIGHTED, the calculated Y MUST // be UNIQUE and equivalent to the initial Y value of the sender, if it does // not match we have a major flaw, if (calculated_Y == Y) { printf("RECIPIENT'S CALCULATED Y EQUIVALENT TO SENDER'S Y!!!!!!!!!!!!!!!!!!!!\n"); printf("SENDER Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("CALCULATED Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Q)), 0xF0 ^ calculated_Q); printf("SENDER R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("CALCULATED R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_R)), 0xF0 ^ calculated_R); printf("SENDER Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z1)), 0xF0 ^ Z1); printf("CALCULATED Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Z)), 0xF0 ^ calculated_Z); printf("SENDER Z PRIME:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(sender_Z1prime), sender_Z1prime); printf("RECIPIENT Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(recipient_Zprime), recipient_Zprime); printf("CALCULATED Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(calculated_Zprime), calculated_Zprime); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("RECIPIENT X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n\n", BYTETOBINARY(calculated_X), BYTETOBINARY(calculated_Y), calculated_X, calculated_Y); } // major flaw, back to the drawing board! else { printf("RECIPIENT'S CALCULATED Y NOT EQUIVALENT TO SENDER'S Y!!!!!!!!!!!!!!!!!!!!\n"); printf("SENDER Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("CALCULATED Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Q)), 0xF0 ^ calculated_Q); printf("SENDER R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("CALCULATED R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_R)), 0xF0 ^ calculated_R); printf("SENDER Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z1)), 0xF0 ^ Z1); printf("CALCULATED Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ calculated_Z)), 0xF0 ^ calculated_Z); printf("SENDER Z PRIME:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(sender_Z1prime), sender_Z1prime); printf("RECIPIENT Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(recipient_Zprime), recipient_Zprime); printf("CALCULATED Z PRIME:\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(calculated_Zprime), calculated_Zprime); printf("SENDER X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("RECIPIENT X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n\n", BYTETOBINARY(calculated_X), BYTETOBINARY(calculated_Y), calculated_X, calculated_Y); } } /** Zprime = calcZprime(&Q, &D); calculated_Y = calcY(&Zprime, &Q); if ( X == calculated_X && Y == calculated_Y) { printf("Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Q)), 0xF0 ^ Q); printf("R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ R)), 0xF0 ^ R); printf("Z1:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z1)), 0xF0 ^ Z1); printf("Z2:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY((0xF0 ^ Z2)), 0xF0 ^ Z2); ); //printf("Z':\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(Zprime), Zprime); printf("Q:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(Q), Q); printf("R:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(R), R); printf("Z:\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(Z), Z); printf("Z':\t\t"BYTETOBINARYPATTERN", %d\n", BYTETOBINARY(Zprime), Zprime); printf("INITIAL X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n", BYTETOBINARY(X), BYTETOBINARY(Y), X, Y); printf("SOLVED X, Y:\t"BYTETOBINARYPATTERN", "BYTETOBINARYPATTERN"\t: %d, %d\n\n", BYTETOBINARY(calculated_X), BYTETOBINARY(calculated_Y), calculated_X, calculated_Y); }*/ } return 0; }
int main(){ int fd = spi_open("/dev/spidev0.0"); spi_mode(fd, SPI_MODE_1); // spi_mode(fd, SPI_NO_CS | SPI_MODE_2); spi_speed(fd, MHZ_32); dumpstat("SPI device 0: ",fd); // uint16_t command = MCP3208_START_BIT | MCP3208_SINGLE_ENDED printf("size %d\n", sizeof(MCP_CHAN_7)); // uint32_t foo = MCP_CHAN_7; // uint32_t mcp_tx = ((uint32_t)MCP_CHAN_7) << 14; // uint32_t mcp_rx = 0; uint8_t tx[] = {1,8 + 0 << 4,0,0}; uint8_t rx[4] = {0}; struct spi_ioc_transfer mcp_tr ={ .tx_buf = (unsigned long)&tx, .rx_buf = (unsigned long)&rx, .len = 4, .delay_usecs = 0, .speed_hz = KHZ_500, .bits_per_word = 8, }; while(1){ spi_transfer(fd, &mcp_tr, 1); // printf ("B "BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_tx >> 24)); // printf (""BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_tx >> 16)); // printf (""BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_tx >> 8)); // printf (""BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_tx)); // printf("\tbuf_tx: %u\n", mcp_tx); // mcp_rx |= 0xff000000; // mcp_rx &= 0x00ffffff; // mcp_rx = mcp_rx >> 0; uint32_t ret = 0; ret |= (uint32_t)rx[3]; ret |= (uint32_t)rx[2] << 8; ret |= (uint32_t)rx[1] << 16; // ret |= (uint32_t)rx[0] << 24; print_byte(rx[0]); print_byte(rx[1]); print_byte(rx[2]); print_byte(rx[3]); printf(" rx %d", ret >> 6); printf("\n"); // printf("%d\n", rx); // printf ("\nA "BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_rx >> 24)); // printf (""BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_rx >> 16)); // printf (""BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_rx >> 8)); // printf (""BYTETOBINARYPATTERN" ", BYTETOBINARY(mcp_rx)); // printf("\tbuf_rx: %u\n", mcp_rx); nanosleep(&requested,&remaining); } // uint16_t command = get_mcp_channel_command(0); // printf ("Byte 00 "BYTETOBINARYPATTERN"\n", BYTETOBINARY((uint8_t)command)); // printf ("Byte 01 "BYTETOBINARYPATTERN"\n", BYTETOBINARY((uint8_t)command >> 8)); // printf ("Byte 00 "BYTETOBINARYPATTERN"\n", BYTETOBINARY((uint8_t)0x8)); // printf ("Byte 01 "BYTETOBINARYPATTERN"\n", BYTETOBINARY((uint8_t)0x10)); // printf("command %d %s\n", command, &buf); // dumpstat("SPI device 0: ",fd); spi_close(fd); } static void print_byte(uint8_t byte){ printf (""BYTETOBINARYPATTERN" ", BYTETOBINARY(byte)); }