/**
* UnPack RTP bitstream containing SID frame as unpacked ITU stream
* @param bitstream RTP bitstream to unpack
* @param bits ITU bitstream used as destination (0 - BIT_0, 1 - BIT_1)
*/
static void unpack_SID(const uint8_t bitstream[], int16_t bits[])
{
*bits++ = SYNC_WORD;
*bits++ = RATE_SID_OCTET;
int2bin((int16_t)bitstream[0], 8, &bits[0]);
int2bin((int16_t)bitstream[1], 8, &bits[8]);
}
/*----------------------------------------------------------------------------
* prm2bits_ld8k -converts encoder parameter vector into vector of serial bits
* bits2prm_ld8k - converts serial received bits to encoder parameter vector
*
* The transmitted parameters are:
*
* LPC: 1st codebook 7+1 bit
* 2nd codebook 5+5 bit
*
* 1st subframe:
* pitch period 8 bit
* parity check on 1st period 1 bit
* codebook index1 (positions) 13 bit
* codebook index2 (signs) 4 bit
* pitch and codebook gains 4+3 bit
*
* 2nd subframe:
* pitch period (relative) 5 bit
* codebook index1 (positions) 13 bit
* codebook index2 (signs) 4 bit
* pitch and codebook gains 4+3 bit
*----------------------------------------------------------------------------
*/
void prm2bits_ld8k(
Word16 prm[], /* input : encoded parameters (PRM_SIZE parameters) */
Word16 bits[] /* output: serial bits (SERIAL_SIZE ) bits[0] = bfi
bits[1] = 80 */
)
{
Word16 i;
*bits++ = SYNC_WORD; /* bit[0], at receiver this bits indicates BFI */
switch(prm[0]){
/* not transmitted */
case 0 : {
*bits = RATE_0;
break;
}
case 1 : {
*bits++ = RATE_8000;
for (i = 0; i < PRM_SIZE; i++) {
int2bin(prm[i+1], bitsno[i], bits);
bits += bitsno[i];
}
break;
}
case 2 : {
#ifndef OCTET_TX_MODE
*bits++ = RATE_SID;
for (i = 0; i < 4; i++) {
int2bin(prm[i+1], bitsno2[i], bits);
bits += bitsno2[i];
}
#else
*bits++ = RATE_SID_OCTET;
for (i = 0; i < 4; i++) {
int2bin(prm[i+1], bitsno2[i], bits);
bits += bitsno2[i];
}
*bits++ = 0; //BIT_0;
#endif
break;
}
default : {
printf("Unrecognized frame type\n");
exit(-1);
}
}
return;
}
int main(int argc, char* argv[])
{
int i;
for(i = 8; i <= 20; i++)
printf("Decimal : %02d, Binary : %s, Hexadecimal : %02X\n", i, int2bin(i), i);
return 0;
}
int cmd_add_cid(proc_add_cid_t rec) {
uint16_t addr=rec.token.addr;
if( addr < GP_START_TICKET_BOUND ) {
addr=devices[rec.dev].bound_token;
}
uint64_t cid2=db_get_cid_by_a(addr);
if ( cid2 != 0 && cid2 != rec.token.cid ) {
zprintf(3, "Conflict in db was: 0x%016llX, new: 0x%016llX for addr: 0x%04x\n", cid2, rec.token.cid, addr);
return 0;
}
gp_token_rec_t t2;
memset(&t2, 0, sizeof(gp_token_rec_t));
int2bin(t2.cid, rec.token.cid, 6, devices[rec.dev].cid_revert);
t2.attr=rec.token.attr;
t2.schedule_mask=rec.token.schedule_mask;
// t2.attr=0; t2.schedule_mask=0xFF; t2.schedule_mask=1;
zprintf(7,"Writing cid: 0x%012llX, dev=%d, addr=0x%04X, mask=0x%02X\n",
rec.token.cid, rec.dev, addr, rec.token.schedule_mask);
ad_set_token(AD_Q_SECOND, rec.dev, addr, &t2, 1);
if( addr >= devices[rec.dev].bound_token ) {
devices[rec.dev].bound_token = addr + sizeof(gp_token_rec_t);
gp_cfg.max_bound_token=MAX(gp_cfg.max_bound_token,devices[rec.dev].bound_token);
ad_set_token_bound(AD_Q_SECOND, rec.dev, devices[rec.dev].bound_token);
}
return 1;
}
void makelut(unsigned int bits, unsigned int div)
{
assert(bits < 32);
// header
std::cout << " type rom" << div << "_t is array(0 to 2**lut_bits/" << div
<< "-1)" << std::endl
<< " of std_logic_vector(lut_bits-1 downto 0);" << std::endl
<< " constant rom" << div << " : rom" << div << "_t :=("
<< std::endl;
// length of the LUT
unsigned int length = powui(2u, bits)/div;
// maximum value of a signed integer of length bits.
unsigned int max = powui(2u, bits-1)-1;
// cake
long double pi = std::acos(-1.l);
// construct LUT
for(unsigned int c = 0; c < length; c++)
{
long double x = static_cast<long double>(c)/static_cast<long double>(length)*2.l*pi
/static_cast<float>(div);
unsigned int y = static_cast<unsigned int>(cos(x)*max);
if(c % 4 == 0) std::cout << " ";
std::cout << "\"" << int2bin(y, bits) << "\"";
if(c < length-1) std::cout << ", ";
if((c + 1) % 4 == 0) std::cout << std::endl;
}
std::cout << " );" << std::endl;
}
int main()
{
int dec;
char* bin;
int cnt=0,cnt2=0;
printf("Enter a decimal integer: ");
scanf("%d",&dec);
bin = int2bin(dec);
printf("\n\nThe binary equivalent is: ");
for (cnt=0; cnt<=31; cnt++)
{
//find the first index where a '1' can be found
if (bin[cnt]=='1')
{
for (cnt2 = cnt; cnt2 < 32; cnt2++)
{
printf("%c",bin[cnt2]);
}
cnt=31;
}
}
getchar();
return (0);
}
void asl(){
ALUOut = aluA << 1; // execução
alu_flags.zero = ALUOut == 0 ? TRUE : FALSE;
alu_flags.neg = ALUOut < 0 ? TRUE : FALSE;
alu_flags.negzero = alu_flags.zero || alu_flags.neg;
alu_flags.overflow = aluB > 0 ? (32767 - aluB) < aluA : (-32768 - aluB) > aluA;
alu_flags.carry = int2bin(aluA)[15];
}
void create_data(FILE *bitfile, FILE *outfile, int a, int dw)
{
int i,j,c,ca;
char buf[1024], x[32];
ca = pw(a);
for(j=0;j<=ca;j++){
int2bin(a,j,x);
for(i=0; i<dw/8; i++)
if((c=fgetc(bitfile))!=EOF)
int2bin(8,c,buf+i*8);
else
int2bin(8,0,buf+i*8);
buf[dw]=0; x[a] = 0;
fprintf(outfile," when \"%s\" => d <= \"%s\";\n",x,buf);
if (feof(bitfile)) break;
}
// fseek(outfile,-6,SEEK_CUR);
}
int main() {
char buffer[BUF_SIZE];
buffer[BUF_SIZE - 1] = '\0';
int a = -8;
unsigned u = -8;
int2bin(a, buffer, BUF_SIZE - 1);
printf("a = %s", buffer);
printf("\n");
int2bin(u, buffer, BUF_SIZE -1 );
printf("u = %s", buffer);
printf("\n");
}
//====================================
void registerLog()
//====================================
{
if(g_boardType==UNO)
{
setPINRegister(g_curStep);
fprintf(r_log,"# %d,DDRB=%s,DDRC=%s,DDRD=%s,",g_curStep,int2bin(DDRB,8),int2bin(DDRC,8),int2bin(DDRD,8));
fprintf(r_log,"PORTB=%s,PORTC=%s,PORTD=%s,",int2bin(PORTB,8),int2bin(PORTC,8),int2bin(PORTD,8));
fprintf(r_log,"PINB=%s,PINC=%s,PIND=%s\n",int2bin(PINB,8),int2bin(PINC,8),int2bin(PIND,8));
fprintf(r_log,"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",g_curStep,DDRB,DDRC,DDRD,PORTB,PORTC,PORTD,PINB,PINC,PIND);
}
}
int main( void )
{
init();
int sec=0;
int min=0;
int hour=0;
for (;;){
char binsec[6];
char binmin[6];
char binhou[6];
int i=0;
int2bin(sec,binsec);
int2bin(min,binmin);
int2bin(hour,binhou);
sendData(binsec,binmin,binhou);
for(i=0;i<9;i++){
min=checkMButton(min);
hour=checkHButton(hour);
_delay_ms(100);
}
sec++;
if(sec>59){
sec=0;
min++;
}
if(min>59){
min=0;
hour++;
}
if(hour>23){
hour=0;
}
}
}
int CFanmotorDlg::dataread_anybits(int addr,int ind,int length)
{
int datr,datr_section;
CString datstring,dat_section;
datr = rreg(addr);
if (!success){goto end;};
datstring = int2bin(datr);
for(int i=0;i<length;i++){
dat_section += datstring[ind + i];
}
datr_section = bin2intwl(dat_section,length);
return datr_section;
end:;
}
/*----------------------------------------------------------------------------
* prm2bits_ld8k -converts encoder parameter vector into vector of serial bits
* bits2prm_ld8k - converts serial received bits to encoder parameter vector
*
* The transmitted parameters are:
*
* LPC: 1st codebook 7+1 bit
* 2nd codebook 5+5 bit
*
* 1st subframe:
* pitch period 8 bit
* parity check on 1st period 1 bit
* codebook index1 (positions) 13 bit
* codebook index2 (signs) 4 bit
* pitch and codebook gains 4+3 bit
*
* 2nd subframe:
* pitch period (relative) 5 bit
* codebook index1 (positions) 13 bit
* codebook index2 (signs) 4 bit
* pitch and codebook gains 4+3 bit
*----------------------------------------------------------------------------
*/
void prm2bits_ld8k(
Word16 prm[], /* input : encoded parameters (PRM_SIZE parameters) */
Word16 bits[] /* output: serial bits (SERIAL_SIZE ) bits[0] = bfi
bits[1] = 80 */
)
{
Word16 i;
*bits++ = SYNC_WORD; /* bit[0], at receiver this bits indicates BFI */
*bits++ = SIZE_WORD; /* bit[1], to be compatible with hardware */
for (i = 0; i < PRM_SIZE; i++)
{
int2bin(prm[i], bitsno[i], bits);
bits += bitsno[i];
}
return;
}
void CFanmotorDlg::dataupdate_anybits(int addr, int ind, CString datbits,int length)
{
int temp,datupdated;
CString datbintemp;
temp = rreg(addr);
if (!success){goto end;};
datbintemp = int2bin(temp);
for(int i = 0;i<length;i++){
datbintemp.SetAt(ind+i,datbits[i]);
}
datupdated = bin2int(datbintemp);
wreg(addr,datupdated);
if (!success){goto end;};
end:;
}
/**
* UnPack RTP bitstream as unpacked ITU stream
* @param bitstream RTP bitstream to unpack
* @param bits ITU bitstream used as destination (0 - BIT_0, 1 - BIT_1)
* @param len length of the RTP bitstream
*/
static void unpack_G729(const uint8_t bitstream[], int16_t bits[], int len)
{
int16_t i;
*bits++ = SYNC_WORD; /* bit[0], at receiver this bits indicates BFI */
switch(len){
case 10:
*bits++ = SIZE_WORD;
break;
case 8: // RATE_6400
case 15: //RATE_11800
default:
TSK_DEBUG_ERROR("%d is an invalid lenght value", len);
return;
}
for(i=0; i<len; i++){
int2bin(bitstream[i], 8, &bits[i*8]);
}
}
void prm2bits_ld8f(
Word16 prm[], /* input : encoded parameters */
Word16 bits[] /* output: serial bits */
)
{
Word16 i;
Word16 *ptr_bits;
ptr_bits = bits;
*ptr_bits++ = SYNC_WORD; /* bit[0], at receiver this bits indicates BFI */
switch(prm[0]){
case 0 : { /* DTX: no bits transmitted */
*ptr_bits = RATE_0;
break;
}
case 1 : { /* SID: 15 bits (or 16 bits if OCTET mode) */
#ifndef OCTET_TX_MODE
*ptr_bits++ = RATE_SID;
for (i = 0; i < PRM_SIZE_SID; i++) {
int2bin(prm[i+1], bitsno2[i], ptr_bits);
ptr_bits += bitsno2[i];
}
#else
*ptr_bits++ = RATE_SID_OCTET;
for (i = 0; i < PRM_SIZE_SID; i++) {
int2bin(prm[i+1], bitsno2[i], ptr_bits);
ptr_bits += bitsno2[i];
}
*ptr_bits++ = BIT_0;
#endif
break;
}
case 2 : {
*ptr_bits++ = RATE_6400;
for (i = 0; i < PRM_SIZE_6K; i++) {
int2bin(prm[i+1], bitsno_6k[i], ptr_bits);
ptr_bits += bitsno_6k[i];
}
break;
}
case 3 : {
*ptr_bits++ = RATE_8000;
for (i = 0; i < PRM_SIZE; i++) {
int2bin(prm[i+1], bitsno[i], ptr_bits);
ptr_bits += bitsno[i];
}
break;
}
default : {
printf("Unrecognized frame type\n");
exit(-1);
}
}
return;
}
void prm2bits_ld8g(
Word16 prm[], /* input : encoded parameters */
Word16 bits[] /* output: serial bits */
)
{
Word16 i;
Word16 *ptr_bits;
ptr_bits = bits;
*ptr_bits++ = SYNC_WORD; /* bit[0], at receiver this bits indicates BFI */
switch(prm[0]){
case 0 : { /* DTX: no bits transmitted */
*ptr_bits = RATE_0;
break;
}
case 1 : { /* SID: 15 bits (or 16 bits if OCTET mode) */
#ifndef OCTET_TX_MODE
*ptr_bits++ = RATE_SID;
for (i = 0; i < PRM_SIZE_SID; i++) {
int2bin(prm[i+1], bitsno_B[i], ptr_bits);
ptr_bits += bitsno_B[i];
}
#else
*ptr_bits++ = RATE_SID_OCTET;
for (i = 0; i < PRM_SIZE_SID; i++) {
int2bin(prm[i+1], bitsno2[i], ptr_bits);
ptr_bits += bitsno2[i];
}
*ptr_bits++ = BIT_0;
#endif
break;
}
case 3 : {
*ptr_bits++ = RATE_8000;
for (i = 0; i < PRM_SIZE; i++) {
int2bin(prm[i+1], bitsno[i], ptr_bits);
ptr_bits += bitsno[i];
}
break;
}
case 4 : {
*ptr_bits++ = RATE_11800;
/* case 11.8 kbps */
if((prm[1]) == 0) { /* mode parameter */
*ptr_bits++ = BIT_0; /* "Backward / Forward" Indication bit */
*ptr_bits++ = BIT_0; /* Parity bit */
for (i = 0; i < PRM_SIZE_E_fwd-1; i++) {
int2bin(prm[i+2], bitsno_E_fwd[i], ptr_bits);
ptr_bits += bitsno_E_fwd[i];
}
}
else {
*ptr_bits++ = BIT_1; /* "Backward / Forward" Indication bit */
*ptr_bits++ = BIT_1; /* Parity bit */
for (i = 0; i < PRM_SIZE_E_bwd-1; i++) {
int2bin(prm[i+2], bitsno_E_bwd[i], ptr_bits);
ptr_bits += bitsno_E_bwd[i];
}
}
break;
}
default : {
printf("Unrecognized frame type\n");
exit(-1);
}
}
return;
}
/*############################## START FUNCTION ################################## */
void mpu9150_start(void) {
printf("Setting sample rate...\n");
/*=== Set sample rate divider: (REG:25) ===*/
uint8_t cmd[] = {MPU9150_SMPLRT_DIV, SAMPLE_RATE_CONFIG};
i2c_transmitinit( MPU9150_I2C_ADDR, 2, cmd );
while(!i2c_transferred()) /* Wait for transfer */ ;
printf("Sample rate set to: %i!\n", SAMPLE_RATE_CONFIG);
/*=== Set up FSYNC and dlpf: (REG:26) ===*/
printf("Setting fsync dlpf config...\n");
uint8_t fsync_dlpf_config = 0b00000011; //FSYNC disabled and dlpf_cfg set to 3.
cmd[0] = MPU9150_CONFIG;
cmd[1] = fsync_dlpf_config;
i2c_transmitinit( MPU9150_I2C_ADDR, 2, cmd );
while(!i2c_transferred()) /* Wait for transfer */ ;
printf("FSYNC rate set!\n");
/*
* With current dlpf_cfg (3) the sample rate of the accelerometer is 1kHz and the
* gyroscope is 1kHz too. The sample rate divider has been set to 20 (register 20).
* Sample rate = Gyroscope output rate / (1 + sample rate divider)
* = 1000 / (1 + 19)
* = 50Hz
*/
/* Set up the fifo_config parameter and enable sensors if they are defined in the header file: */
uint8_t fifo_config = 0b00000000;
/*=== Trigger the gyroscopes self-test and set the scale range: (REG:27) ===*/
if (INV_XYZ_GYRO) {
fifo_config = fifo_config | 0b01110000;
printf("Starting up gyroscope...\n");
//Self test xyz and set full scale range to +-2000s:
uint8_t gyro_config = 0b11111000;
cmd[0] = MPU9150_GYRO_CONFIG;
cmd[1] = gyro_config;
i2c_transmitinit( MPU9150_I2C_ADDR, 2, cmd ) ;
while(!i2c_transferred()) /* Wait for transfer */ ;
printf("Gyroscope started!\n");
}
/*=== Trigger the accelorometer self-test and set the scale range: (REG:28) ===*/
if (INV_XYZ_ACCEL) {
fifo_config = fifo_config | 0b00001000;
printf("Starting up accelorometer...\n");
uint8_t accel_config = 0b11111000; //self test xyz, with full scale range +-16g and reset hpf
cmd[0] = MPU9150_ACCEL_CONFIG;
cmd[1] = accel_config;
i2c_transmitinit( MPU9150_I2C_ADDR, 2, cmd ) ;
while(!i2c_transferred()) /* Wait for transfer */ ;
printf("Accelorometer started!\n");
}
/*=== Enable Temp on FIFO: ===*/
if (INV_TEMP) {
fifo_config = fifo_config | 0b10000000;
printf("Adding thermometer to FIFO...\n");
}
if (INV_XYZ_ACCEL) {
packet_size += 6;}
if (INV_TEMP) {
packet_size += 2;}
if (INV_XYZ_GYRO) {
packet_size += 6;}
printf("packet size: %i\n", packet_size);
//exit(0);
/*
* SKIPPING FREE FALL, MOTION DETECTION, ETC. CONFIGURATION
*/
/*=== Setup FIFO queue: (REG:35) ===
Bit order [1: Temp, 2-4: Gyro{x,y.z}, 5: Accel, 6-8: SLV{2,1,0}] */
int BUF_SIZE = 9;
char buffer[BUF_SIZE];
buffer[BUF_SIZE - 1] = '\0';
printf("Configuring FIFO with parameter %s...\n", int2bin(fifo_config, buffer, BUF_SIZE-1));
cmd[0] = MPU9150_FIFO_EN;
cmd[1] = fifo_config;
i2c_transmitinit( MPU9150_I2C_ADDR, 2, cmd );
while(!i2c_transferred()) /* Wait for transfer */ ;
printf("FIFO configured!\n");
/* Setup i2c master control (REG:36)
First bit controls multi-master capability (not needed for us I think)
Second bit controls wait for external sensors (to keep data in sync), which is not needed by us, because we do ot use external sensors
Third bit controls FIFO_EN for salve 3 (other slaves controled in REG35)
Fourth bit controls slave read and write mode (don't really know waht the implications of the different write modes are, think it's not significant for us?)
Last four bits control the i2c master clock. We set the 8mhz clock divider to 19, so set this to 12 1100??? */
printf("Setting up I2C master controller...\n");
uint8_t i2cmc_config= 0b00001101;
cmd[0] = MPU9150_I2C_MST_CTRL;
cmd[1] = i2cmc_config;
i2c_transmitinit( MPU9150_I2C_ADDR, 2, cmd );
while(!i2c_transferred()) /* Wait for transfer */ ;
printf("I2C master configured!\n");
/* Setup user control */
printf("Setting up user control...\n");
uint8_t user_config= 0b01000100;
cmd[0] = MPU9150_USER_CTRL;
cmd[1] = user_config;
i2c_transmitinit( MPU9150_I2C_ADDR, 2, cmd );
while(!i2c_transferred()) /* Wait for transfer */ ;
printf("User control configured!\n");
/*
* SLAVE CONTROL REGISTERS (37-53) WE DON'T NEED TO CONFIGURE (I THINK). 54 IS THE I2C MASTER CONTROLLER,
* ALSO NOT USED BY US, 55 IS USED TO CONFIGURE INTERRUPTS (MAYBE WE SHOULD CONFIGURE), 56 ENABLES
* INTERRUPTS, MAYBE WE SHOULD SET THE FIFO INTERRUPT TO ONE, THEN WAIT FOR THE INTERRUPT TO OCCOUR
* AND THEN READ ALL SENSORS IN ONE GO AND WAIT FOR NEXT INTERRUPT. REG 58 CONTAINS THE INTERRUPT STATA.
* 59-96 CONTAINS THE LATEST VALUES FROM THE SENOSRS, BUT WE READ THEM FROM THE FIFO INSTEAD. REG 97 IS
* MOTION DETETION STATUS, 98-102 HAS THE DATAOUT FOR THE IC2 SLAVES, 103 CONTROLS IC2 MASTER DEALY, 104
* CAN BE USED TO RESET THE PATHS FOR THE INTERNAL SENSORS, 105 IS MOTION DETECTION CONTROL, 106 USER CONTROL,
* BUT WE ENABLE THE FIFO IN A DIFFERENT REGISTER, SO SON'T NEED TO REENABLE IT HERE. 107 AND 108 ARE
* POWER MANAGEMENT.
* NOW TO GET DATA, WE SHOULD LOOK AT REGISTERS 114 AND 115 TO GET THE COUNT OF NEW MEASUREMENTS AND THEN
* READ THEM FROM THE FIFO QUEUE:
*/
}
int main(int argc, char** argv){
int i, j;
ERR_load_crypto_strings();
OpenSSL_add_all_algorithms();
OPENSSL_config(NULL);
unsigned char data_to_encrypt[] = {0x01, 0x4B, 0xAF, 0x22, 0x78, 0xA6, 0x9D, 0x33, 0x1D, 0x51, 0x80, 0x10, 0x36, 0x43, 0xE9, 0x9A, '\0'};
unsigned char key[] = {0xE8, 0xE9, 0xEA, 0xEB, 0xED, 0xEE, 0xEF, 0xF0, 0xF2, 0xF3, 0xF4, 0xF5, 0xF7, 0xF8, 0xF9, 0xFA, '\0'};
unsigned char key1[] = {0xE9, 0xE9, 0xEA, 0xEB, 0xED, 0xEE, 0xEF, 0xF0, 0xF2, 0xF3, 0xF4, 0xF5, 0xF7, 0xF8, 0xF9, 0xFA, '\0'};
unsigned char key2[] = {0xEA, 0xE9, 0xEA, 0xEB, 0xED, 0xEE, 0xEF, 0xF0, 0xF2, 0xF3, 0xF4, 0xF5, 0xF7, 0xF8, 0xF9, 0xFA, '\0'};
unsigned char iv[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, '\0'};
unsigned char data_to_encrypt2[] = {0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, '\0'};
int data_length;
if(argc == 2){
data_length = atoi(argv[1]);
} else{
data_length = 100;
}
printf("Data length: %i\n", data_length);
unsigned char data_to_encrypt3[16*data_length];
memset(data_to_encrypt3, 0, 16*data_length);
unsigned char encrypted_data_openssl[16*data_length*2];
memset(encrypted_data_openssl, 0, 16*data_length);
// unsigned char encrypted_data_fabric[16*data_length];
// memset(encrypted_data_fabric, 0, 16*data_length);
memmgr_init_shared_short();
printf("\n");
unsigned char *fpga_src = memmgr_alloc(16*data_length);
unsigned char *fpga_dest = memmgr_alloc(16*data_length);
srand (time(NULL));
int randStart = rand();
for(i=0; i<data_length; i++){
for(j=0; j<16; j++){
data_to_encrypt3[16*i + j] = i*j+j;//+randStart;
}
}
unsigned char* data_pointer = data_to_encrypt3;
unsigned char* encrypted_dest = encrypted_data_openssl;
// memset(encrypted_dest, 16*data_length, 0);
clock_t begin, end;
begin = clock();
encrypt(data_pointer, 16*data_length, key, iv, encrypted_dest);
encrypt(encrypted_dest, 16*data_length, key1, iv, encrypted_dest);
encrypt(encrypted_dest, 16*data_length, key2, iv, encrypted_dest);
end = clock();
double ticks = (double)(end - begin);
double seconds =(double)(end - begin)/CLOCKS_PER_SEC;
printf ("It took %f clicks (%f seconds) in openssl.\n",ticks,seconds);
// FPGA_AES *cipher = fpga_aes_new(key, 16, 0x1f410000, "qam", "axi-reset");
data_pointer = data_to_encrypt3;
// encrypted_dest = encrypted_data_fabric;
begin = clock();
// Aes_encrypt_cbc_memcpy(cipher, iv, encrypted_dest, data_pointer, 16*data_length);
triple_encrypt_fpga_ecb(fpga_src, 16*data_length, key, key1, key2, fpga_dest);
end = clock();
ticks = (double)(end - begin);
seconds =(double)(end - begin)/CLOCKS_PER_SEC;
printf ("\nIt took %f clicks (%f seconds) in fabric.\n",ticks,seconds);
printf("\nChecking");
ticks = clock();
char bin_buffer[33];
bin_buffer[32] = '\0';
int incorrectCount = 0;
int k = 0;
for(i=0; i<1000000; i++){
k+=5;
}
printf("\nk is: %i", k);
if(data_length > 5){
for(i=0; i<data_length; i++){
for(j=0; j<16; j++){
char openssl = encrypted_data_openssl[i*16 + j];
int2bin(openssl, bin_buffer, 32);
char fabric = fpga_dest[i*16+j];
if(openssl != fabric){
printf("\nChar at index %i is not encrypted correctly. It is %02x in openssl, %02x in fabric", i*16+j, openssl, fabric);
incorrectCount++;
}
}
}
ticks = clock() - ticks;
printf ("\nIt took %f clicks (%f seconds) to check.\n",(float)ticks,((float)ticks)/CLOCKS_PER_SEC);
} else{
printf("\nInputs:\n");
for(i=0; i<data_length; i++){
printf(" 0x");
for(j=0; j<16; j++){
printf("%02x", data_to_encrypt3[i*16+j]);
}
}
printf("\nOpenSSL results:\n");
for(i=0; i<data_length; i++){
printf(" 0x");
for(j=0; j<16; j++){
printf("%02x", encrypted_data_openssl[i*16+j]);
}
}
printf("\nFabric results:\n");
for(i=0; i<data_length; i++){
printf(" 0x");
for(j=0; j<16; j++){
printf("%02x", fpga_dest[i*16+j]);
}
}
}
printf("\n");
EVP_cleanup();
ERR_free_strings();
memmgr_free(fpga_src);
memmgr_free(fpga_dest);
return 0;
}
//This function performs the SBox substitution
//The input is a 48 bits array, and the output is a 32 bits array
void SBox_Function(unsigned int *oldBlock, unsigned int *compressedBlock)
{
int beg,end,row,col,index;
unsigned int aux[4]; //Auxiliary array that stored the Sbox value in binary
beg = 0; //flag to the beginning of the 48 bits array
end = 5; //flag to the end of the 48 bits array
index = 0; //flag that controls the array that stores substitutions
unsigned int rowBin[2], colBin[4]; // arrays that store both row and column of Sbox in binary
//Execute this until the end of 48 bits array
while(end<48)
{
//Extract both first and last bits in a range of 6 bits
rowBin[0] = oldBlock[beg];
rowBin[1] = oldBlock[end];
//Extract the 4 bits in the middle of beg and end
for(int i=beg+1,j=0;i<end;i++,j++)
{
colBin[j] = oldBlock[i];
}
//Convert Row and Col to numbers
row = bit2int(rowBin,2);
col = bit2int(colBin,4);
//Select the correspondent Sbox number and transforms it in binary
switch(end)
{
case 5:
int2bin(aux,(int)S1[row][col],4);
break;
case 11:
int2bin(aux,(int)S2[row][col],4);
break;
case 17:
int2bin(aux,(int)S3[row][col],4);
break;
case 23:
int2bin(aux,(int)S4[row][col],4);
break;
case 29:
int2bin(aux,(int)S5[row][col],4);
break;
case 35:
int2bin(aux,(int)S6[row][col],4);
break;
case 41:
int2bin(aux,(int)S7[row][col],4);
break;
case 47:
int2bin(aux,(int)S8[row][col],4);
break;
}
//Append the 4 bits array generated to the 32 bits array
for(int j=0;j<4;j++,index++)
compressedBlock[index] = aux[j];
beg+=6;
end+=6;
}
}
// funcion main
int main (){
int x, i;
init_input("input");
// test factorial entero
print_string("Factorial Enteros----------------------------------");
x=get_int(); // lee la cantidad de veces que ejecutara la funcion
i = 0;
while (i<x){
int aux;
aux=get_int(); // lee los datos para invocar a la funcion
aux = factorial(aux);
print_int(aux);
i++;
}
print_string("---------------------------------------------------------");
// test factorial real
print_string("Factorial Reales----------------------------------");
x=get_int();
i = 0;
while (i<x){
float aux;
aux=get_float();
aux = factorialF(aux);
print_float(aux);
i++;
}
print_string("---------------------------------------------------------");
// test factorial array entero
print_string("Factorial Array Enteros----------------------------------");
x=get_int(); // lee la cantidad de veces que ejecutara la funcion
i = 0;
while (i<x){
int aux;
aux=get_int(); // lee los datos para invocar a la funcion
aux = factorialArray(aux);
print_int(aux);
i++;
}
print_string("---------------------------------------------------------");
// test nthprime entero
print_string("Nthprime Enteros----------------------------------");
x=get_int(); // lee la cantidad de veces que ejecutara la funcion
i = 0;
while (i<x){
int aux;
aux=get_int(); // lee los datos para invocar a la funcion
aux = nthprime(aux);
print_int(aux);
i++;
}
print_string("---------------------------------------------------------");
// test nthprime array entero
print_string("Nthprime Array Enteros----------------------------------");
x=get_int(); // lee la cantidad de veces que ejecutara la funcion
i = 0;
while (i<x){
int aux;
aux=get_int(); // lee los datos para invocar a la funcion
aux = nthprimeArray(aux);
print_int(aux);
i++;
}
print_string("---------------------------------------------------------");
// test int2bin entero
print_string("Int2Bin Enteros----------------------------------");
x=get_int(); // lee la cantidad de veces que ejecutara la funcion
i = 0;
while (i<x){
int aux;
aux=get_int(); // lee los datos para invocar a la funcion
aux = int2bin(aux);
print_int(aux);
i++;
}
print_string("---------------------------------------------------------");
// test gcd entero
print_string("GCD Enteros----------------------------------");
x=get_int(); // lee la cantidad de veces que ejecutara la funcion
i = 0;
while (i<x){
int aux;// lee los datos para invocar a la funcion
aux = gcd(get_int(),get_int());
print_int(aux);
i++;
}
print_string("---------------------------------------------------------");
// test test
print_string("test----------------------------------");
test();
print_string("---------------------------------------------------------");
// test test1
print_string("test1----------------------------------");
test1();
print_string("---------------------------------------------------------");
close_input();
return 1;
}
//============================================================================================================
int main()
{
int N; //system size
cout <<"set system size: ";
cin >>N;
int m; //total magnetization counted in multiples of 1
cout <<"set total magnetization (in multiples of 1/2): ";
cin >>m;
cout <<endl;
bool testpos=0; //test the position finder of the states. Set to 1 for test.
Hamiltonian testHam(N,m);
//Test der Suchfunktion:
if (testpos){
int pos=0;
char* out;
for(int i=0;i<testHam.get_dim();i++){
REP_TYPE state = testHam.get_basis_state(i);
pos = testHam.find_state(state);
out = int2bin(state,NULL);
out = &(out[sizeof(REP_TYPE)*CHAR_BIT - N]); //cutoff string, borrowed from utilities.c
cout <<"integer: " <<state<<" binary: "<<out<<" pos: "<<pos<<endl;
}
}
cout <<"\n";
testHam.print_basis_list();
testHam.print_system_size();
testHam.print_basis_dimension();
cout <<"\n";
//GROUND STATE:
Hamiltonian h1(N,m);
h1.set_ham(1,0); //mu=1.1
h1.diagonalize();
Hamiltonian h2(N,m);
h2.set_ham(4,0);
h2.diagonalize();
plot_groundstate_quench(&h1,&h2,0.01,30);
//state eingeben :
char test[testHam.get_system_size()];
cout << "insert initial state:"<<endl;
cin.ignore();
cin.getline(test,testHam.get_system_size()+1);
cx_vec state=input_state(test,&testHam);
cout <<"vector is: "<<endl;
cout << state <<endl;
testHam.set_ham(0,0);
testHam.diagonalize();
plot_lohschmidt_echo(&testHam,state,0.01,50);
/*
double T=40; //60
double dt=0.1; //0.02
double mu=0;
double lambda=0;
while (lambda <= 1){
testHam.set_ham(mu,lambda); // mu=0,Lambda=0
cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
testHam.diagonalize();
plot_sz(&testHam,state,dt,T);
T-=5;
lambda+=0.1;
}
*/
/*(kollision)
mu=0;
testHam.set_ham(mu,lambda); // mu=0,Lambda=0
cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
testHam.diagonalize();
plot_sz(&testHam,state,dt,T);
mu=5;
testHam.set_ham(mu,lambda); // mu=5,Lambda=0
cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
testHam.diagonalize();
plot_sz(&testHam,state,dt,T);
*/
/* (two string)
mu+=1;
while (mu <= 3){
testHam.set_ham(mu,lambda); // mu=0,Lambda=0
cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
testHam.diagonalize();
plot_sz(&testHam,state,dt,T);
mu+=1;
}
*/
//(kurzzeit)
testHam.set_ham(0,0);
cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
testHam.diagonalize();
plot_kurz_auto(&testHam,state,0.01,10);
//plot_lohschmidt_echo(&testHam,state,0.01,10); //(ham,dt,T)
//plot_szsz_n(&testHam,state,1,0.1,10); //(ham,n,dt,T)
/*
int i=0;
for (;;){
cout << "enter component:"<<endl;
cin.ignore();
cin >> i;
cout << i<<" th spin is "<<get_sz(string_to_state(test,testHam.get_system_size()),i,testHam.get_system_size())*1/2.<<endl;
}
*/
return 0;
}
