Go Down

Topic: fusion de 2 codes (Read 1 time) previous topic - next topic

danogena

Bonjour, j'ai 2 codes pour un ATmega 328

le 1er qui contrôle les relais
le second qui donne la température, je voudrais savoir si un copier/coller (avec changement de pin bien sur) puis un téléversement suffirait ou si on doit faire autrement.
code 1
Code: [Select]

#include <EEPROM.h>

int recepteurPin = 9; // Brancher le pin data du recepteur
int RPin[]={2, 3, 4, 5, 6, 7, 8, 10, 11, 12}; // Pin utilisés sur latmega (code radio 0 pin4, 1 pin 5 ect...
int ledPin = 13; // Peut servir de debugueur
int N = 123; // Code emetteur

struct config_t
{
  long sender;
  int receptor;
}
signal;

struct signal_t
{
  long sender;
  int receptor;
  boolean isSignal;
  boolean state;
}
receivedSignal;


void setup()
{
  pinMode(recepteurPin, INPUT);
 
  for (int i=0;i<=((sizeof(RPin))/(sizeof(int)));i++)
  {
    pinMode(RPin[i], OUTPUT);
  }
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  Serial.println("start");
  digitalWrite(ledPin,HIGH);
}


void loop()
{

  //Ecoute des signaux
  listenSignal();

  //Si un signal au protocol home easy est reçu...
  if(receivedSignal.isSignal){

      if (receivedSignal.sender==N){

      Serial.println("Signal correspondant");

      if(receivedSignal.state)
      {
        Serial.println("Etat : on, fermeture du relais");
        digitalWrite(RPin[receivedSignal.receptor],HIGH);
      }
      else
      {
        Serial.println("Etat : off, ouverture du relais");
        digitalWrite(RPin[receivedSignal.receptor],LOW);
      }
     
      blinkLed(1,50);

    }
    else{
      Serial.println("Signal inconnu");
      //La led clignotte 1 fois lentement  pour signaler que le signal est mauvais mais que le protocol est le bon
      blinkLed(10,10);
    }
  }

}


void blinkLed(int repeat,int time){
  for(int i =0;i<repeat;i++){
    digitalWrite(ledPin,LOW);
    delay(time);
    digitalWrite(ledPin,HIGH);
    delay(time);
  }
}


void listenSignal(){
  receivedSignal.sender = 0;
  receivedSignal.receptor = 0;
  receivedSignal.isSignal = false;

  int i = 0;
  unsigned long t = 0;

  byte prevBit = 0;
  byte bit = 0;

  unsigned long sender = 0;
  bool group = false;
  bool on = false;
  unsigned int recipient = 0;

  // latch 1
  while((t < 9200 || t > 11350))
  {
    t = pulseIn(recepteurPin, LOW, 1000000); 
  }
  Serial.println("latch 1");

  // latch 2
  while(t < 2550 || t > 2800)
  {
    t = pulseIn(recepteurPin, LOW, 1000000);
  }

  Serial.println("latch 2");

  // data
  while(i < 64)
  {
    t = pulseIn(recepteurPin, LOW, 1000000);

    if(t > 200 && t < 365)
    {
      bit = 0;

    }
    else if(t > 1000 && t < 1400)
    {
      bit = 1;

    }
    else
    {
      i = 0;
      break;
      Serial.println("bit mort"+t);
    }

    if(i % 2 == 1)
    {
      if((prevBit ^ bit) == 0)
      { // must be either 01 or 10, cannot be 00 or 11
        i = 0;
        break;
      }

      if(i < 53)
      { // first 26 data bits
        sender <<= 1;
        sender |= prevBit;
      }
      else if(i == 53)
      { // 26th data bit
        group = prevBit;
      }
      else if(i == 55)
      { // 27th data bit
        on = prevBit;
      }
      else
      { // last 4 data bits
        recipient <<= 1;
        recipient |= prevBit;
      }
    }

    prevBit = bit;
    ++i;
  }


  // interpret message
  if(i > 0)
  {
    receivedSignal.sender = sender;
    receivedSignal.receptor = recipient;
    receivedSignal.isSignal = true;
    if(on)
    {
      receivedSignal.state = true;
    }
    else{
      receivedSignal.state = false;
    }
  }
}



