Laboratorul 9

1.

#include <stdio.h>

#include <cdefBF533.h>

#include <ccblkfn.h>

#include <sys\exception.h>

#include <math.h>

#include <complex.h>

#include <filter.h>

#define BUFFER_SIZE 2

int buffer[BUFFER_SIZE] = {0, 0};

short input, output;

int main() {

while (1) {

input = *pSPORT0_RX;

output = inversare_frecvente(input);

*pSPORT0_TX = output;}

return 0;

short inversare_frecvente(short x) {

short y = x - buffer[1] + buffer[0];

buffer[1] = buffer[0];

buffer[0] = x;

return y;

}
1.1

#include <stdio.h>

#include <cdefBF533.h>

#include <ccblkfn.h>

#include <sys\exception.h>

#define BUFFER_SIZE 4 // Numarul de eșantioane stocate în buffer

int buffer[BUFFER_SIZE] = {0, 0, 0, 0}; // Inițializarea bufferului

short input, output;

int main() {

while (1) {

// Citirea eșantionului de intrare

input = *pSPORT0_RX;

// Aplicarea coeficienților la eșantionul curent și stocarea în buffer

buffer[0] = input;

buffer[1] = -input + buffer[0];

buffer[2] = input - buffer[1];

buffer[3] = -input + buffer[2];

// Transmiterea eșantionului procesat către portul de ieșire

output = buffer[3];

*pSPORT0_TX = output;

return 0;

}
2.

#include <stdio.h>

#include <stdlib.h>

#define SIGNAL_LEN 10

#define IMPULSE_RESPONSE_LEN 5

int main() {

// Definirea semnalului de intrare și a răspunsului la impuls

int signal[SIGNAL_LEN] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int impulse_response[IMPULSE_RESPONSE_LEN] = {1, -1, 1, -1, 1};

// Definirea buffer-ului în care se vor stoca produsele

int product_buffer[SIGNAL_LEN + IMPULSE_RESPONSE_LEN - 1] = {0};

// Aplicarea algoritmului de convoluție

for (int i = 0; i < SIGNAL_LEN; i++) {

for (int j = 0; j < IMPULSE_RESPONSE_LEN; j++) {

product_buffer[i+j] += signal[i] * impulse_response[j];

// Afisarea rezultatului convolutiei

printf("Convolutia semnalului de intrare cu raspunsul la impuls este:\n");

for (int i = 0; i < SIGNAL_LEN + IMPULSE_RESPONSE_LEN - 1; i++) {

printf("%d ", product_buffer[i]);

printf("\n");

return 0;

}
 Laboratorul 10
1.#include <stdio.h>

#include <wiringPi.h>

#include <math.h>

#define BUTTON_PIN 4

volatile int frequency = 440; // Frecvența inițială a semnalului (440 Hz)

void changeFrequency(void) {

frequency = 880; // Frecvența nouă a semnalului (880 Hz)

int main(void) {

wiringPiSetup();

pinMode(BUTTON_PIN, INPUT);

pullUpDnControl(BUTTON_PIN, PUD_UP);

wiringPiISR(BUTTON_PIN, INT_EDGE_FALLING, &changeFrequency);

int fs = 44100; // Frecvența de eșantionare

int duration = 5; // Durata semnalului în secunde

int numSamples = fs * duration;

double t[numSamples];

double signal[numSamples];

for (int i = 0; i < numSamples; i++) {

t[i] = (double) i / fs;

signal[i] = sin(2 * M_PI * frequency * t[i]);

// Redarea semnalului aici

return 0;

}
2. #include <stdio.h>

#include <sys\exception.h>

#include <cdefbf533.h>

// Define parameters for the equation

#define a 1664525

#define c 32767

#define m 4294967296UL // 2^32

#define x0 0

// Function to calculate the next value in the sequence

unsigned long nextValue(unsigned long xn) {

return (a*xn + c) % m;

int main() {

unsigned long xn = x0;

// Configure SPORT0 for output

*pSPCTL0 = SPEN_A | SCHEN_A | SDEN_A | SPTRAN | SPFS_0 | SP32 | LSBF;

*pSPMCTL0 = 0x0000;

*pSPBRR0 = 9;

// Loop forever, sending each new value to the output

while(1) {

xn = nextValue(xn);

*pTX0 = xn;

return 0;

}
3. #include <stdio.h>

#include <stdint.h>

#define a 1664525

#define c 32767

#define m (1ULL << 32)

uint32_t x = 0; // Variabila de stare initializata cu x(0) = 0

uint32_t generateNoise(void) {

x = (a * x + c) % m; // Calculul urmatoarei valori folosind ecuatia data

return x; // Returnarea valorii generate

int main(void) {

// Initializarea configuratiei pentru SPORT0 TX0

while (1) {

uint32_t noise = generateNoise(); // Generarea unei valori de zgomot

// Transmiterea valorii de zgomot prin SPORT0 TX0

// Opreste temporar executia pentru a simula un semnal continuu de zgomot

// Curatarea resurselor si inchiderea programului