Programmation et Logique

// Tester si le bit 3 est à 1
uint8_t value = 0b00101010;
if (value & (1 << 3)) {
    printf("Bit 3 est à 1\n");
}

// Mettre le bit 5 à 1
value |= (1 << 5);  // value = 0b00101010 | 0b00100000 = 0b00101010

// Mettre le bit 3 à 0
value &= ~(1 << 3);  // value = 0b00101010 & 0b11110111 = 0b00100010

// Inverser le bit 1
value ^= (1 << 1);  // XOR avec 1 inverse le bit

// Registre de contrôle 8 bits : [MODE:2][SPEED:3][ENABLE:1][RESERVED:2]
uint8_t reg = 0b10101101;

// Extraire SPEED (bits 3-5)
uint8_t speed = (reg >> 3) & 0b111;  // Décale puis masque 3 bits
printf("Speed: %d\n", speed);  // Speed: 5

// Extraire MODE (bits 6-7)
uint8_t mode = (reg >> 6) & 0b11;
printf("Mode: %d\n", mode);  // Mode: 2

// Port D = pins 0-7 sur Arduino
// Au lieu de digitalWrite() qui est lent...

// Méthode lente (1 pin à la fois)
digitalWrite(8, HIGH);   // ~5 µs

// Méthode rapide (manipulation directe des registres)
PORTB |= (1 << 0);       // ~125 ns (40× plus rapide !)

// Configurer plusieurs pins en une seule opération
DDRB = 0b00111111;  // Pins 8-13 en sortie
PORTB = 0b00101010; // Écrire pattern binaire sur les 6 pins

// Lire l'état d'un port complet
uint8_t portState = PINB;
if (portState & (1 << 2)) {
    // Pin 10 est HIGH
}

// Trame APRS simplifiée (en réalité beaucoup plus complexe)
typedef struct {
    uint8_t flags;      // [TYPE:3][PRIORITY:2][RESERVED:3]
    uint16_t position;  // Latitude/Longitude codée
    uint8_t data;       // Altitude, vitesse, etc.
} APRSFrame;

void decodeAPRS(APRSFrame *frame) {
    // Extraire le type de message
    uint8_t type = (frame->flags >> 5) & 0b111;
    
    // Extraire la priorité
    uint8_t priority = (frame->flags >> 3) & 0b11;
    
    // Décoder la position (exemple simplifié)
    float lat = (frame->position >> 8) * 0.01;  // 8 bits MSB
    float lon = (frame->position & 0xFF) * 0.01; // 8 bits LSB
    
    printf("Type: %d, Priority: %d\n", type, priority);
    printf("Position: %.2f, %.2f\n", lat, lon);
}

-- Testbench pour l'additionneur
entity adder_4bit_tb is
end adder_4bit_tb;

architecture Behavioral of adder_4bit_tb is
    -- Déclaration du composant à tester
    component adder_4bit
        Port ( A, B : in STD_LOGIC_VECTOR(3 downto 0);
               Cin : in STD_LOGIC;
               Sum : out STD_LOGIC_VECTOR(3 downto 0);
               Cout : out STD_LOGIC );
    end component;
    
    -- Signaux de test
    signal A, B, Sum : STD_LOGIC_VECTOR(3 downto 0);
    signal Cin, Cout : STD_LOGIC;
    
begin
    -- Instanciation du composant
    UUT: adder_4bit port map (A, B, Cin, Sum, Cout);
    
    -- Processus de test
    stim_proc: process
    begin
        -- Test 1 : 5 + 3 = 8
        A <= "0101"; B <= "0011"; Cin <= '0';
        wait for 10 ns;
        assert (Sum = "1000" and Cout = '0')
            report "Test 1 failed!" severity error;
        
        -- Test 2 : 15 + 1 = 16 (overflow)
        A <= "1111"; B <= "0001"; Cin <= '0';
        wait for 10 ns;
        assert (Sum = "0000" and Cout = '1')
            report "Test 2 failed!" severity error;
        
        -- Fin de simulation
        wait;
    end process;
end Behavioral;

# Simulation d'un additionneur complet en Python
def full_adder(a, b, cin):
    """Additionneur complet : retourne (sum, cout)"""
    sum_bit = a ^ b ^ cin          # XOR à 3 entrées
    cout = (a & b) | (cin & (a ^ b))  # Logique de retenue
    return sum_bit, cout

def ripple_carry_adder(a_bits, b_bits, cin=0):
    """Additionneur 4 bits par propagation de retenue"""
    result = []
    carry = cin
    
    for a, b in zip(a_bits, b_bits):
        sum_bit, carry = full_adder(a, b, carry)
        result.append(sum_bit)
    
    return result, carry

# Test
a = [1, 0, 1, 0]  # 5 en binaire (LSB first)
b = [1, 1, 0, 0]  # 3 en binaire
sum_bits, cout = ripple_carry_adder(a, b)

print(f"A = {a} (5)")
print(f"B = {b} (3)")
print(f"Sum = {sum_bits} (8)")
print(f"Carry out = {cout}")