/* barillet.c */ /* es - Input/Output general purpose board. {{{ * * Copyright (C) 2006 Lambert Thomas * * Robot APB Team/Efrei 2006. * Web: http://assos.efrei.fr/robot/ * Email: robot AT efrei DOT fr * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * }}} */ #include "barillet.h" #include "modules/utils/utils.h" #include "common.h" #include "io.h" /* utilisation de OCR1A pour le moteur barillet OCR1B pour la turbine 1 => avant OCR1C pour la turbine 2 => arriere SIG_INTERRUPT7 pour la fourche montee de balle arriere SIG_INTERRUPT6 pour la fourche montee de balle avant SIG_INTERRUPT5 pour la fourche barillet 1 => celle pres de la carte de puissance SIG_INTERRUPT4 pour la fourche barillet 2 => celle pres de la carte de es-2006 */ /* XXX verifier que les turbines sont en vitesse lente si inutilisé */ /* XXX verifier que le sens de rotation du barillet est 0 si inutilisé */ /* etat pour l'interruption fourche optique montee de balle arriere */ #define MONTEE 1 #define DESCENTE 0 #define TERMINE 0 #define EN_COURS 1 /* vitesse de rotation maximale du barillet */ #define VITESSE_BAR_MAX_ 0xA0 /* XXX a etalonner */ /* vitesse de rotation minimale du barillet */ #define VITESSE_BAR_MIN_ 0x10 /* XXX a etalonner */ /* vitesse de rotation maximale des turbines */ #define VITESSE_TURB_MAX_ 0x70 /* XXX a etalonner */ /* vitesse de rotation minimale des turbines */ #define VITESSE_TURB_MIN_ 0x10 /* XXX a etalonner */ /* delai d'une µs pour la carte puissance */ #define DELAY_ 1 /* position relative au barillet */ volatile uint8_t pos_actuel_; uint8_t pos_prec_; uint8_t pos_final_; /* etat d'attente pour l'interruption fourche optique */ uint8_t etat_inter_ar_; /* fourche arriere */ volatile uint8_t etat_inter_av_; /* fourche avant */ /* variable pour le delay aspiration */ volatile uint8_t compteur_timer_; /* etat de la rotation */ uint8_t rotation_en_cours_; /* variable indiquant que la balle est extraite */ volatile uint8_t inter_ar_; /* XXX variable globale avec le main */ /* variable indiquant qu'il faut faire une extraction de balle */ uint8_t extraction; /* variable indiquant que l'on depose une balle, on attend que la barriere optique voit la balle passee */ uint8_t depose; /* variable pour lancer une rotation */ uint8_t rotation; /* position du barillet a aller */ uint8_t pos_a_aller; /* fonctions static dans le fichier */ static void rotation_barillet( uint8_t pos_a_aller ); static void pos_bar(void); static void extraction_balle(void); static void extraction_fin(void); static void new_balle(void); static void depose_balle(void); static void vitesse_turbine( uint8_t turbine, uint8_t vitesse ); /* Initialisation pour tout ce qui concerne le barillet */ inline void barillet_init (void) { /* initialisation des registres du timer 1 pour la PWM total*/ ///******************************* // * a inserer dans es_config * // * *****************************/ // // TCCR1A = // regv (COM1A1, COM1A0, COM1B1, COM1B0, COM1C1, COM1C0, WGM11, WGM10, // 1, 0, 1, 0, 1, 0, 1, 1); // // TCCR1B = // regv ( ICNC1, ICES1, 5, WGM13, WGM12, CS12, CS11, CS10, // 0, 0, 0, 0, 1, 0, 0, 1); // ///********************************/ /* initialisation des sorties sur le port B pour moteur et turbines */ DDRB |= _BV(7) | _BV(6) | _BV (5) | _BV (4); /* initialisation des entrees du port E pour les interruptions */ DDRE &= ~(_BV(7) | _BV(6) | _BV (5) | _BV (4)); /* mode PWM = 0 */ OCR1A = 0; /* vitesse moteur barillet null */ utils_delay_us ( DELAY_ ); /* attente d'1 µs pour la puiss_barillet */ // FIXME // 1µs ok, mais fait pas appel à delay_ms non ? // Passe aussi ton 1 en define, histoire que si tu veuilles le changer, // ca ne soit pas trop galère. Voir meme une fonction inline qui // appelle que le utils_delay_ms, enfin on verra après. // FIXME // il y a pas un _ à la fin ? Met en majuscule, ca sera plus // simple donc. OCR1B = VITESSE_TURB_MAX_; /* vitesse turb av max */ OCR1C = VITESSE_TURB_MIN_; /* vitesse turb ar min */ /* initialisation sens rotation */ PORTB &= ~_BV(4); /* interruption autorisees INT7 INT6 INT5 INT4 à chaque changement logique */ EICRB = regv ( ISC71, ISC70, ISC61, ISC60, ISC51, ISC50, ISC41, ISC40, 1, 1, 1, 1, 0, 1, 0, 1); EIFR |= _BV(7) | _BV(6) | _BV(5) | _BV(4); EIMSK |= _BV(7) | _BV(6) | _BV(5) | _BV(4); /* initialisation de la position du barillet */ pos_prec_ = 0; // XXX penser a mettre le barillet avec un trou vers l'avant du robot XXX } /***************************** * fonction main du barillet * * ***************************/ /* A la fin du main */ // if ( rotation != 1 ) // // { // /* extraire une balle */ // extraction = 1; // /* deposer une balle */ // depose = 2; // /* appel pour une rotation */ // pos_a_aller = 4; // rotation = 1; // // // main_barillet(); // } /* fonction principale du barillet a apeller a la fin de la boucle principale du main */ void main_barillet(void) { /* rotation en cours */ if ( rotation_en_cours_ == EN_COURS ) // XXX a faire dans le main, ce sera plus simple { /* ne rien faire dans cette fonction et attendre que le barillet est fini de tourner */ } else if ( rotation == 1 ) { rotation_barillet( pos_a_aller ); } /* fonction pour l'extraction d'une balle */ else if ( inter_ar_ == MONTEE ) { if ( compteur_timer_ == 5 ) { extraction_fin(); /* fin de l'extraction */ } } else if ( extraction == EN_COURS ) { extraction_balle(); /* debut de l'extraction */ } else if ( depose == EN_COURS ) { depose_balle(); } /* fonction pou la gestion d'une montee de balle a l'avant */ else if ( etat_inter_av_ == MONTEE ) { if ( compteur_timer_ == 5 ) { new_balle(); } } } /* ********************** * ROTATION DU BARILLET * * **********************/ void rotation_barillet( uint8_t pos_a_aller ) { /* initialisation pour la rotation */ pos_final_ = ( pos_a_aller * 4 ); /* affecter le bon sens de rotation */ if ( ( ( ( (40 + pos_actuel_ - pos_final_) % 40 ) >= 20 && ( pos_final_ < 20 ) ) ) || ( ( ( (40 + pos_actuel_ - pos_final_) % 40 ) < 20 && ( pos_final_ > 20 ) ) ) ) { PORTB &= ~_BV(4); utils_delay_us ( DELAY_ ); } else // ( pos_final < 20 ) { PORTB |= _BV(4); utils_delay_us ( DELAY_ ); } vitesse_turbine ( 1,VITESSE_TURB_MIN_); /* tourner le barillet */ rotation_en_cours_ = EN_COURS; if ( ( ( ( 40 + pos_actuel_ - pos_final_) % 40 ) < 4 ) || ( ( ( 40 + pos_actuel_ - pos_final_) % 40 ) > 36 ) ) { OCR1A = VITESSE_BAR_MIN_; } else { OCR1A = VITESSE_BAR_MAX_; } } /* gestion de la position du barillet */ void pos_bar(void) { uint8_t pos_conc_; uint8_t pos_temp_; pos_temp_ = ( PINE >> 4) & 3; pos_conc_ = ( pos_temp_ << 2 ) | pos_prec_; switch ( pos_conc_ ) { case 1 : // 00 01 --pos_actuel_; break; case 2 : // 00 10 ++pos_actuel_; break; case 4 : // 01 00 ++pos_actuel_; break; case 7 : // 01 11 --pos_actuel_; break; case 8 : // 10 00 --pos_actuel_; break; case 11 : // 10 11 ++pos_actuel_; break; case 13 : // 11 01 ++pos_actuel_; break; case 14 : // 11 10 --pos_actuel_; break; } if ( ( ( 40 + pos_actuel_ - pos_final_ ) % 40 ) == 1 ) { OCR1A = VITESSE_BAR_MIN_; } else if ( ( ( 40 + pos_actuel_ - pos_final_ ) % 40 ) == 0 ) { OCR1A = 0; rotation_en_cours_ = TERMINE; vitesse_turbine ( 1, VITESSE_BAR_MAX_); rotation = 0; } pos_prec_ = pos_temp_; } /************************************** * CHANGEMENT DE VITESSE DES TURBINES * **************************************/ static void vitesse_turbine(uint8_t turbine, uint8_t vitesse) { if ( turbine == 1 ) { OCR1B = vitesse; } else if ( turbine == 2 ) { OCR1C = vitesse; } } /* ********************* * EXTRACTION DE BALLE * * *********************/ /* Si balle dans trou => Extraction */ void extraction_balle(void) { /* mode extraction */ etat_inter_ar_ = MONTEE; /* Ralentir la turbine avant */ vitesse_turbine( 1, VITESSE_TURB_MIN_); /* Vitesse max de la turbine arriere */ vitesse_turbine( 2, VITESSE_TURB_MAX_); } /* fin d'extration de balle a appeller si extraction_balle =1 et interrupt arriere =1 */ void extraction_fin(void) { /* Ralentir la vitesse de la turbine arriere pour la rotation */ vitesse_turbine( 2, VITESSE_TURB_MIN_); /* fin d'extraction */ extraction = TERMINE; } /****************** * DEPOT DE BALLE * * ****************/ /* deposer une balle dans un trou apres rotation */ void depose_balle(void) { /* attente de l'interruption */ etat_inter_ar_ = DESCENTE; /* vitesse turbine arriere nulle */ vitesse_turbine( 2, 0); } /* *********************** * MONTEE DE BALLE AVANT * * ***********************/ void new_balle(void) { /* baisser la vitesse de la turbine */ OCR1B = VITESSE_TURB_MIN_; if ( (PINE & 64 ) == 0 ) /* le Port E bit 6 est a 0 => plus de balle devant la barriere optique */ { /* faire tourner le barillet pour voir la couleur */ rotation_barillet( pos_prec_ + 8 ); } else if ( rotation_en_cours_ == TERMINE ) { /* XXX appel de la fonction pour lire la couleur de la balle */ /* ca y'ai, on a fini, remettre la variable etat_inter_av_ a 0 */ etat_inter_av_ = DESCENTE; } } /* *************** * INTERRUPTIONS * * ***************/ /* interruption fourche optique turbine avant */ SIGNAL ( SIG_INTERRUPT6 ) { etat_inter_av_ = MONTEE; compteur_timer_ = 0; } /* interruption fourche optique turbine arriere */ /* XXX attention car l'interruption est rapide et le barillet va commencer à tourner avant que * la balle soit arrivé */ SIGNAL ( SIG_INTERRUPT7 ) { if ( etat_inter_ar_ == MONTEE ) { inter_ar_ = MONTEE; compteur_timer_ = 0; } else if ( etat_inter_ar_ == DESCENTE ) { /* remettre la vitesse turbine a min */ vitesse_turbine( 2, VITESSE_TURB_MIN_); /* XXX verifier que la balle ne remonte pas */ /* XXX mettre une variable pour dire : OK, on peut avancer ??*/ } } /* interruption fourche optique barillet 1 */ SIGNAL ( SIG_INTERRUPT5 ) { pos_bar(); } /* interruption fourche optique barillet 1 */ SIGNAL ( SIG_INTERRUPT4 ) { pos_bar(); }