Revision 0:eac65d0c5a1c, committed 2016-06-15

Comitter:

Paolo804

Date:

Wed Jun 15 09:00:08 2016 +0000

Commit message:

Projet total V1

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fonctions_demodulation.cpp	Wed Jun 15 09:00:08 2016 +0000
@@ -0,0 +1,4 @@
+char decale_mot(char mot){ //Cette fonction effectue un décalage du mot de 1 cran vers la gauche
+    mot=((mot&0x7F)<<1)|((mot&0x80)>>7); 
+    return mot;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fonctions_demodulation.h	Wed Jun 15 09:00:08 2016 +0000
@@ -0,0 +1,1 @@
+char decale_mot(char mot);
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fonctions_distance.cpp	Wed Jun 15 09:00:08 2016 +0000
@@ -0,0 +1,134 @@
+#include <fonctions_distance.h>
+
+void init_tab_max(struct maximum tab[3], float acquisition){
+    int i;
+    for (i=0;i<3;i++){
+        tab[i].valeur=acquisition;
+        tab[i].indice=0;
+    }
+}
+
+void init_tab_min(struct minimum tab[3], float acquisition){
+    int i;
+    for(i=0;i<3;i++){
+        tab[i].valeur=acquisition;
+        tab[i].indice=0;
+    }
+}
+
+bool appartient_max(int i, struct maximum tab_max[3]){
+    int indice;
+    bool state;
+    state=false;
+    for(indice=0;indice<3;indice++){
+        if (tab_max[indice].indice == i) state = true;
+    }
+    return state;
+}
+
+
+bool appartient_min(int i, struct minimum tab_min[3]){
+    int indice;
+    bool state;
+    state=false;
+    for(indice=0;indice<3;indice++){
+        if (tab_min[indice].indice == i) state = true;
+    }
+    return state;
+}
+
+void have_max(float tab[NB_VALEURS], struct maximum tab_max[3]){
+    int i,j;
+    for(j=0;j<3;j++){
+        for(i=0;i<NB_VALEURS;i++){
+            if (tab_max[j].valeur < tab[i] && appartient_max(i, tab_max) != true){ //La valeur du tableau est supérieure et aucune autre case du tabelau de structure ne contient cette valeur;
+                tab_max[j].valeur=tab[i];
+                tab_max[j].indice=i;
+            }
+        }
+    }
+}
+
+void have_min(float tab[NB_VALEURS], struct minimum tab_min[3]){ // A modifier avec la rejection de valeur;
+    int i,j;
+    for(j=0;j<3;j++){
+        for(i=0;i<NB_VALEURS;i++){
+            if (tab_min[j].valeur > tab[i] && appartient_min(i, tab_min) != true){ 
+                tab_min[j].valeur=tab[i];
+                tab_min[j].indice=i;
+            }
+        }
+    }
+}
+
+//ALGO DETECTION DISTANCE
+float abs_minus(float a, float b){
+    float retour;
+    if ((a-b)>=0) retour = a-b;
+    else retour = b-a;
+    return retour;
+}
+
+void init_struct(struct signal_caracteristiques tableau){
+    tableau.indice_max=0;
+    tableau.indice_moyenne=0;
+    tableau.indice_ecart=0;
+    tableau.indice_rapport=0;
+}
+
+void verifff(struct distance signal, struct distance donnee[], struct signal_caracteristiques *signal_carac){
+    int i;
+    init_struct(*signal_carac);
+    for(i=1;i<9;i++){
+        if (abs_minus(signal.max, donnee[signal_carac->indice_max].max) > abs_minus(signal.max, donnee[i].max))signal_carac->indice_max=i;
+        if (abs_minus(signal.moyenne, donnee[signal_carac->indice_moyenne].moyenne) > abs_minus(signal.moyenne, donnee[i].moyenne))signal_carac->indice_moyenne=i;
+        if (abs_minus(signal.ecart, donnee[signal_carac->indice_ecart].ecart) > abs_minus(signal.ecart, donnee[i].ecart))signal_carac->indice_ecart=i;
+        if (abs_minus(signal.rapport, donnee[signal_carac->indice_rapport].rapport) > abs_minus(signal.rapport, donnee[i].rapport))signal_carac->indice_rapport=i;
+    }
+}
+
+void printf_SC(struct signal_caracteristiques sig){
+    printf("indice_max: %d\n", sig.indice_max);
+    printf("indice_moyenne: %d\n", sig.indice_moyenne);
+    printf("indice_ecart: %d\n", sig.indice_ecart);
+    printf("indice_rapport: %d\n", sig.indice_rapport);
+}
+
+int calcul_distance_V1(struct distance signal, struct distance donnee[], struct signal_caracteristiques caracteristiques){
+    int distance;
+    if (caracteristiques.indice_rapport < 3){
+        if (abs_minus(signal.rapport, donnee[0].rapport) <= abs_minus(signal.rapport, donnee[1].rapport)) distance = 20;
+        else {
+            if (abs_minus(signal.rapport, donnee[1].rapport) < abs_minus(signal.rapport, donnee[2].rapport)) distance = 30;
+            else distance = 40;
+        }
+    }
+    else{
+        if (abs_minus(signal.ecart, donnee[3].ecart) < abs_minus(signal.ecart, donnee[4].ecart)) distance = 50;
+        else {
+            if (signal.ecart < donnee[8].ecart) distance = 100;
+            else if (signal.ecart < donnee[7].ecart) distance = 90;
+            else if (signal.ecart < donnee[6].ecart) distance = 80;
+            else if (signal.ecart < donnee[5].ecart) distance = 70;
+            else distance = 60;
+        }
+    }
+    return distance;
+}
+
+float convert_indice(int indice){
+    return indice*10+20;
+}
+
+float calcul_distance_V2(struct distance signal, struct signal_caracteristiques caracteristiques){
+    float distance;
+    if(convert_indice(caracteristiques.indice_rapport) <= 40)
+        distance = convert_indice(caracteristiques.indice_rapport);
+    else if(convert_indice(caracteristiques.indice_ecart) == 100)
+        distance = 100;
+    else
+        distance = 0.5*convert_indice(caracteristiques.indice_rapport) + 0.5*convert_indice(caracteristiques.indice_ecart);
+    return distance;
+
+}
+//FIN ALGO DETECTION DISTANCE
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fonctions_distance.h	Wed Jun 15 09:00:08 2016 +0000
@@ -0,0 +1,59 @@
+#include "mbed.h"
+#define NB_VALEURS 280
+#define NB_VALEURS_BIT 36
+#define NB_VALEURS_MOYENNE_HAUTE 10
+
+
+struct distance{
+    float max;
+    float min;
+    float moyenne;
+    float ecart;
+    float rapport;
+};
+
+struct maximum{
+    float valeur;
+    int indice;
+};
+
+struct minimum{
+    float valeur;
+    int indice;
+};
+
+struct signal_caracteristiques{
+    int indice_max;
+    int indice_moyenne;
+    int indice_ecart;
+    int indice_rapport;
+};
+
+
+//Fonctions pour les paramètres distance
+void init_tab_max(struct maximum tab[3], float acquisition);
+
+void init_tab_min(struct minimum tab[3], float acquisition);
+
+bool appartient_max(int i, struct maximum tab_max[3]);
+
+bool appartient_min(int i, struct minimum tab_min[3]);
+
+void have_max(float tab[NB_VALEURS], struct maximum tab_max[3]);
+
+void have_min(float tab[NB_VALEURS], struct minimum tab_min[3]);
+
+//Fonctions de calcul de la distance
+float abs_minus(float a, float b);
+
+void init_struct(struct signal_caracteristiques tableau);
+
+void verifff(struct distance signal, struct distance donnee[], struct signal_caracteristiques *signal_carac);
+
+void printf_SC(struct signal_caracteristiques sig);
+
+int calcul_distance_V1(struct distance signal, struct distance donnee[], struct signal_caracteristiques caracteristiques);
+
+float convert_indice(int indice);
+
+float calcul_distance_V2(struct distance signal, struct signal_caracteristiques caracteristiques);
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Wed Jun 15 09:00:08 2016 +0000
@@ -0,0 +1,148 @@
+#include "mbed.h"
+#include <fonctions_demodulation.h>
+#include <fonctions_distance.h>
+
+
+AnalogIn adc(A0);
+
+int i,j,k;
+
+#define NB_VALEURS 280
+#define NB_VALEURS_BIT 36
+#define NB_VALEURS_MOYENNE_HAUTE 10
+
+float acquisition[NB_VALEURS];
+float acquisition_distance[NB_VALEURS]; 
+float seuil;
+
+//Déclarations pour la distance
+
+
+struct maximum valeur_max[3];
+struct minimum valeur_min[3];
+struct distance signal;
+struct signal_caracteristiques signal_car;
+//Valeurs 13 Juin : Mesure 1
+//struct distance donnee[]={{562,458,260,0.3999}, {559,430,260,0.49},{524,396,223,0.57},{458,367,160,0.6},{413,345,111,0.6},{380,330,82,0.6},{368,324,73,0.59},{354,318,56,0.62},{341,313,45,0.61}};
+
+//Valeurs 14 Juin : Mesure 2
+//struct distance donnee[]={{565,454,275,0.4}, {560,418,270,0.53},{433,349,143,0.58},{389,329,98,0.59},{360,317,72,0.61},{338,307,50,0.61},{324,303,34,0.61},{316,300,26.5,0.61},{313,299,13.5,0.61}};
+
+//Valeurs 14 Juin : Mesure 3 (2 47Ohm en parallèle)
+struct distance donnee[]={{563,497,256,0.25}, {563,460,263,0.39},{562,434,257,0.49},{538,402,234,0.58},{464,368,156,0.6},{425,352,118,0.62},{389,336,85,0.625},{375,329,71,0.64},{360,323,57,0.64}};
+
+
+int indice;
+float moyenne;
+//Fin déclarations pour la distance
+
+
+int main() {
+    char mot;
+    float moyenne;
+    mot=0x00;
+    while(1){
+        //Aquisition pour seuil_moyen
+        for(i=0; i< NB_VALEURS; i++){
+            acquisition[i]=adc.read();
+        }
+        seuil = 0;
+        for(i=0; i< NB_VALEURS; i++){
+            seuil += acquisition[i];
+        }
+        seuil /= NB_VALEURS;
+        
+        //Acquisition pour la démodulation
+        while(adc.read() > seuil);
+        while(adc.read() < seuil);
+        for(i=0; i< NB_VALEURS; i++){
+            acquisition[i]=adc.read();
+        }
+            //Reajustement du seuil :
+            float max[NB_VALEURS_MOYENNE_HAUTE][2];
+                //Moyenne des 1 :
+                for(i=0;i<NB_VALEURS_MOYENNE_HAUTE;i++){
+                    max[i][0] = 0; //initialisation des indices
+                    max[i][1] = acquisition[0]; //initialisation des max
+                }
+                char already_max=0;
+                for(i=0;i<NB_VALEURS_MOYENNE_HAUTE;i++){ //prise de 10 valeurs max
+                    for(j=0;j < NB_VALEURS;j++){
+                        for(k=0;k<i;k++){
+                            if(j == max[k][0]){
+                                already_max = 1;
+                                break;
+                            }
+                            else already_max = 0;
+                        }
+                        if(acquisition[j] > max[i][1] && !already_max){
+                             max[i][1] = acquisition[j];
+                             max[i][0] = j;
+                        }
+                    } 
+                }
+                float moyenne_haute = 0;
+                for(i=0;i<NB_VALEURS_MOYENNE_HAUTE;i++){
+                    moyenne_haute += max[i][1];
+                }
+                moyenne_haute /= NB_VALEURS_MOYENNE_HAUTE;
+                
+                //moyenne des 0;
+                
+        for (i=0; i<8; i++){
+            moyenne = 0;
+            for (j=0;j<NB_VALEURS_BIT;j++){
+                moyenne += acquisition[i*NB_VALEURS_BIT + j]; 
+            }
+            moyenne /= NB_VALEURS_BIT;
+            mot |= (moyenne > seuil)?0x01:0x00;
+            if (i == 7) break;
+            mot = mot << 1;
+        }
+
+        for (i=0; i<8; i++){
+            mot = decale_mot(mot);
+            if(mot == 0xAC){
+                printf("Mot present\n");
+                break;
+            }
+        }
+        
+        //----------------------
+        //MESURE DISTANCE
+        //----------------------
+        for(i=0;i<NB_VALEURS;i++){
+            acquisition_distance[i] = acquisition[i]*1000;
+        }
+        for(i=0;i<NB_VALEURS;i++){
+            moyenne += acquisition_distance[i];
+        }
+        moyenne /= NB_VALEURS;
+        signal.moyenne=moyenne;
+        init_tab_max(valeur_max, acquisition_distance[0]);
+        init_tab_min(valeur_min, acquisition_distance[0]);
+        have_max(acquisition_distance, valeur_max);
+        signal.max = (valeur_max[0].valeur+valeur_max[1].valeur+valeur_max[2].valeur)/3;
+        have_min(acquisition_distance, valeur_min);
+        signal.min=(valeur_min[0].valeur+valeur_min[1].valeur+valeur_min[2].valeur)/3;
+        signal.ecart=signal.max-signal.min;
+        signal.rapport=(signal.max-signal.moyenne)/signal.ecart;
+        printf("signal.max: %f\n", signal.max);
+        printf("signal.min: %f\n", signal.min);
+        printf("signal.moyenne: %f\n", signal.moyenne);
+        printf("signal.ecart: %f\n", signal.ecart);
+        printf("signal.rapport: %f\n", signal.rapport);
+        
+        init_struct(signal_car);
+        verifff(signal, donnee, &signal_car);
+        printf_SC(signal_car);
+        printf("Distance : %f\n", calcul_distance_V2(signal, signal_car));
+        
+        
+        //----------------------
+        //FIN MESURE DISTANCE
+        //----------------------
+        
+        wait(0.5);
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Wed Jun 15 09:00:08 2016 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/6c34061e7c34
\ No newline at end of file