code 2
Code: [Select]
/*
* Code pour construction d'une sonde de temperature "maison", récupère une temperature et l'envois sur la fréquence de 433 mhz
* Fréquence : 433.92 mhz
* Protocole : Ridle (Radio Idle, protocole customisé basé sur home easy)
* Licence : CC -by -sa
* Matériel associé : Atmega 328 (+résonateur associé) + emetteur RF AM 433.92 mhz + capteur DS18B20 + led d'etat + résistance 4.7 kohms
* Auteur : Valentin CARRUESCO  aka idleman (idleman@idleman.fr - http://blog.idleman.fr)
*/

#include <OneWire.h>
#include <DallasTemperature.h>

//La sonde de température DS18B20 est branchée au pin 10 de l'atmega
#define TEMPERATURE_PIN 10
//L'émetteur radio 433 mhz est branché au pin 9 de l'atmega
#define TRANSMITTER_PIN 9

//Tableaud de stockage du signal binaire à envoyer
bool bit2[26]={};             


// On crée une instance de la classe oneWire pour communiquer avec le materiel on wire (dont le capteur ds18b20)
OneWire oneWire(TEMPERATURE_PIN);
//On passe la reference onewire à la classe DallasTemperature qui vas nous permettre de relever la temperature simplement
DallasTemperature sensors(&oneWire);

//Fonction lancée à l'initialisation du programme
void setup(void)
{
  //On definis les logs à 9600 bauds
  Serial.begin(9600);
  //On initialise le capteur de temperature
  sensors.begin();
  //On définis le pin relié à l'emetteur en tant que sortie
  pinMode(TRANSMITTER_PIN, OUTPUT);   
}

//Fonction qui boucle à l'infinis
void loop(void)
{

  //Lancement de la commande de récuperation de la temperature
  sensors.requestTemperatures();
  //Affichage de la temparature dans les logs
  Serial.println(sensors.getTempCByIndex(0)); 
  //Conversion de la temperature en binaire et stockage sur 7 bits dans le tableau bit2
  itob(sensors.getTempCByIndex(0),7);
  //Envois du signal radio comprenant la temperature (on l'envois 5 fois parce qu'on est pas des trompettes :p, et on veux être sûr que ça recoit bien)
  int i=0;
  for(i=0; i<5;i++)
  {
    transmit();
    delayMicroseconds(666);   
  }
  //delais de 5sc avant le prochain envois
  delay(5000);
}

//Fonction de tansmission radio
void transmit()
{

  // On envois 2 impulsions 1->0 avec un certain delais afin de signaler le départ du siganl( verrou de départ)
  //Initialisation radio à 1
  digitalWrite(TRANSMITTER_PIN, HIGH);
  delayMicroseconds(275);     
  //Verrou 1
  digitalWrite(TRANSMITTER_PIN, LOW);
  delayMicroseconds(9900);     
  digitalWrite(TRANSMITTER_PIN, HIGH);
  //Pause entre les verrous 
  delayMicroseconds(275);     
  //Verrou 2
  digitalWrite(TRANSMITTER_PIN, LOW);   
  delayMicroseconds(2675);
  // End on a high
  digitalWrite(TRANSMITTER_PIN, HIGH);

//On envois les 8 bits stockés dans le tableau bit2
int i;
for(i=0; i<8;i++)
{
    sendPair(bit2[i]);
}

//On envois le code de la sonde (1010 = code 10)
sendPair(true);
sendPair(false);
sendPair(true);
sendPair(false);

//On envois un verrou de fin pour signaler la fin du signal :)
  digitalWrite(TRANSMITTER_PIN, HIGH);   
  delayMicroseconds(275);     
  digitalWrite(TRANSMITTER_PIN, LOW); 

}

