SE3Binome2023-9

Voiture

1. Objectif du Projet

Le but est de concevoir et développer une mini-voiture autonome en termes d'énergie, optimisée pour une utilisation efficiente de l'énergie, avec une gestion intelligente des mouvements et une signalisation intégrée.

2. Caractéristiques Techniques

a. Alimentation

• Batterie au Lithium : Utilisation d'une batterie au lithium pour l'alimentation principale, garantissant une autonomie élevée et une recharge efficace.
• Alimentation Intégrée : Mise en place d'un système d'alimentation intégré sur la carte pour une distribution optimale de l'énergie.

b. Propulsion

• Moteurs Continus : Deux moteurs continus de petite taille (2 cm) seront utilisés, positionnés au niveau des roues avant.
• Gestion des Moteurs : Utilisation d'un pont en H pour la réduction des contraintes mécaniques et l'inversion du sens de rotation des roues, favorisant une meilleure gestion de l'espace et du poids.

c. Signalisation

• LED de Surface : Installation de quatre LED de surface, deux à l'avant et deux à l'arrière, pour indiquer le sens de déplacement

3. Contrôle et Programmation

• Interface de Programmation : L'utilisateur peut programmer le trajet et les comportements de la voiture via un logiciel dédié sur ordinateur, qui communique avec la voiture via USB.
• Microcontrôleur : Le projet utilisera un microcontrôleur ATmega16u4 , la sélection dépendant de l'espace disponible pour la mémoire flash.

SCHEMA ET COMPOSANTE :

1- Batterie (Lithium)On utilise une batterie au Lithium afin que la voiture fonctionne de manière autonome

batterie LIPO

2-Microcontrôleur :

on utilise un ATMEGA16U4 :

3-régulateur et moteur  :

4-port USB :

PCB :

Détection du mode DFU sur notre carte :

Utilisation de la carte Arduino Uno afin de détecter le mode DFU :

les commandes utilisée a l'aide l'Arduino pour programmer le bootloader :

• avrdude -c stk500v1 -p atmega32u4 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xFF:m -U efuse:w:0xF7:m
• avrdude -c stk500v1 -p atmega32u4 -P /dev/ttyACM0 -b 19200 -U flash:w:ATMega16U4-usbdevice_dfu-1_0_0.hex

la carte est bien détecte : en utilisant la commande "lsusb" :

Programmateur AVR :

Nous allons tester nos LED en codant un simple code permettant de les faire clignoter, nous allons utiliser un programmateur AVR :

#include<avr/io.h>
#include<util/delay.h>

#define LED_PIN PF4


int main(void)
{  
  DDRF |=(1 << LED_PIN);
    while(1)
    {  
        PORTF |= (1 << LED_PIN);
       _delay_ms(1000);
	PORTF &= ~(1 << LED_PIN);
       _delay_ms(1000);
    }
return 0;
}
 

makefile :

export CC = avr-gcc

export MCU = atmega16U4
export TARGET_ARCH = -mmcu=$(MCU)

export CFLAGS =  -Wall -I. -DF_CPU=16000000 -Os #-g
export LDFLAGS = -g $(TARGET_ARCH) -lm -Wl,--gc-sections #	-Os


TARGET = display
TERM = /dev/ttyUSB0
#TERM = /dev/ttyACM0
CPPFLAGS = -mmcu=$(MCU)
PGMER = -c stk500v1 -b 57600 -P $(TERM)
PGMERISP = -c stk500v1 -b 115200 -P $(TERM)
ARVDUDECONF= -C /usr/local/arduino/arduino-0021/hardware/tools/avrdude.conf
export DUDE = /usr/bin/avrdude -F -v -p $(MCU) $(AVRDUDECONF)

C_SRC = $(wildcard *.c)
OBJS = $(C_SRC:.c=.o)


all: $(TARGET).hex

ass:$(C_SRC)
	$(CC) -S $(CPPFLAGS) $(CFLAGS) $< -o $@

clean:
	rm -f *.o

%.o:%.c
	$(CC) -c $(CPPFLAGS) $(CFLAGS) $< -o $@


$(TARGET).elf: $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $(OBJS)

$(TARGET).hex: $(TARGET).elf
	avr-objcopy -j .text -j .data -O ihex $(TARGET).elf $(TARGET).hex
	avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 -O ihex $(TARGET).elf eeprom.hex

