int main(int argc, char **argv)
{
FILE *swp;
struct cache *c;
struct matrix *m;
FILE *matrix_shared;
readargs(argc, argv);
if ((swp = fopen(swapfile, "w+")) == NULL)
error("cannot open swap file");
c = cache_create(&access_info, swp, CACHE_SIZE);
/* Read traces. */
for (int i = 0; i < ntraces; i++)
{
FILE *trace;
if ((trace = fopen(tracefiles[i], "r")) == NULL)
error("cannot open trace file");
trace_read(c, trace, i);
fclose(trace);
fprintf(stderr, "\nFechado arquivo de trace da thread %d\n\n", i);
}
/* Flushe traces on swap file. */
cache_flush(c);
/* Create communication matrix. */
fseek(swp, 0, SEEK_SET);
m = matrix_create(QTD_THREADS, QTD_THREADS);
fprintf(stderr, "\nMatriz criada\n");
matrix_generate(swp, m);
if ((matrix_shared = fopen(outfile, "w")) == NULL)
error("cannot open output file");
fprintf(stderr, "\nGravar matriz no arquivo\n");
for (int i = 0; i < ntraces; i++)
{
for(int j = 0; j < ntraces; j++)
fprintf(matrix_shared, "%d;%d;%d\n", i, j, (int) matrix_get(m, i, j));
}
/* House keeping. */
fclose(matrix_shared);
fclose(swp);
fprintf(stderr, "\n\n FIM!\n");
return (EXIT_SUCCESS);
}
void test_matrix()
{
struct Matrix* m = matrix_generate(5,5);
printf("Matrix null: %d\n", matrix_is_null(m));
matrix_make_identity(m);
struct Matrix* m2 = matrix_copy(m);
matrix_set(m2,1,2,1);
struct Matrix* m3 = matrix_mul(m2,m);
matrix_show(m3);
matrix_free(m);
matrix_free(m2);
matrix_free(m3);
}
int main(void)
{
struct Hamming_config* conf = hamming_generate_config();
i = 1;
j = 0;
data = matrix_generate(N,1);
#ifdef DEBUG
//Setup led for debugging
//LED_DDR |= LED_PIN_MASK;
//LED_PORT &=~LED_PIN_MASK;
#endif
uart_init(BAUD_RATE);
// Pin change interrupt (INT1 pin)
EICRA |= (1 << ISC11); // Falling edge
EIMSK |= (1 << INT1); // Enable Interruption
EIFR |= (1 << INTF1);
char str[5];
// Enable interrupts.
sei();
//Main loop
for(;;)
{
sprintf(str, "%d\n", freeRam());
uart_tx_str(str);
if(i == 8)
{
struct Matrix* tmp = hamming_correction(data, conf);
struct Matrix* deco = hamming_decode(tmp, conf);
data_show(deco->data);
matrix_free(tmp);
matrix_free(deco);
i = 1;
}
}
}
void test_hamming()
{
struct Hamming_config* conf = hamming_generate_config();
printf("\nTest of the (%d, %d, 3) Hamming code\n--------------------------------\n\n", N, K);
// Display the generator and control matrix
printf("Control matrix: \n");
matrix_show(conf->CONTROL_MATRIX);
printf("Generator matrix: \n");
matrix_show(conf->GENERATOR_MATRIX);
printf("Syndromes array: \n");
for(uint8_t i = 0; i <= N; i++)
{
print_var_bits(i);
printf(" : ");
print_var_bits(conf->SYNDROMES_ARRAY->data_array[i]);
printf(" (%d : %d)", i, conf->SYNDROMES_ARRAY->data_array[i]);
printf("\n");
}
printf("\n");
// Generation of the word to encode
struct Matrix* dte = matrix_generate(K, 1);
matrix_set(dte, 3, 1, 1);
matrix_set(dte, 1, 1, 1);
// Display
printf("Data to encode : %d elements\n", dte->data->data_number);
matrix_show_word(dte);
// Encoding
struct Matrix* d = hamming_encode(dte, conf);
printf("Data encoded : %d elements\n", d->data->data_number);
matrix_show_word(d);
// Add an error
data_set(3, 1, d->data);
printf("Data modified : %d elements\n", d->data->data_number);
matrix_show_word(d);
// Correction
struct Matrix* r = hamming_syndrome(d, conf);
printf("\n\nCorrection\n-----------\n\n");
printf("Syndrome of the modified code : %d \n", matrix_word_to_int(r));
if(!matrix_is_null(r))
{
uint8_t b = hamming_check_syndrome(r, conf);
printf("The bit %d is corrupted\n", b + 1);
}
else
printf("No bit corrupted\n");
matrix_free(dte);
matrix_free(d);
matrix_free(r);
hamming_free_config(conf);
}
int main(void)
{
// Generate Hamming configuration
struct Hamming_config* hamming_config = hamming_generate_config();
uint32_t nb_data = 512;
char data_string[] = "01000010011011110110111001101010011011110111010101110010001011000010000001101010011001010010000001110011011101010110100101110011001000000110110001100101001000000111000001110010011001010110110101101001011001010111001000100000011101000110010101111000011101000110010100100000011001000110010100100000011011000010011101101000011010010111001101110100011011110110100101110010011001010010000001100100011001010010000001101100001001110110100001110101011011010110000101101110011010010111010011000011101010010010000000100001";
uint8_t remainder = nb_data % K; // Data number which will not be encoded
uint8_t p;
struct Matrix* data_loaded = matrix_generate(K, 1);
// Send number of data
for(uint8_t i = 0; i < 32; i++)
ow_write_bit((nb_data & _BV(i)) ? 1 : 0);
_delay_us(100);
// Send encoded data
for(uint32_t i = 0; i < nb_data; i--)
{
if(i % K == K - 1)
{
matrix_set(data_loaded, (i % K) + 1, 1, (data_string[nb_data - 1 - i] == 0x31) ? 1 : 0);
struct Matrix* data_encoded = hamming_encode(data_loaded, hamming_config);
for(p = 0; p < N; p++)
//ow_write_bit(matrix_get(data_encoded, p + 1, 1));
matrix_show(data_encoded);
matrix_free(data_encoded);
_delay_us(10);
}
else
{
matrix_set(data_loaded, (i % K) + 1, 1, (data_string[nb_data - 1 - i] == 0x31) ? 1 : 0);
data_show(data_loaded->data);
}
}
/*
// Remainder
if(remainder != 0)
{
// Void other data than remainder
for(p = remainder + 1; p < K; p++)
matrix_set(data_loaded, j, 1, 0);
// Encode
struct Matrix* data_encoded = hamming_encode(data_loaded, hamming_config);
// Send by one_wire
for(p = 0; p < N; p++)
ow_write_bit(matrix_get(data_encoded, p + 1, 1));
matrix_free(data_encoded);
}
*/
matrix_free(data_loaded);
return 0;
}
