MiGaNuTs's Blog

le code de l'arduino

#include  // necessaire pour pouvoir appeller une fonction toutes les x ms

#define DEBUG1 // je sait plus a quoi ca sert :D
//#define DEBUG2 // le mode debug 2 ecrit l'etat des 8 leds en binaire sur le port serie
//#define DEBUG3 // le mode debug 3 ecrit la tension du flash sur le port serie


const int led=13;// led de visualisation du temps passé dans l'interruption, pour l'oscillo.

volatile int tensionflash = 0; // definie en tps que globale pour pas declancher les thyristors
                               // si pas de jus
const int pattetension = A0;
const int pattepwm = 9; // patte 9 ou 10 car ca permets de changer le frequence du pwm sans mettre le dawa
                  // dans les timings de l'interruption ni dans la fonction delay (enfin, normalement. a tester a l'oscillo)

void setup()   { 
  pinMode(led, OUTPUT);
  pinMode(pattepwm, OUTPUT);
  
  /*Pins 9 and 10:
  Setting	Divisor	Frequency
  0x01	1	31250
  0x02	8	3906.25
  0x03	64	488.28125
  0x04	256	122.0703125
  0x05	1024	30.517578125
  TCCR1B = TCCR1B & 0b11111000 | ;
  */
  TCCR1B = TCCR1B & 0b11111000|0x01;
    
  MsTimer2::set(1, InterruptTimer2); // appelle l'interruption toutes les x ms 
  MsTimer2::start(); // active Timer 2
  #if defined(DEBUG1) || defined (DEBUG2) || defined (DEBUG3) || defined (DEBUG4) || defined (DEBUG5)
    Serial.begin(115200);  // pour debug via l'usb
  #endif
}

void loop (){
  unsigned int machin=0;
  while (1){
    machin=analogRead(pattetension);
    Serial.print(machin,DEC);
    Serial.print("\n");
    if ((machin<50)||(machin>595)) {delay (12);} // reduit le debit des trucs sur le port serie
    delay (3);
    }
}

void InterruptTimer2() { 
  const int seuiltension = 600; // consigne de tension de charge des condos
                                // 800 : 383v sur les condos, 3,9v sur l'entrée
                                // 400 : 191 v et 1,96v sur l'entrée
                                // 700 : 338 et 3,42
                                // 600 : 290 et 2,93
                                
  const int seuiltensionmini=350; // tension de "softstart"
  const int pwnmini=100; // ratio de softstart
  const int pwnregul= 175; // il faut environ 10 us pour couper le courant dans la transfo.
                          // la periode du pwm est de 32 us (environ)
                          // (255/32)*(32-10) = 175,3
  const int pwnmaxi = 180; // ratio utilisé dans la phase on l'on "booste" la charge a la barbare :D
                          
  int ratiopwm;
  digitalWrite(led, HIGH); //on allume la led pour montrer qu'on est dans la boucle d'interruption
  tensionflash=analogRead(pattetension);
  if (tensionflashseuiltension) { //coupure de la charge
      analogWrite(pattepwm,0);digitalWrite(led,LOW); return; }
  
  analogWrite(pattepwm,pwnregul);
  digitalWrite(led,LOW); // on coupe la led pour montrer qu'on a rendu la main.
                         // nickel pour un debug a l'oscilloscope

}

Le code processing coté mac

// Programme processing
// généré avec le générateur de code Processing
// X. HINAULT - Janvier 2011 - tous droits réservés

/////////////// Description du programme //////////// 
// Utilise le port Serie
// Utilise une police texte

/////////////// ENTETE DECLARATIVE //////////// 

// inclusion des librairies utilisées 

import processing.serial.*; // importe la librairie série processing

// déclaration objets 

// --- port Série --- 
Serial  myPort; // Création objet désignant le port série

// --- police texte --- 
PFont fontA; // crée un objet de police texte 

// déclaration variables globales 
 int xPos = 1;         // variable abscisse  - x
 int xPos0=1;       // variable mémorisation xPos n-1

float yPos=1;  // variable yPos - ordonnée
float yPos0=1; // variable yPos n-1

 int xTextPos=50; // variable position texte dans la fenêtre
 int yTextPos=50; 


/////////////// Fonction SETUP //////////// 