upload: $(TARGET).hex
	stty -F $(TERM) hupcl # reset
	$(DUDE) $(PGMER) -U flash:w:$(TARGET).hex
#	$(DUDE) $(PGMERISP) -U flash:w:$(TARGET).hex

size: $(TARGET).elf
	avr-size --format=avr --mcu=$(MCU) $(TARGET).elf

test LED :

programmation du moteur :

#include <avr/io.h>
#include <util/delay.h>

void pwm_init(void) {
    TCCR1A |= (1 << WGM10) | (1 << WGM12); // Mode PWM rapide 8-bit
    TCCR1A |= (1 << COM1A1); // Non-inverted PWM sur OC1A (PB5)
    TCCR1B |= (1 << CS11); // Prescaler de 8
    DDRB |= (1 << PB5); // PB5 comme sortie (OC1A)
}

void set_pwm_duty_cycle(uint8_t duty_cycle) {
    OCR1A = duty_cycle; // Régler le duty cycle
}

void motor_init(void) {
    DDRD |= (1 << PD2) | (1 << PD3); // PD2 (AIN2) et PD3 (AIN1) comme sorties
    PORTD &= ~((1 << PD2) | (1 << PD3)); // Initialiser à 0

    // Configurer les broches des LED comme sorties
    DDRF |= (1 << PF0) | (1 << PF1) | (1 << PF4) | (1 << PF5); // PF0, PF1, PF4, PF5 comme sorties
    PORTF &= ~((1 << PF0) | (1 << PF1) | (1 << PF4) | (1 << PF5)); // Initialiser à 0
}

void motor_forward(void) {
    PORTD |= (1 << PD3); // AIN1 à 1
    PORTD &= ~(1 << PD2); // AIN2 à 0
    PORTF |= (1 << PF5); // Allumer LED1
    PORTF &= ~((1 << PF4) | (1 << PF1) | (1 << PF0)); // Éteindre les autres LED
}

void motor_backward(void) {
    PORTD |= (1 << PD2); // AIN2 à 1
    PORTD &= ~(1 << PD3); // AIN1 à 0
    PORTF |= (1 << PF4); // Allumer LED2
    PORTF &= ~((1 << PF5) | (1 << PF1) | (1 << PF0)); // Éteindre les autres LED
}

void motor_turn_left(void) {
    PORTD |= (1 << PD2); // AIN2 à 1
    PORTD &= ~(1 << PD3); // AIN1 à 0
    PORTF |= (1 << PF1); // Allumer LED3
    PORTF &= ~((1 << PF5) | (1 << PF4) | (1 << PF0)); // Éteindre les autres LED
}

void motor_turn_right(void) {
    PORTD |= (1 << PD3); // AIN1 à 1
    PORTD &= ~(1 << PD2); // AIN2 à 0
    PORTF |= (1 << PF0); // Allumer LED4
    PORTF &= ~((1 << PF5) | (1 << PF4) | (1 << PF1)); // Éteindre les autres LED
}

void motor_stop(void) {
    PORTD &= ~((1 << PD3) | (1 << PD2)); // AIN1 et AIN2 à 0
    PORTF &= ~((1 << PF5) | (1 << PF4) | (1 << PF1) | (1 << PF0)); // Éteindre toutes les LED
}

int main(void) {
    pwm_init();
    motor_init();

    while (1) {
        motor_forward();
        set_pwm_duty_cycle(128); // Régler le duty cycle à 50%
        _delay_ms(5000); // Tourner pendant 5 secondes

        motor_stop();
        _delay_ms(2000); // Attendre pendant 2 secondes

        motor_backward();
        set_pwm_duty_cycle(128); // Régler le duty cycle à 50%
        _delay_ms(5000); // Tourner pendant 5 secondes

        motor_stop();
        _delay_ms(2000); // Attendre pendant 2 secondes

        motor_turn_left();
        set_pwm_duty_cycle(128); // Régler le duty cycle à 50%
        _delay_ms(5000); // Tourner pendant 5 secondes

        motor_stop();
        _delay_ms(2000); // Attendre pendant 2 secondes

        motor_turn_right();
        set_pwm_duty_cycle(128); // Régler le duty cycle à 50%
        _delay_ms(5000); // Tourner pendant 5 secondes

        motor_stop();
        _delay_ms(2000); // Attendre pendant 2 secondes
    }

    return 0;
}