//Fonction d'envois d'un bit pure (0 ou 1)
void sendBit(boolean b) {
  if (b) {
    digitalWrite(TRANSMITTER_PIN, HIGH);
    delayMicroseconds(310);   //275 orinally, but tweaked.
    digitalWrite(TRANSMITTER_PIN, LOW);
    delayMicroseconds(2500);  //1225 orinally, but tweaked.
  }
  else {
    digitalWrite(TRANSMITTER_PIN, HIGH);
    delayMicroseconds(310);   //275 orinally, but tweaked.
    digitalWrite(TRANSMITTER_PIN, LOW);
    delayMicroseconds(1000);   //275 orinally, but tweaked.
  }
}

//Fonction d'envois d'un bit codé en manchester (0 = 01 et 1 = 10)
void sendPair(boolean b) {
  if(b)
  {
    sendBit(true);
    sendBit(false);
  }
  else
  {
  sendBit(false);
  sendBit(true);
  }
}

//fonction de conversion d'un nombre décimal "integer" en binaire sur "length" bits et stockage dans le tableau bit2
void itob(unsigned long integer, int length)

  int positive;
  if(integer>0){
   positive = true;
   Serial.println("positif ");
}else{
  positive = false;
   Serial.println("negatif ");
}
  //needs bit2[length]
  // Convert long device code into binary (stores in global bit2 array.)
for (int i=0; i<length; i++){
   if ((integer / power2(length-1-i))==1){
     integer-=power2(length-1-i);
     bit2[i]=1;
   }
   else bit2[i]=0;
}
//Définit le signe (+ ou -)
if(positive){
   bit2[length]=1;
}else{
   bit2[length]=0;
}
}

//Calcule 2^"power"
unsigned long power2(int power){   
unsigned long integer=1;         
for (int i=0; i<power; i++){     
   integer*=2;
}
return integer;
}

68tjs

Pour le "setup" a priori ce doit être possible puisque c'est là que ce font les configurations.
Bien vérifier quand même qu'il n'y a pas incohérence entre les deux "setup".

Pour la boucle infinie (-> loop) c'est peut-être possible mais personnellement je mettrais tout à plat en essayant de réaménager au mieux.

danogena

ok , mais je débute vraiment, (gros gros noob) je pense tester en mettant dans un "loop" toutes les commandes des 2 loop et on verra bien

merci de ta réponse en tous cas

68tjs

C'est un peu ce que je craignais : c'est deux bouts de programme tout fait que tu as trouvé et que tu veux rassembler.

Deux solutions :
La meilleure : cela ne marche pas -> tu sera obligé de comprendre les programmes qui ne sont pas bien compliqués.
La pire : cela tombe en marche par hasard et tu n'aura strictement rien appris.

skywodd

Bonjour,

+1 pour l'avis de 68tjs.

N'essaye pas de copier coller bêtement, tu n'y gagneras rien pour l'avenir et en plus c'est quasi sûr vu le code que ça ne marchera pas.
Les codes sont très spécialisés et d'un niveau technique assez élevé (ya des structures, du bitwise, ...) copier colle bêtement ne donnera rien de bon.

1) Défini ce que tu veut faire exactement
2) Réfléchi à ce que tu doit mettre en place pour y arriver
3) Fouille la doc C/C++ et Arduino où tu trouveras tout ce dont tu as besoin ;)
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

Rovhell

De toute façon, rien qu'à regarder l'attribution des pins de chaque code, y'a déjà conflit!

-Standby

Une solution assez simple c'est de prendre un code source reference et de l'écrire complètement a ta sauce, c'est comme sa que je procède pour bien comprendre le fonctionnement sinon comme dit plus haut sa abrutise..
The Mind is like a parachute it works best when opened.

Go Up