void setup(){ // fonction d'initialisation exécutée 1 fois au démarrage

        // ---- initialisation paramètres graphiques utilisés
        colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc...
        fill(0,0,255); // couleur remplissage RGB
        stroke (0,255,0); // couleur pourtour RGB
        strokeWeight(1); // largeur du trait en pixels
        rectMode(CORNER); // origine rectangle coin sup gauche 

        // --- initialisation fenêtre de base --- 
        //size(200, 200); // ouvre une fenêtre xpixels  x ypixels
         size(int(screen.width*0.65), int(screen.height*0.6));        
        // 90% de l'écran par défaut - régler au besoin - 
        // viser taille maxi en hauteur - taille fenêtre (x,y)

        background(0,0,0); // fond fenetre en noir

// --- initialisation des fonctionnalités utilisées --- 

        //------------- initialisation de la police texte - à mettre avant série ---- 
        fontA = loadFont("HoboStd-20.vlw"); // charge le fichier police dans l'objet police texte
        // ce fichier doit être présent dans un rép  dans le répertoire du programme 
        // pour générer un fichier de police à partir des polices système aller dans Tools > create Fonts
        // voir également http://processing.org/learning/text/ 

        textFont(fontA, 20); // Initialise la police et sa taille (en pixels)




        //------------- initialisation port série ---- 
        println(Serial.list()); // affiche dans la console la liste des ports séries
        //myPort = new Serial(this, Serial.list()[1], 115200); // Initialise une nouvelle instance du port Série
        myPort = new Serial(this, "/dev/cu.usbmodem1d11", 115200); // Initialise une nouvelle instance du port Série
        myPort.bufferUntil('\n'); // attendre arrivée d'un saut de ligne pour générer évènement série

         //------- tracé initial ---------

        //traceInitial(); 

    } // fin fonction Setup

/////////////// Fonction Draw //////////// 

void  draw() { // fonction exécutée en boucle


        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

/////////////// Autres Fonctions //////////// 

        //------------- Fonction de gestion des évènements série ---- 
         void serialEvent (Serial myPort) { // fonction appelée lors de la survenue d'un évènement série

        // ******** Gestion de la valeur reçue sur le port série : **********

        String inString = myPort.readStringUntil('\n'); // chaine stockant la chaîne reçue sur le port Série 
        // saut de ligne en marque de fin

        if (inString != null) { // si la chaine recue n'est pas vide

                inString = trim(inString); // enlève espace blancs de la chaine recue
                int inByte_brut=int(inString); // conversion valeur reçue en valeur numérique entiere
                float inByte = float(inString); // conversion valeur reçue en valeur numérique décimale

                // ré-échelonne la valeur pour affichage
                 inByte = map(inByte, 0, 1023, 0, height);

                 yPos=inByte; // l'ordonnée est la valeur reçue par le port série

                //********** affichage numérique de la valeur reçue et autres calculs *****

                 //---- calcul de la tension à afficher --------
                 float tension=float(inByte_brut); 
                 tension=tension*5000;
                 tension=tension/1023;

                // dessin d'un rectangle sous le texte avant affichage pour effacer texte précédent
                 fill(0,0,0); // couleur de remplissage idem fond
                 stroke(255,0,0); // fixe la couleur utilisée pour le tracé en RVB 
                 rect(40, 20, 200, 50);

                  // Use fill() to change the value or color of the text
                  fill(255,0,0);
                  text("         ", xTextPos, yTextPos); //efface la valeur précédente
                  //text(inByte_brut, xTextPos, yTextPos);
                 text(inString+" Pts", xTextPos, yTextPos);

                //*********** gestion du graphique *********

                 // trace la ligne
                 stroke (0,0,0);
                 strokeWeight(1);
                 rect (xPos0,0,3,height);
                 
                 
                 stroke(0,255,255); // fixe la couleur utilisée pour le tracé en RVB 
                 strokeWeight(2); // largeur du trait en pixels
                 line (xPos0,height-yPos0,xPos,height-yPos); // trace une ligne en tenant compte valeur reçue

                 xPos0=xPos; // mémorisation xPos n-1
                 yPos0=yPos; // mémorisation xPos n-1

                 // à la fin de l'écran revient au début
                 if (xPos >= width) {
                   xPos = 0;
                   xPos0=0; // pour retour de la trace sans ligne

                   //background(0,0,0); // couleur du fond


        //------- tracé initial ---------

        //traceInitial(); 

              }  // fin RAZ graphique

                 else {
                 // incrémente la position horizontale (abscisse)
                 xPos++;
                  }


        } // fin condition chaine recue pas vide


} // fin de la fonction de gestion des évènements Série

// ----- mémo fonctions processing -------