SE3Binome2023-9
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
2-Microcontrôleur :
on utilise un ATMEGA16U4 :
3-régulateur et moteur :
4-port USB :
PCB :
PCB : Il y avait un léger souci lié aux deux broches du microcontrolleur qui n'étaient pas connectées (ce souci a été résolu par MS REDON en liant les broches).
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:mavrdude -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;
}
Test moteur :
Le test de la carte électronique n'a malheureusement pas été aussi concluant que prévu. Le moteur ne s'est pas mis en marche comme espéré, et le mode Device Firmware Upgrade (DFU) a cessé de fonctionner de manière inexplicable. J'ai tenté de reprogrammer le mode DFU en réinitialisant le microcontrôleur et en utilisant plusieurs méthodes pour recharger le firmware, mais cela n'a pas résolu le problème.
Conclusion :
Mon projet de conception et de réalisation d'une carte électronique pour une voiture électrique ne s'est pas déroulé comme prévu, mais il a été incroyablement enrichissant. C'était ma première expérience avec KiCad, un logiciel de conception de circuits imprimés (PCB), ainsi que ma première tentative de soudage de composants électroniques et de programmation d'une carte.
Durant cette aventure, j'ai appris à utiliser KiCad pour dessiner et simuler des circuits, ce qui m'a permis de comprendre les principes de base de la conception électronique. Même si j'ai rencontré plusieurs défis techniques, comme des erreurs de routage et des problèmes de compatibilité entre les composants, chaque obstacle m'a offert une opportunité précieuse de renforcer mes compétences et de comprendre les subtilités de la conception de circuits imprimés.
Le processus de soudage des composants sur la carte a également été une expérience formatrice. Bien que j'aie eu du mal au début avec la précision requise pour souder de petits composants, avec de la pratique et de la patience, j'ai réussi à améliorer ma technique