Version actuelle datée du 30 mai 2016 à 07:01

Sommaire

1 Projet ER Semestre 3 : BATAK
2 Fabrication de la carte
3 Présentation du la connexion via le bus I2C
4 (Cahier des charges)
- 4.1 Conception
  - 4.1.1 Entrées/Sorties
- 4.2 Documents ressources
5 Etudes préliminaires
6 Présentation du bouton batak
- 6.1 Le bouton(cahier des charges)
- 6.2 Schematic(s) et board(s)
  - 6.2.1 Version 1
  - 6.2.2 Version 2
7 Tests
8 Utilisation de Charly robot pour détourage/perçage
- 8.1 Préparation des fichiers sur eagle
  - 8.1.1 Pour le contour
  - 8.1.2 Perçage
- 8.2 Préparer le fichier "charlyRobot" avec Target
9 Raspberry Pi 2
10 Annexes

Projet ER Semestre 3 : BATAK

Présentation

Dans le cadre de notre projet ER du semestre 3, nous allons réaliser le projet 'BATAK', en association avec le département GMP. Ce projet Batak est un outil de d'entraînement reposant sur une série de boutons comportant des LEDs. L’utilisateur doit appuyer sur les boutons lorsque ceux-ci sont allumés dans les plus bref délais. Cela permet d'évaluer ou d’entraîner la rapidité de réflexe des de l'utilisateur. C'est un outil particulièrement intéressant dans les milieux sportifs, prenant en charge de nombreux disciplines: arts martiaux, football, handball ... Nous nous focaliseront essentiellement sur la conception du bouton lumineux ainsi de la partie programmation de ces boutons et une interface graphique (C, Java ...).

Principe de fonctionnement

Le dispositif est organisé autour d'un panneau réalisant l'interface homme-machine et d'un système de calcul. L'ensemble est alimenté par le secteur 230V AC / 50Hz.

L'interface homme-machine se compose de 2 parties:

La première partie est un panneau comportant des boutons poussoirs associés à des voyants lumineux initialement éteints. Lorsqu'un voyant lumineux est allumé, le joueur doit appuyer sur le bouton poussoir correspondant dans les meilleurs délais. Physiquement, les ensembles bouton-voyant, au nombre de 12, sont répartis, sur le panneau d'environ 2m de largeur et 1m80 de hauteur, pour former une matrice 4x3.
La seconde partie de l'interface homme-machine est un dispositif d'affichage pour informer le joueur sur le test en cours ou réalisé. L'affichage est placé sur le panneau, par exemple, au-dessus de la matrice de bouton-voyant. On envisage un affichage à base d'afficheurs 7 segments réalisés par des leds.

Le système de calcul constitue la partie commande du dispositif. Il permet de gérer l'allumage, au choix ou aléatoirement, d'un voyant parmi les 12, de vérifier l'enfoncement du bouton poussoir correspondant et de piloter le système d'affichage. Par ailleurs, il permettra de compter le nombre de boutons poussoirs enfoncés, de compter le temps, ...Ainsi, le système de calcul, via ces diverses possibilités de comptage, autorisera plusieurs modes de jeu ( ou types de test). On peut déjà imaginer 2 modes :

tester, sur une durée donnée, la capacité du joueur à enfoncer un maximum de boutons.
tester la durée nécessaire au joueur pour enfoncer un nombre de voyants allumés donné.

Quel que soit le mode de jeu retenu, la mesure du temps est nécessaire et l'on pourra par exemple retenir le meilleur temps de réponse, le plus mauvais,... Mieux encore, on peut envisager de mener des statistiques sur les performances d'un joueur ( progression de ses résultats, analyse des zones où il est le plus/le moins réactif, ... ) et pourquoi pas, lui préparer un programme de tests spécifiques pour améliorer ses capacités. Cette simple évocation de différents modes de jeu/test possibles ouvre la porte à l'imagination. Le système de calcul, basé sur un processeur, doit simplement être suffisamment puissant pour être capable de stocker en mémoire un programme toujours plus volumineux et enregistrer des résultats toujours plus nombreux. Dans une perspective plus éloignée, on pourrait imaginer une liaison vers un PC qui enregistrerait les résultats de nombreux joueurs si le système de calcul reste limité à la gestion du jeu lui-même et pas à l'exploitation plus sophistiquée des résultats.

La figure ci-dessous présente le dessin de principe énoncé ci-dessus :

Diagramme de Gantt

Fabrication de la carte

Vérifications préliminaires

Avant d’effectuer toute opération sur le circuit imprimé, il est nécessaire de vérifier que le circuit soit en bon état.

Vérification des pistes

à l’œil nu (pistes fusionnées avec d’autres ou piste coupés)
avec appareil permettant de mesurer la conductivité des différents pôles des pistes (multimètre...)

Mise en place des composants CMS

En suivant le schematic et le board sous eagle il faut :
- Déposer de la pâte à braser sur les pattes du circuit imprimé
- Déposer les composants CMS aux endroits appropriés
- Passer le circuit dans le four
- Recommencer pour l’autre face.

Soudures

Soudure des vias

Lorsque les composants CMS ont été déposés il sera nécessaire de souder les différents vias.
Pour cela nous devons :
- Introduire un fil de cuivre de diamètre approprié dans les vias
- Souder des deux côtes à l’aide d’étain et d’un fer à souder

Soudure des composants traversants

-Soudure des derniers composants traversant à l’aide d’étain et de fer à souder

Perçage, découpage et soudure

Utilisation de perceuse avoir des forets de différents diamètres:

- 1mm pour capteurs et connecteurs
- 0,6 et 0,8 mm pour les vias
- Utilisation de charlyrobot pour le découpage de la carte mais aussi perçage dans certains cas
- Utilisation de cisaille pour finir de découper la carte
- pour les vias: on prend un fil que l'on dénude, on le découpe pour qu'il soit à la largeur de la carte
- Une fois inséré dans le trou on soude des deux cotés pour le maintenir
- Soudure avec un fil d'étain pour relier les vias (avec un fer à souder)
-on soude quelques composants avec de la pâte à braser pour les composants cms
- pour ajuster la taille de la carte on utilise des cisailles

Présentation du la connexion via le bus I2C

Avec la documentation du mcp23008 on connecte le SCL au pin A5 et SDA à A4.

SDA= ligne de données bidirectionnelle (Serial Data Line)

SCL= ligne d’horloge de synchronisation bidirectionnelle (Serial Clock line)

Il faut utiliser des connecteurs MOLEX à 4 bornes, voir ci-dessous pour description :

N° de patte	Fonction	Nom	Connection Arduino
1	SCL	Serial Clock line	A5 (entrée analogique)
2	SDA	Serial Data Line	A4 (entrée analogique)
3	GND	Masse	GND
4	VCC	Alimentation	5V ou 3.3V

Codage des bits

Le codage utilisé est de type NRZ (non retour à 0) :

Le niveau (« HIGH » ou « LOW ») de la ligne SDA doit être maintenu stable pendant le niveau « HIGH » sur la ligne SCL pour la lecture du bit.

SDA et SCL vu par oscilloscope

(Cahier des charges)

Le dispositif complet sera développé par parties constituant divers projets menés de front. Cependant, toute l'électronique ne sera pas développée dans ce projet, notamment le système de calcul. La carte processeur a été choisie préalablement et un certain nombre de contraintes en découle. Ainsi, le système de calcul reposera sur une carte Arduino. A contrario, si la carte Arduino n'est pas matériellement développée dans ce projet par les étudiants, elle sera programmée, le cas échéant, par leurs soins pour permettre de tester telle ou telle partie. On propose le découpage fonctionnel suivant qui génère de fait les divers projets :

Pour la première partie de l'interface homme-machine, il existe un panneau disposant de boutons intégrant des lampes. Ce panneau pourra être utilisé tel quel pour le projet Batak global, notamment pour tester les différents systèmes de calcul et d'affichage. Cependant, le projet comporte une partie consistant à développer un bouton poussoir intégré et spécifique.
Pour l'affichage, le choix est de développer des afficheurs 7 segments dont chacun des segments sera "dessiné" par une série de quelques leds alignées. On y ajoutera quelques leds supplémentaires qui donneront des indications sur le mode de jeu choisi par exemple. Une carte d'affichage sera donc ainsi conçue et produite.

-Une carte d'alimentation sera conçue et produite pour desservir en énergie les différentes cartes du système à partir de l'alimentation secteur.
-Une carte d'adaptation de puissance sera conçue et produite pour permettre d'interfacer les bouton/voyant au système de calcul.
-Une carte dite "CPLD" sera conçue et produite pour adapter (en terme de nombre d'entrées/sorties et pas en terme de puissance cette fois) la carte Arduino au panneau de boutons/voyants.

Conception

Entrées/Sorties

Il s'agira de fabriquer une carte électronique qui servira de support aux différents composants et qui permettra de venir facilement connecter le bouton au système entier.
Cette carte (qui pourra être composée de plusieurs parties) proposera un connecteur permettant d'avoir les signaux suivants :

Alimentation
- +5V DC (ou +3.3V)
- GND
I2C
- horloge SCL
- donnée SDA

Documents ressources

Ce découpage fonctionnel ainsi obtenu, les pages suivantes détaillent plus avant chacune des fonctions à développer et constituent le document de référence de chaque binôme pour développer sa propre partie. Cependant il sera intéressant de consulter les pages des autres projets puisque tous les projets sont liés.

Les dimensions des cartes sont imposées afin de correspondre au cahier des charges imposé pour la fabrication mécanique des boutons. Les fichiers suivants contiennent principalement le contour des cartes :

Etudes préliminaires

Dans un premier temps il convient de choisir et de tester la valeur des résistances et la disposition de LEDs que l’on va utiliser pour le bouton lumineux.

Choix des résistances

Pour choisir la bonne valeur de résistance, il faut connaître les valeurs normalisées des résistances.

Valeurs normalisées des résistances: (12 valeurs par décade)

Calcul résistance pour LEDs (carte voyant)

Calcul résistance pour LEDs (carte capteur)

De même pour la LED infrarouge on utilise la même méthode de calcul
Pour le choix de la résistance pour le transistor, il suffit de tester des valeurs de résistances élevées et constater une grande variation de valeur compris entre 0 et 1023

Choix branchements des LEDs

Il y a deux façons de brancher les LEDs :

Anode commune
Cathode commune

Anode commune

Lorsque les LEDs sont disposé en anode communes, il faudra envoyer un 0 à la Bit correspondant pour allumer la LED spécifique.

Cathode commune

Lorsque les LEDs sont disposé en cathode communes, il faudra envoyer un 1 à la Bit correspondant pour allumer la LED spécifique.

Choix pour branchement avec entrées analogiques du MCP23008

Première solution: utilisation de switch

Avant de s’attaquer au schématic il faut noter la particularité du MCP23008. En effet, afin de pouvoir piloter plusieurs cartes simultanément, il est nécessaire d’identifier chaque carte par une « adresse ». Cette adresse est inscrite dans le mcp23008 et peut être modifié à tout moment par des dispositifs différents consistant à mettre un 0 ou 1 aux pins correspondants. On peut noter que la valeur des résistances est très élevée (100kΩ) pour empêcher que le courant passe au GND lorsque l'on veut fermé l'interrupteur. (Le courant passe par le chemin le moins « difficile »).

Deuxième solution: utilisation de résistances

Dans ce cas on utilisera des résistances 0Ω et 100kΩ pour définir l'adresse

Troisième solution: utilisation de jumpers

la patte 1 est branché au VCC (Alimentation)
la patte 2 est relié a Ax c'est-à-dire à l'adresse
la patte 3 est relié au GND (masse)

Étude du CNY70

Légende:

K: Cathode
A: Anode
C: Collecteur
E: Émetteur
D: Détecteur

Le photocoupleur (capeur) CNY70 est composé d'un phototransistor et d'une diode infrarouge.
La LED infrarouge émet un signal et le transistor détecte la réponse.

Présentation du bouton batak

Le bouton(cahier des charges)

Le système d'entraînement de type Batak est composé de 12 boutons. Chacun de ces boutons est "lumineux" et doit pouvoir afficher 3 couleurs différents rouge/orange/vert. Le système mécanique prévoit 9 emplacements pour des leds 5mm.La détection de la position du bouton sera basée sur l'utilisation d'un photocoupleur par réflexion : la partie mobile du bouton présentant un coefficient de réflexion différent du corps du bouton, la lumière réfléchie a une intensité différente suivant sa position.
Alimenté en +5/-5 Le bouton comportera deux cartes électroniques :

la première carte comporte le MCP23008 assurant la commande des LEDs et du photocoupleur - les résistances - LEDs lumineux.
la seconde carte comporte le le photocoupleur CNY et le bus i2c

Détection de la position du bouton

Nous utiliserons un photocoupleur CNY70 pour détecter la position. Vous devrez proposer et valider par des tests une structure permettant d'obtenir un signal logique représentant cette position.
Il conviendra pour se faire d'utiliser un comparateur ou une porte logique (de préférence triggerisée).

Fabrication

La contrainte principale de la carte tient dans sa forme. Vous devrez ajuster très précisément à la fois le contour, mais également la position des leds et du photocoupleur. Si la carte est en plusieurs morceaux, il conviendra de proposer une solution à la fois résistante et peu coûteuse d'assemblage.
La partie perçage et détourage sera nécessairement réalisée en utilisant une fraiseuse numérique

Première version de la carte

Nomenclature: carte capteur

-1 résistance 47kΩ
-1 résistance 330Ω
-un capteur CNY70
-1 connecteur molex bus I2C (mâle)

Nomenclature: carte voyant

-3 leds jaunes
-3 leds vertes
-3 leds rouges
-1 MCP23008
-3 résistances de 0Ω
-9 résistances 470Ω (possibilité de 280Ω)

Tableau de transcodage

pour allumer une led il faut mettre '1'
pour éteindre une led il faut mettre '0'
exemple pour tout éteindre: 0x00

-GP1 LED Jaune 0x02 (0b00000010)
-GP2 LED Verte 0x04 (0b00000100)
-GP7 LED Rouge 0x80 (0b10000000)
-GP0 CNY 0x01 (0b00000001)

Deuxième version de la carte

Nomenclature: carte capteur

-1 résistance 560kΩ
-1 résistance 270Ω
-un capteur CNY70
-1 connecteur molex bus I2C (mâle)

Nomenclature: carte voyant

-3 leds jaunes
-3 leds vertes
-3 leds rouges
-1 MCP23008
-4 résistances de 0Ω
-9 résistances 270Ω
-3 jumpers

Tableau de transcodage

pour allumer une led il faut mettre '0'
pour éteindre une led il faut mettre '1'
exemple pour tout éteindre: 0xFF

-GP0 LED Jaune 0xFE (0b11111110)
-GP2 LED Verte 0xFB (0b11111011)
-GP1 LED Rouge 0xFD (0b11111101)
-GP4 CNY 0xEF (0b11101111)

Schematic(s) et board(s)

Version 1

Schematic carte voyant version 1

Board carte voyant version 1

Schematic carte capteur version 1

Board carte capteur version 1

Version 2

Schematic carte voyant version 2

Board carte voyant version 2

Schematic carte capteur version 2

Board carte capteur version 2

Tests

Programmation

Afin de pouvoir programmer la carte et le bus mcp28003, ll est nécessaire de télécharger le librairie Arduino correspondant. Cette librairie permet alors de commander les bus avec des fonctions spécifique tout en prenant en compte de ces différents adresses après avoir été branché avec le connecteur I2C:

#include <Wire.h>

#include "Adafruit_MCP23008.h"

Cette commande permet d’inclure la libraire Arduino pour le mcp28003.

mcp.begin(1);

Cette commande permet de choisir/démarer la carte avec son adresse que l’on souhaite programmer

mcp.writeGPIO(...); // adresse sur 7bits

Cette fonction indique l’état des bit pour allumer les segments de l’afficheur.

/*************************************************** 
  This is a library for the MCP23008 i2c port expander
  These displays use I2C to communicate, 2 pins are required to  
  interface
  Adafruit invests time and resources providing this open source code, 
  please support Adafruit and open-source hardware by purchasing 
  products from Adafruit!
  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#ifndef _ADAFRUIT_MCP23008_H
#define _ADAFRUIT_MCP23008_H
// Don't forget the Wire library
#ifdef __AVR_ATtiny85__
  #include <TinyWireM.h>
#else
  #include <Wire.h>
#endif

class Adafruit_MCP23008 {
public:
  void begin(uint8_t addr); // adresse
  void begin(void);

  void pinMode(uint8_t p, uint8_t d); // déclaration entrée/sorties
  void digitalWrite(uint8_t p, uint8_t d); // 1 par 1
  void pullUp(uint8_t p, uint8_t d);
  uint8_t digitalRead(uint8_t p); // 1 par 1 //allumage led
  uint8_t readGPIO(void); //global
  void writeGPIO(uint8_t); //global //lire valeur capteur

 private:
  uint8_t i2caddr;
  uint8_t read8(uint8_t addr);
  void write8(uint8_t addr, uint8_t data);
};

#define MCP23008_ADDRESS 0x20

// registers
#define MCP23008_IODIR 0x00
#define MCP23008_IPOL 0x01
#define MCP23008_GPINTEN 0x02
#define MCP23008_DEFVAL 0x03
#define MCP23008_INTCON 0x04
#define MCP23008_IOCON 0x05
#define MCP23008_GPPU 0x06
#define MCP23008_INTF 0x07
#define MCP23008_INTCAP 0x08
#define MCP23008_GPIO 0x09
#define MCP23008_OLAT 0x0A

#endif

Pour programmer on peut utiliser la méthode globale ou un par un

Programme de scan d’adresse

Pour choisir une carte, il faut d’abord connaître son adresse inscrit dans le MCP23008
Pour cela un programme permet alors de détecter l’adresse de la carte :

// --------------------------------------
// i2c_scanner
//
// This program (or code that looks like it)
// can be found in many places.
// For example on the Arduino.cc forum.
// The original author is not know.
//
// This sketch tests the standard 7-bit addresses
// from 0 to 127. Devices with higher bit address
// might not be seen properly.
//
// Adapted to be as simple as possible by Arduino.cc user Krodal
//
// June 2012
// Using Arduino 1.0.1
//

#include <Wire.h>

void setup()

{

Wire.begin();

Serial.begin(9600);

Serial.println("\nI2C Scanner");

}

void loop()

{

byte error, address;

int nDevices;

Serial.println("Scanning...");

nDevices = 0;

for(address = 0; address <= 127; address++ )

{

// The i2c_scanner uses the return value of

// the Write.endTransmisstion to see if

// a device did acknowledge to the address.

Wire.beginTransmission(address);

error = Wire.endTransmission();

if (error == 0)

{

Serial.print("I2C device found at address 0x");

if (address<16)

Serial.print("0");

Serial.print(address,HEX);

Serial.println(" !");

nDevices++;

}

else if (error==4)

{

Serial.print("Unknow error at address 0x");

if (address<16)

Serial.print("0");

Serial.println(address,HEX);

} 

}

if (nDevices == 0)

Serial.println("No I2C devices found\n");

else

Serial.println("done\n");

delay(500); // wait 8 seconds for next scan

}

Test batak version 1

//ajout des librairies
#include <Wire.h>
#include <Adafruit_MCP23008.h>

Adafruit_MCP23008 mcp;

float cny;

void setup() {

  // adressedu bus
  Serial.begin(9600);
  mcp.begin(3); // Utilisation de l'adresse "0" par défaut
  // on choisit 3 car après le scan i2c l'adresse est 0x23

  // E/S

  mcp.pinMode(0, INPUT); // mise en entrée
  //capteur cny70
  mcp.pinMode(1, OUTPUT);//mise en sortie
  //led jaune
  mcp.pinMode(2, OUTPUT);
  //led verte
  mcp.pinMode(7, OUTPUT);
  //led rouge
  //initialisation
  Serial.println ("step 1");

}

void loop() {

  
  mcp.writeGPIO(0x80);// on
  //led rouge
  Serial.println ("led rouge A");
  delay(500);

  mcp.writeGPIO(0x00);// off
  Serial.println ("led  rouge E");
  delay(500);
  
  mcp.writeGPIO(0x02);// on 
  //led jaune
  Serial.println ("led  jaune A");
  delay(500);

  mcp.writeGPIO(0x00);// off
  Serial.println ("led  jaune E");
  delay(500);
  
  mcp.writeGPIO(0x04);// on 
  //led verte
  Serial.println ("led  verte A");
  delay(500);

  mcp.writeGPIO(0x00);// off
  Serial.println ("led  verte E");
  delay(500); 


    cny= mcp.digitalRead(0);
if (cny >500)
    { Serial.println("0");}
    else {  Serial.println(" 1");}



    Serial.print(" valeur cny70 : ");
    Serial.print(cny,DEC);
      delay(1000);
 
}

Test batak version 2

//ajout des librairies
#include <Wire.h>
#include <Adafruit_MCP23008.h>
 
Adafruit_MCP23008 mcp;
 
float cny;
 
void setup() {
 
  // adresse du bus
  Serial.begin(9600);
  mcp.begin(7); // Utilisation de l'adresse "0" par défaut
  // on choisit 7 car après le scan i2c l'adresse est 0x027
 
  // E/S
 
  mcp.pinMode(4, INPUT); // mise en entrée
  //capteur cny70
  mcp.pinMode(0, OUTPUT);//mise en sortie
  //led jaune
  mcp.pinMode(1, OUTPUT);
  //led verte
  mcp.pinMode(2, OUTPUT);
  //led rouge
  //initialisation
  Serial.println ("step 1");
 
}
 
void loop() {
 
 
  mcp.writeGPIO(0xFD);// on
  //led rouge
  Serial.println ("led rouge A");
  delay(500);
 
  mcp.writeGPIO(0xFF);// off
  Serial.println ("led  rouge E");
  delay(500);
 
  mcp.writeGPIO(0xFE);// on 
  //led jaune
  Serial.println ("led  jaune A");
  delay(500);
 
  mcp.writeGPIO(0xFF);// off
  Serial.println ("led  jaune E");
  delay(500);
 
  mcp.writeGPIO(0xFB);// on 
  //led verte
  Serial.println ("led  verte A");
  delay(500);
 
  mcp.writeGPIO(0xFF);// off
  Serial.println ("led  verte E");
  delay(500); 
 
    cny= mcp.digitalRead(4);
if (cny <250)
    { Serial.println("0");}
    else {  Serial.println(" 1");}
 
 
 
    Serial.print(" valeur cny70 : ");
    Serial.print(cny,DEC);
      delay(1000);
 
}

Test bouton+ leds

//ajout des librairies
#include <Wire.h>
#include <Adafruit_MCP23008.h>
 
Adafruit_MCP23008 mcp;
float cny;
 
void setup() {
 
  // adresse du bus
  Serial.begin(9600);
  mcp.begin(7); // Utilisation de l'adresse "0" par défaut
  // on choisit 7 car après le scan i2c l'adresse est 0x027
 
  // E/S
  mcp.pinMode(4, INPUT); // mise en entrée
  //capteur cny70
  mcp.pinMode(0, OUTPUT);//mise en sortie
  //led jaune
  mcp.pinMode(1, OUTPUT);
  //led verte
  mcp.pinMode(2, OUTPUT);
  //led rouge
}
 
void loop() {

    cny= mcp.digitalRead(4);
if (cny <1)
    { Serial.println("0");
    mcp.writeGPIO(0xFD);
    mcp.writeGPIO(0xFE);
     mcp.writeGPIO(0xFB);
    }
//allume les leds sit la valeur du capteur cy est 0
        else {  Serial.println(" 1");
    mcp.writeGPIO(0xFF);
    // éteint tout les leds si sny = 1
    }
}

Pour vérifier fonctionnement du CNY70, il faut utiliser un appareil numérique qui perçoit les IR

Voir ci-dessous le lien pour voir la vidéo du programme:
Le programme Arduino permet d'allumer les LEDS quand le bouton est appuyé.
https://www.youtube.com/watch?v=EKHmDXdy9Tg

Interface de jeu en utilisant processing

//******************************************* Déclaration des variable *****************************************************

//cercle 1
float xCercle1 =400 ;
float yCercle1 = 400;
float RayonCercle1 = 200;

//cercle 2
float xCercle2 = 400;
float yCercle2 = 400;
float RayonCercle2 = 220;

//Led Rouge
float xLedRouge = 185;
float yLedRouge = 160;
float RayonLedRouge = 80;


//Led Jaune
float xLedJaune = 393;
float yLedJaune = 160;
float RayonLedJaune = 80;

//Led Verte
float xLedVerte = 600;
float yLedVerte= 160;
float RayonLedVerte = 80;





//***********************************Fonction SETUP******************************************************

void setup()
{
  size(800, 800);
}


//*********************************Fonction loop******************************************************
void draw ()
{

  background( 30, 60, 70);

  smooth();

  // calcule de la distance entre la position de la souris et le centre du bouton
  float distance = sqrt(((mouseX-xCercle2)*(mouseX-xCercle2))+((mouseY-yCercle2)*(mouseY-yCercle2)));


  noStroke();

  //bouton central
  fill (76, 58, 58);
  ellipse(xCercle2, yCercle2, RayonCercle2, RayonCercle2);

  // second bouton contour
  fill (78, 89, 80);
  ellipse(xCercle1, yCercle1, RayonCercle1, RayonCercle1);

  stroke(1);
  //Led rouge
  fill (78, 89, 80);
  ellipse(xLedRouge, yLedRouge, RayonLedRouge, RayonLedRouge);


  //Led Jaune
  fill (78, 89, 80);
  ellipse(xLedJaune, yLedJaune, RayonLedJaune, RayonLedJaune);


  //Led Verte
  fill (78, 89, 80);
  ellipse(xLedVerte, yLedVerte, RayonLedVerte, RayonLedVerte);


  //rectangle


  rect(193, 702, 424, -122);

  fill(0);
  rect (205, 691, 400, -100);




  // change le bouton de couleur lorsqu'il est appuyé
  if (mousePressed && distance <= (RayonCercle2/2)  ) {

    // le bouton devient vert
    noStroke();
    fill (25, 123, 50);
    ellipse(xCercle1, yCercle1, RayonCercle1, RayonCercle1);

    stroke(1);

    //Led rouge
    fill (215, 10, 10);
    ellipse(xLedRouge, yLedRouge, RayonLedRouge, RayonLedRouge);


    //Led Jaune
    fill (255, 255, 0);
    ellipse(xLedJaune, yLedJaune, RayonLedJaune, RayonLedJaune);


    //Led Verte
    fill (0, 208, 35);
    ellipse(xLedVerte, yLedVerte, RayonLedVerte, RayonLedVerte);


    fill (255, 255, 255);
    textSize(40);
    text("Bouton appuyé", 265, 650);
  }

  print("X=");
  println(mouseX);
  print("Y=");
  println(mouseY);
  println("");
  println("");
}

programmation avec raspberry pi 2

#include <time.h>
#include <stdio.h>
#include <wiringPi.h>
#include <mcp23008.h>
#include <sys/time.h>

int main (void)
{
 
  struct timeval tval_before, tval_after, tval_result;


  wiringPiSetup () ;
  mcp23008Setup (100, 0x27) ;

  printf ("Raspberry Pi - MCP23008 Test\n") ;

  
  pinMode         (100, OUTPUT) ; 
  pinMode         (101, OUTPUT) ;
  pinMode         (102, OUTPUT) ;
  pinMode         (104, INPUT) ;

  digitalWrite (100, 1) ;
  digitalWrite (101, 1) ;
  digitalWrite (102, 1) ;

   for (;;)
  {
    int cny;
     
    digitalWrite (100, 1) ;
    digitalWrite (101, 1) ;
    digitalWrite (102, 1) ;

    delay(3000);

    cny=digitalRead (104);

    gettimeofday(&tval_before, NULL);

    digitalWrite (100, 0);
    digitalWrite (101, 0);
    digitalWrite (102, 0);


    
    while ( cny == 1)

{
    cny=digitalRead (104);
}


   gettimeofday(&tval_after, NULL);
   timersub(&tval_after, &tval_before, &tval_result);

   printf("Time elapsed: %ld.%06ld\n", (long int)tval_result.tv_sec, (long int)tval_result.tv_usec);

delay(2000);

cny=digitalRead (104);

  
while ( cny == 0)

{
    printf(" Release the button please.\n");
    delay(500);
    cny=digitalRead (104);
}
  }

  return 0 ;
}

Programme(s) à réaliser

Par la suite l'interface processing sera relié à une programme Arduino
Suite au projet batak une interface sera réalisé, les différents éléments de cette interface seront:
- Les différents modes de jeux
- le temps qu'il reste à jouer
- le score obtenu

Utilisation de Charly robot pour détourage/perçage

Il existe façons d'utiliser Charlyrobot pour détourer ou bien pour percer une carte électronique.
Les étapes à réaliser sont les suivantes:

Préparation des fichiers sur eagle

Pour le contour

Pour obtenir ce type de fichier il faut ouvrir le fichier board (.brd) sur Eagle.
Pour commercer il faut tout désélectionner (dans Layer Settings) sauf la couche contour.
Il doit donc rester à l'écran uniquement le parcours de la fraise lors du détourage du PCB.

On génère ensuite un fichier DXF à partir de cette vue :

-avec la version eagle 6 : File -> export -> DXF
- avec la version eagle 6 : File -> export -> dxf
- avec la version eagle 5 : ULP -> dxf

Il faut décocher les différentes options:

- Always vector font
- Use wire widths
- Fill areas

Perçage

Pour générer le fichier de perçage, il faut lancer l'outil CAM processor.
Ouvrir un nouveau job,choisir excellon.cam.
Ajuster les paramètres en désélectionnant pos_Coord, pour ne pas avoir un décalage entre contour et perçage
Puis il faut cliquer sur process job → Cela permet de trouver le fichier .drd dans le répertoire du projet eagle.

Préparer le fichier "charlyRobot" avec Target

Nouveau projet

Ouvrir Target et créer un nouveau projet:

créer un board (1 face sans schéma)

Contour

On commence par importer le fichier de contour :

Dans le menu :

Fichier -> Utilitaires:Import-EXport -> Importer en format DXF

Sélectionner le fichier DXF créé avec Eagle

Choisir les options d'importation comme indiqué ci contre.

Perçage

Dans le menu :

Fichier -> Utilitaires:Import-EXport -> Importer des fichiers XGERBER/EXCELLON Sélectionner le fichier ".drd" créé avec Eagle

Choisir les options d'importation comme indiqué ci contre.

Fichier charlyRobot

On va exporter un fichier de fabrication (type *.pcb) export-> production-> fichier gravure par fraisage

Modifier les paramètres des fenêtres tel qu'indiqué sur les captures d'écran.
Se rendre ensuite dans l'onglet "Résultat" et lancer la création du fichier ".pcb"

Fabrication avec GPILOTE

Sur une perceuse manuelle, faire les trous de centrage sur la carte aux emplacements prévus, avec un forêt de 3mm.
Positionner la carte dans la machine à l'aide des "piges" et en fixant un morceau de scotch double face sous la carte. Il n'est pas nécessaire et même déconseillé de recouvrir entièrement la carte de scotch.
Attention au sens : Mettre le cuivre au dessus (visible) si vous avez, comme indiqué plus haut, sélectionné "Face soudure cuivre seulement" lors de la production du fichier pour charlyRobot
Lancer le logiciel GPILOTE.
Charger votre fichier ".pcb"
Normalement la machine est déjà préréglée
Suivre les instructions
- Le logiciel doit vous demander d'insérer le premier outil
- Le premier outil à insérer devrait être en toute logique un foret
- Attention, si le logiciel ne le demande pas, il faut toujours faire une mesure de l'outil
- Le logiciel est prêt et doit proposer de lancer le cycle d'usinage

- Fermer le capot avant de commencer

Raspberry Pi 2

Le Raspberry Pi est un nano-ordinateur monocarte à processeur ARM conçu par le créateur de jeux vidéo David Braben, dans le cadre de sa fondation Raspberry Pi. Cet ordinateur, qui est assez petite (taille d'une carte de crédit), est destiné à encourager l'apprentissage de la programmation informatique et permet l'exécution de plusieurs variantes du système d'exploitation libre comme GNU/Linux et des logiciels compatibles. Il est fourni avec la carte mère seule, sans boîtier, alimentation, clavier, souris ni écran, dans l'objectif de diminuer les coûts et de permettre l'utilisation de matériel de récupération.

Modèle de carte: Rasperry Pi 2 modèle B
Branchement à faire pour utiliser l'I2C
Il faut utiliser les ports:
- GND
-VCC (3.3V ou 5V selon utilisation)
- SDA
- SDL

Présentation générale de la carte:

Le Raspberry Pi 2 Modèle B est la deuxième génération Raspberry Pi. Elle a remplacé l'original Raspberry Pi 1 Modèle B +.
Par rapport à la Raspberry Pi 1, il a:

A 900 MHz quad-core ARM Cortex-A7 CPU
1 Go de RAM (1GB RAM)

Comme le (Pi 1) Modèle B +, on a aussi:

4 ports USB
40 broches GPIO
port HDMI complet
port Ethernet
jack 3,5 mm audio combinée et vidéo composite
l'interface de l'appareil photo (CSI)
L'interface d'affichage (DSI)
Micro SD slot pour carte
cœur graphique VideoCore IV 3D

Il dispose d'un processeur ARMv7, il peut fonctionner toute la gamme des distributions ARM GNU / Linux, y compris Snappy Ubuntu Core, ainsi que Microsoft Windows 10. Le Raspberry Pi 2 a une forme identique facteur à la précédente (Pi 1) Modèle B + et a une compatibilité totale avec Raspberry Pi 1.Le Raspberry Pi 2 Modèle B offre une plus grande souplesse que le (Pi 1) Modèle A + , ce qui est plus utile pour les projets et les projets intégrés qui nécessitent une très faible puissance.

L'interface I2C est un standard très utilisé conçu pour permettre à un circuit intégré de communiquer avec une autre (maître et esclave).
Raspberry Pi est capable de dialoguer en I2C, on peut donc connecter une grande variété de composants et modules supportant le protocole I2C.

Utilisation de la carte:

Identification des différents modèles de Raspberry (en complément à ci-dessus)
La commande suivante permet de retourner les informations concernant le processeur de la Raspberry Pi:

 cat /proc/cpuinfo

Équipements supplémentaires

Équipements minimum

Le Raspberry Pi ne comprend pas :

D'écran. Un écran ou un téléviseur peuvent être connectés via les sorties HDMI et Composite (sauf si un convertisseur dynamique est utilisé, les écrans VGA sont incompatibles) ;
De clavier / de souris. Pour l'utiliser, il faut donc le connecter à ces deux périphériques, via la prise USB

Le modèle A n'offrant qu'un unique port USB, il faudra utiliser un Hub USB, ou un clavier intégrant un dispositif de pointage (trackball, trackpad, trackpoint) ou bien comprenant un port USB. Le dispositif de pointage (voire le clavier) ne sont cependant pas indispensables pour toutes les applications : serveur, utilisation d'autre type d'interface (manette, reconnaissance vocale, etc.). Sous Raspbian, le protocole SSH est actif par défaut, et le Raspberry Pi peut être contrôlé à distance dès le premier démarrage, sans avoir besoin d'un clavier ou d'une souris supplémentaire.

De carte mémoire SD contenant un système d'exploitation compatible. Dans un but d'économie, toute carte SD est compatible, la classe 6 étant néanmoins recommandée

et les fichiers systèmes nécessaires seront disponibles en téléchargement gratuit. Il est ainsi possible de recycler d'anciennes cartes mémoire de capacité modeste pour utilisation avec le Raspberry Pi

De boîtier. Ceux-ci sont proposés en option ou en lot
D'alimentation. Le Raspberry Pi est compatible avec de nombreuses alimentations, micro-USB étant par exemple une norme pour les téléphones mobiles récents en Europe. Encore une fois, recyclage ou achat local sont l'objectif
D'horloge matérielle, dit composant HTR (le terme anglais est RTC : real time clock). La fondation justifie ce choix par le coût excessif du composant par rapport au budget initial très serré. La fondation suggère d'utiliser par exemple un composant GPS, qui contient une HTR très précise. Ce composant peut être branché via la prise GPIO. Il est aussi possible de synchroniser le temps du système grâce au protocole de réseau NTP, ce qui implique de se connecter via un réseau à un service NTP qui fonctionne soit sur un ordinateur sur Internet, soit sur un ordinateur d'un réseau local, ce dernier ordinateur devant être capable de se synchroniser avec une référence NTP sur Internet.

Équipements utilisant l'USB

Il est possible de connecter le Raspberry Pi avec :

Pour le modèle A, une carte réseau Ethernet ou Wi-Fi, pour établir une connexion en réseau, notamment avec Internet.Le modèle B introduit durant l'été 2011 comporte une carte Ethernet intégrée.
Des unités de stockage externe, clés USB ou disques durs alimentés séparément
Tout autre périphérique USB disposant d'un pilote informatique compatible : clé Bluetooth, clé Wi-Fi, mémoire flash, imprimante, webcam

La fondation Raspberry Pi proposera à la vente une palette de périphériques validés compatibles. D'autres périphériques seront possibles, mais la disponibilité d'un pilote informatique adéquat, compatible avec le processeur, le système d'exploitation, le circuit d'interface, et le périphérique lui-même, devra être scrupuleusement vérifiée.

Équipements utilisant les ports séries

Ces ports permettront l'interfaçage avec d'autres circuits, pour la réalisation de projets électroniques, robotiques, physiques (par exemple, émettre en FM grâce à piFM).

Utilisation de Raspberry Pi 2:

Lier arduino et raspberry via le bus I2C

Raspberry et Arduino ne sont pas opposés, ils ont des points communs et chacun a des avantages qui peuvent être bon de combiner.

Avec le Raspberry Pi on peut via les ports GPIO contrôler des composants externes et faire des projets en électronique. Pour lier les deux, on doit passer par le protocole I2C.
Plusieurs raisons à ça :

ne pas utiliser le port USB, le Raspberry Pi étant limité
ne pas utiliser le port série

Le protocole I2C, avec une orientation domotique, permet à plusieurs composants de dialoguer entre eux de manière bidirectionnel mais en half-duplex uniquement. Il y a un principe de maitre et esclave. On utilise le Raspberry Pi en tant que maitre et l’Arduino en tant qu’esclave. Avant tout pour connecter les deux appareils il faut savoir quelles broches il faut utiliser. Pour le raspberry c’est sur les GPIO 2 et 3 (pour les cartes à partir du modèle B révision 2, ceux avec les trous de fixation dans la carte).

Configurer I2C

L'interface I2C est un standard très utilisé conçu pour permettre à un circuit intégré de communiquer avec une autre. Puisque Raspberry Pi est capable de dialoguer en I2C, nous pouvons donc connecter une grande variété de composants et modules supportant le protocole I2C.
Voici quelques projets qui utilisent des modules et composants I2C:
-GPIO Expander pour Raspberry Pi Ajouter des entrées/sorties digitales à votre Pi.
-Afficheur 16x2 lignes + Keypad pour Raspberry Pi
-Support RTC DS1307 (horloge temps réel) pour Raspberry PI
-Contrôleur LED (Led Backpack) pour afficheur 4x7 segments et matrice LED
-MCP4725 Convertisseur Digital Analogique 12-Bit
-Controleur PWM/Servo 16 canaux pour Raspberry Pi
-Mesure de pression avec le BMP085

Si on utilise Occidentalis, alors vme Pi est déjà prêt à supporter I2C (pour autant qu'il soit possible au programme d'accéder au broches matérielles). Par contre, si on utilise Raspbian, on aura besoin d'ouvrir LX Terminal et d'encoder la commande suivante:

sudo nano /etc/modules

et d'ajouter les deux lignes suivantes à la fin du fichier

i2c-bcm2708 
i2c-dev

Descrption

L'interface I2C est un standard très utilisé conçu pour permettre à un circuit intégré de communiquer avec une autre (maître et esclave). Raspberry Pi est capable de dialoguer en I2C, on peut donc connecter une grande variété de composants et modules supportant le protocole I2C. Si on utilise Occidentalis, alors le Pi est déjà prêt à supporter I2C (pour autant qu'il soit possible au programme d'accéder au broches matérielles). Par contre, si on utilise Raspbian, on aura besoin d'ouvrir LX Terminal et d'encoder la commande suivante: sudo nano /etc/modules et d'ajouter les deux lignes suivantes à la fin du fichier i2c-bcm2708 i2c-dev

Après la modification du fichier, on doit redémarrer (c’est-à-dire rebooter) le Pi pour les modifications soient ainsi appliquées. Si on a des problèmes I2C avec le Raspbian, il est préférable de passer à la toute dernière version. Le bus I2C permet à plusieurs périphériques d'être connecté sur le Raspberry Pi, chacun avec une adresse unique. Cette adresse unique peut souvent être modifiée sur le module à l'aide de cavalier (ou bien de pontage à souder pour réaliser des connexions). Il est très utile de pouvoir visualiser les appareils qui sont connectés au Pi. Cela est très pratique afin de s'assurer que tout fonctionne correctement. Pour effectuer cette étape il faut installer des utilitaires I2C, il est préférable d'utiliser la commande suivante dans un terminal pour les installer sudo apt-get install python-smbus sudo apt-get install i2c-tools Après installation , on peut taper la commande suivantes pour voir tous les périphériques connectés (si on utilise un Raspberry Pi Modèle B 512MB) sudo i2cdetect -y 1

Cela montre deux adresses I2C en cours d'utilisation – 0x40 et 0x70. Il faut noter que si on utilise l'un des premiers modèle de Raspberry Pi (Raspberry Pi Modèle B 256MB ) alors on aura besoin de changer la commande comme suit: sudo i2cdetect -y 0 En effet, les concepteurs du Raspberry Pi ont modifié le brochage du port I2C entre les deux "release" de Raspberry. Pi B et Pi B+: la compatibilité du GPIO Avec l'arrivée du Raspberry Pi-3, Raspberry Pi-2 et Raspberry Pi-B PLUS, vient également un GPIO étendu de 40 broches rétro-compatible avec le GPIO des premières générations du Raspberry-Pi qui ne comportait que 26 broches. On remarque que les 26 premières broches du GPIO sont identiques entre le Raspberry-Pi modèle B et le Raspberry-Pi 3, Pi 2 (ou Pi B+), tout sur le GPIO du modèle B fonctionnera à l'identique autant sur un modèle B+, ou bien le Pi 2 ainsi que le Pi 3.

La seule vraie différence réside dans la longueur du GPIO du modèle Pi-3, Pi-2 ou B+ qui contient des broches en plus. et le Pi-Cobbler PLUS qui à également grandi pour accueillir les broches en plus. Avec l'apparition du Pi Zero, nous pouvons reparler de la correspondance des GPIO.

le GPIO du Pi Zero et du Pi 3 (ou Pi 2) sont identiques

Brochage Voici le nom des broches du bus I2C matériel et leurs positions sur le GPIO. Les 26 premières broches étant identiques entre le modèle Pi B et Pi B+, le schéma ci-dessous s'applique donc aussi à votre Pi PLUS .

Les ports I2C sont : • SDA - Broche 3 - GPIO #0 (Ligne de donnée du Bus I2C, DATA) • SCL - Broche 4 - GPIO #1 (Ligne du signal d'horloge du BUS I2C, CLOCK et son diminutif CL ou CLK) Alors le Raspberry Pi et l’Arduino ne sont pas forcement aussi opposés, avec même des points communs mais chacun à des avantages qui peuvent être bons de combiner.

Avec le Raspberry Pi on peut via les ports GPIO contrôler des composants externes en électronique. Par conséquent pour lier Raspberry et Arduino, on passe par le protocole I2C. Plusieurs raisons à ça : ne pas utiliser le port USB, le Raspberry Pi étant limité . Et ne pas utiliser le port série. Ici c’est un peu plus personnel, car j’ai une carte Slice Of Pi sur un Raspberry pour la station météo et elle utilise le port série pour les sondes sans fil. Le protocole I2C, créé par Philips avec une orientation domotique, permet à plusieurs composants de dialoguer entre eux de manière bidirectionnel mais en half-duplex uniquement.

Il y a un principe de maitre et esclave. Ici nous va donc utiliser le Raspberry Pi en tant que maitre et l’Arduino en tant qu’esclave. Avant tout pour connecter les deux appareils il faut savoir quelles broches utiliser ! Pour le raspberry c’est sur les GPIO 2 et 3 (pour les cartes à partir du modèle B révision 2, ceux avec les trous de fixation dans la carte)

Pour l’Arduino, ça se passe sur les broches A4 et A5 pour les cartes de type Arduino Uno.

Il faudra ajouter une connexion à la masse entre les deux. Donc vous aurez besoin de trois fils. Avant de connecter les deux appareils, il faut s’assurer qu’ils vont pouvoir communiquer. Toutes les informations sont sur le site d’adafruit mais en gros, voici ce qu’il faut faire. Définir l’Arduino comme esclave C’est relativement simple en incluant le module Wire dans le programme. On prend l’adresse 0x12 mais vous pouvez choisir de 0x03 à 0x77 (en hexa) :

include <Wire.h>

define SLAVE_ADDRESS 0x12

int dataReceived = 0;

void setup() {

   Serial.begin(9600);
   Wire.begin(SLAVE_ADDRESS);
   Wire.onReceive(receiveData);
   Wire.onRequest(sendData);

}

void loop() {

   delay(100);

}

void receiveData(int byteCount){

   while(Wire.available()) {
       dataReceived = Wire.read();
       Serial.print("Donnee recue : ");
       Serial.println(dataReceived);
   }

}

void sendData(){

   int envoi = dataReceived + 1;
   Wire.write(envoi);

} , le programme initialise l’Arduino avec l’adresse 0x12, définit la méthode de réception des données, la méthode d’envoi des données et c’est parti pour l’envoyer vers la carte avec l’interface. Activer la gestion I2C sur le Raspberry Pi Par défaut, des distributions de type Raspbian désactivent la gestion I2C pour économiser la mémoire utilisée par le module. Pour réactiver, rien de plus simple et c’est dans le fichier /etc/modprobe.d/raspi-blacklist.conf. Il faut mettre en commentaire avec un # la ligne : blacklist i2c-bcm2708 Reste à activer le module lors de chaque démarrage. C’est dans le fichier /etc/modules, en y ajoutant à la fin une nouvelle ligne : i2c-dev Ensuite vous installez la suite des outils de gestion I2C apt-get install i2c-tools Il va vous falloir redémarrer le Raspberry pour faire apparaitre deux fichiers :

Grâce à eux vous allez pouvoir communiquer sur le bus I2C ! Vous pouvez lister les périphériques avec la commande : i2cdetect -y 1 Pour les modèles 256Mo (comme celui que j’utilise pour mes tests) : i2cdetect -y 0 Voilà. Etape suivante : connecter l’Arduino et lui parler ! Communiquer avec l’Arduino Vous pouvez maintenant relier l’Arduino au Raspberry et allumer tout ce petit monde ! Attention, sur le schema, le raccordement SDA et SCL est inversé ! Le rouge en A5 et le balnc va en A4

Une fois fait, vous vous connectez sur le Raspberry Pi et vous relancez la commande i2cdetect avec le bon paramètre :

Le paramètre défini dans le sketch envoyé à l’Arduino, 0x12, apparait dans les périphériques détectés. On progresse ! Il nous faut maintenant mettre en place le script sur le Raspberry Pi qui va envoyer/recevoir avec l’Arduino. Pour cela, le plus simple c’est d’installer le support d’I2C dans les scripts Python. C’est ce que va faire python-smbus apt-get install python-smbus Nous sommes donc maintenant équipé pour parler à notre Arduino. Pour ça un petit programme tout simple. Envoyer un chiffre entre 0 et 8 et nous retourner ce chiffre plus un : import smbus import time

Remplacer 0 par 1 si nouveau Raspberry

bus = smbus.SMBus(0) address = 0x12

print "Envoi de la valeur 3" bus.write_byte(address, 3)

Pause de 1 seconde pour laisser le temps au traitement de se faire

time.sleep(1) reponse = bus.read_byte(address) print "La reponse de l'arduino : ", reponse Le résultat de l’exécution :

Annexes

Montage avec pull-up

Version 2 à gauche, version 1 à droite

test du capteur CNY70

Montage choix résistances pour LEDS

Visualisation de SDA et SCL à l'oscillo (SDA en jaune/ SCL en Bleu)

Montage pour visualisation signaux SDA et SCL

Interface de Gpilote pour détourage et perçage

Utilisation de Milling sur eagle pour définir contour carte

Trou de perçage (obtenu avec Target)

Préparation fichier détourage/perçage avec Target
liens utiles:

Cette catégorie ne contient actuellement aucune page ni fichier multimédia.

@@ Ligne 4 : / Ligne 4 : @@
 <center>[[Fichier:ERS3BATACK.PNG]]</center>
 <br>
-==Présentation==
+=={{Rouge|Présentation}}==
 <br>
 Dans le cadre de notre projet ER du semestre 3, nous allons réaliser le projet 'BATAK', en association avec le département GMP. Ce projet Batak est un outil de d'entraînement reposant sur une série de boutons comportant des LEDs. L’utilisateur doit appuyer sur les boutons lorsque ceux-ci sont allumés dans les plus bref délais. Cela permet d'évaluer ou d’entraîner la rapidité de réflexe des de l'utilisateur. C'est un outil particulièrement intéressant dans les milieux sportifs, prenant en charge de nombreux disciplines: arts martiaux, football, handball ...
@@ Ligne 10 : / Ligne 10 : @@
 <br>
-==Principe de fonctionnement==
+=={{Rouge|Principe de fonctionnement}}==
 <br>
@@ Ligne 33 : / Ligne 33 : @@
 [[Image:Batak_general.gif|centre]]
-={{Rouge|Cahier des charges}}=
+<br>
+=={{Rouge|Diagramme de Gantt|1000px}}==
+[[Fichier:Gntt.PNG]]
+<br>
+={{Rouge|Fabrication de la carte}}=
+==={{Bleu|Vérifications préliminaires}}===
+Avant d’effectuer toute opération sur le circuit imprimé, il est nécessaire de vérifier que le circuit soit en bon état.<br>
+===={{Vert|Vérification des pistes}}====
+*à l’œil nu (pistes fusionnées avec d’autres ou piste coupés)<br>
+* avec appareil permettant de mesurer la conductivité des différents pôles des pistes (multimètre...)<br>
+==={{Bleu|Mise en place des composants CMS}}===
+En suivant le schematic et le board sous eagle il faut : <br>
+- Déposer de la pâte à braser sur les pattes du circuit imprimé <br>
+- Déposer les composants CMS aux endroits appropriés <br>
+- Passer le circuit dans le four<br>
+- Recommencer pour l’autre face.<br>
+==={{Bleu|Soudures}}===
+===={{Vert|Soudure des vias}}====
+Lorsque les composants CMS ont été déposés il sera nécessaire de souder les différents vias. <br>
+Pour cela nous devons : <br>
+- Introduire un fil de cuivre de diamètre approprié dans les vias <br>
+- Souder des deux côtes à l’aide d’étain et d’un fer à souder <br>
+===={{Vert|Soudure des composants traversants}}====
+-Soudure des derniers composants traversant à l’aide d’étain et de fer à souder <br>
+==={{Bleu|Perçage, découpage et soudure}}===
+* Utilisation de perceuse avoir des forets de différents diamètres:<br>
+- 1mm pour capteurs et connecteurs<br>
+- 0,6 et 0,8 mm pour les vias<br>
+- Utilisation de charlyrobot pour le découpage de la carte mais aussi perçage dans certains cas <br>
+- Utilisation de cisaille pour finir de découper la carte<br>
+- pour les vias: on prend un fil que l'on dénude, on le découpe pour qu'il soit à la largeur de la carte<br>
+- Une fois inséré dans le trou on soude des deux cotés pour le maintenir<br>
+- Soudure avec un fil d'étain pour relier les vias (avec un fer à souder)<br>
+-on soude quelques composants avec de la pâte à braser pour les composants cms<br>
+- pour ajuster la taille de la carte on utilise des cisailles<br>
+={{Rouge|Présentation du la connexion via le bus I2C}}=
+Avec la documentation du mcp23008 on connecte le SCL au pin A5 et SDA à A4.
+*SDA= ligne de données bidirectionnelle (Serial Data Line)
+*SCL= ligne d’horloge de synchronisation bidirectionnelle (Serial Clock line)
+Il faut utiliser des connecteurs MOLEX à 4 bornes, voir ci-dessous pour description :
+{| class="wikitable"
+|-
+! N° de patte !! Fonction !! Nom !! Connection Arduino
+|-
+| 1 || SCL||Serial Clock line||A5 (entrée analogique)
+|-
+| 2 || SDA||Serial Data Line||A4 (entrée analogique)
+|-
+| 3 || GND||Masse|| GND
+|-
+| 4 || VCC|| Alimentation||5V ou 3.3V
+|}
+<br>
+*Codage des bits<br>
+Le codage utilisé est de type NRZ (non retour à 0) :<br>
+[[Fichier:Bitss.PNG]]<br>
+Le niveau (« HIGH » ou « LOW ») de la ligne SDA doit être maintenu stable pendant le niveau « HIGH » sur la ligne SCL pour la lecture du bit.<br>
+<br>
+SDA et SCL vu par oscilloscope<br>
+[[Fichier:SSGGNN.PNG]]<br>
+={{Rouge|(Cahier des charges)}}=
+Le dispositif complet sera développé par parties constituant divers projets menés de front. Cependant, toute l'électronique ne sera pas développée dans ce projet, notamment le système de calcul. La carte processeur a été choisie préalablement et un certain nombre de contraintes en découle. Ainsi, le système de calcul reposera sur une carte Arduino. A contrario, si la carte Arduino n'est pas matériellement développée dans ce projet par les étudiants, elle sera programmée, le cas échéant, par leurs soins pour permettre de tester telle ou telle partie. On propose le découpage fonctionnel suivant qui génère de fait les divers projets :
+*Pour la première partie de l'interface homme-machine, il existe un panneau disposant de boutons intégrant des lampes. Ce panneau pourra être utilisé tel quel pour le projet Batak global, notamment pour tester les différents systèmes de calcul et d'affichage. Cependant, le projet comporte une partie consistant à développer un bouton poussoir intégré et spécifique.
+*Pour l'affichage, le choix est de développer des afficheurs 7 segments dont chacun des segments sera "dessiné" par une série de quelques leds alignées. On y ajoutera quelques leds supplémentaires qui donneront des indications sur le mode de jeu choisi par exemple. Une carte d'affichage sera donc ainsi conçue et produite. <br>
+-Une carte d'alimentation sera conçue et produite pour desservir en énergie les différentes cartes du système à partir de l'alimentation secteur.<br>
+-Une carte d'adaptation de puissance sera conçue et produite pour permettre d'interfacer les bouton/voyant au système de calcul.<br>
+-Une carte dite "CPLD" sera conçue et produite pour adapter (en terme de nombre d'entrées/sorties et pas en terme de puissance cette fois) la carte Arduino au panneau de boutons/voyants.<br>
+=={{Bleu|Conception}}==
+==={{Vert|Entrées/Sorties}}===
+Il s'agira de fabriquer une carte électronique qui servira de support aux différents composants et qui permettra de venir facilement connecter le bouton au système entier.<br>
+Cette carte (qui pourra être composée de plusieurs parties) proposera un connecteur permettant d'avoir les signaux suivants :<br>
+*Alimentation<br>
+**+5V DC (ou +3.3V)<br>
+**GND<br>
+*I2C<br>
+**horloge SCL<br>
+**donnée SDA<br>
+<br>
 =={{Bleu|Documents ressources}}==
@@ Ligne 47 : / Ligne 137 : @@
 <br>
-=Etudes préliminaires=
+={{Rouge|Etudes préliminaires}}=
 <br>
 <center>
 [[Fichier:ERS3CONCEPTION.png]] </center>
+<br>
+Dans un premier temps il convient de choisir et de tester la valeur des résistances et la disposition de LEDs que l’on va utiliser pour le bouton lumineux. <br>
+=={{Bleu|Choix des résistances}}==
+Pour choisir la bonne valeur de résistance, il faut connaître les valeurs normalisées des résistances.<br>
+*Valeurs normalisées des résistances: (12 valeurs par décade)<br>
+[[Fichier:Res.PNG]]
+<br>
+==={{Vert|Calcul résistance pour LEDs (carte voyant)}}===
+[[Fichier:Clc.PNG]]<br>
+[[Fichier:The.PNG]]<br>
+==={{Vert|Calcul résistance pour LEDs (carte capteur)}}===
+*De même pour la LED infrarouge on utilise la même méthode de calcul<br>
+*Pour le choix de la résistance pour le transistor, il suffit de tester des valeurs de résistances élevées et constater une grande variation de valeur compris entre 0 et 1023 <br>
+=={{Bleu|Choix branchements des LEDs}}==
+Il y a deux façons de brancher les LEDs : <br>
+*Anode commune<br>
+*Cathode commune <br>
+==={{Vert|Anode commune}}===
+Lorsque les LEDs sont disposé en anode communes, il faudra envoyer un 0 à la Bit correspondant pour allumer la LED spécifique. <br>
+[[Fichier:Anodec.PNG]]
+==={{Vert|Cathode commune}}===
+Lorsque les LEDs sont disposé en cathode communes, il faudra envoyer un 1 à la Bit correspondant pour allumer la LED spécifique. <br>
+[[Fichier:Cathodec.PNG]]
+=={{Bleu|Choix pour branchement avec entrées analogiques du MCP23008}}==
+==={{Vert|Première solution: utilisation de switch}}===
+Avant de s’attaquer au schématic il faut noter la particularité du MCP23008. En effet, afin de pouvoir piloter plusieurs cartes simultanément, il est nécessaire d’identifier chaque carte par une
+« adresse ». Cette adresse est inscrite dans le mcp23008 et peut être modifié à tout moment par des  dispositifs différents consistant à mettre un 0 ou 1 aux pins correspondants.
+On peut noter que la valeur des résistances est très élevée (100kΩ) pour empêcher que le courant passe au GND lorsque l'on veut fermé l'interrupteur. (Le courant passe par le chemin le moins « difficile »).
+[[Fichier:Switch.PNG]]
+==={{Vert|Deuxième solution: utilisation de résistances}}===
+[[Fichier:Ures.PNG]] <br>
+Dans ce cas on utilisera des résistances 0Ω et 100kΩ pour définir l'adresse
+==={{Vert|Troisième solution: utilisation de jumpers}}===
+[[Fichier:Jumper.PNG]]<br>
+*la patte 1 est branché au VCC (Alimentation)<br>
+*la patte 2 est relié a Ax c'est-à-dire à l'adresse<br>
+*la patte 3 est relié au GND (masse)<br>
+=={{Bleu|Étude du CNY70 }}==
+[[Fichier:Cny.PNG]]
+<br>
+Légende:
+*K: Cathode
+*A: Anode
+*C: Collecteur
+*E: Émetteur
+*D: Détecteur
+<br>
+Le photocoupleur (capeur) CNY70 est composé d'un phototransistor et d'une diode infrarouge.<br>
+La LED infrarouge émet un signal et le transistor détecte la réponse.<br>
 <br>
-== Le bouton==
+={{Rouge|Présentation du bouton batak}}=
+=={{Rouge|Le bouton(cahier des charges)}}==
+<br>[[Fichier:Bouton.PNG|400px]]
 <br>
 Le système d'entraînement de type Batak est composé de 12 boutons. Chacun de ces boutons est "lumineux" et doit pouvoir afficher 3 couleurs différents rouge/orange/vert. Le système mécanique prévoit 9 emplacements pour des leds 5mm.La détection de la position du bouton sera basée sur l'utilisation d'un photocoupleur par réflexion : la partie mobile du bouton présentant un coefficient de réflexion différent du corps du bouton, la lumière réfléchie a une intensité différente suivant sa position.
@@ Ligne 61 : / Ligne 211 : @@
 * la seconde carte comporte le le photocoupleur CNY et le bus i2c
 <br>
+==={{Bleu|Détection de la position du bouton}}===
+*Nous utiliserons un photocoupleur CNY70 pour détecter la position. Vous devrez proposer et valider par des tests une structure permettant d'obtenir un signal logique représentant cette position.
+*Il conviendra pour se faire d'utiliser un comparateur ou une porte logique (de préférence triggerisée).
+==={{Bleu|Fabrication}}===
+*La contrainte principale de la carte tient dans sa forme. Vous devrez ajuster très précisément à la fois le contour, mais également la position des leds et du photocoupleur. Si la carte est en plusieurs morceaux, il conviendra de proposer une solution à la fois résistante et peu coûteuse d'assemblage.
+*La partie perçage et détourage sera nécessairement réalisée en utilisant une fraiseuse numérique
+==={{Bleu|Première version de la carte}}===
+===={{Vert|Nomenclature: carte capteur}}====
+-1 résistance 47kΩ<br>
+-1 résistance 330Ω<br>
+-un capteur CNY70<br>
+-1 connecteur molex bus I2C (mâle)<br>
 <br>
-<center>'''Board'''
+===={{Vert|Nomenclature: carte voyant}}====
+-3 leds jaunes<br>
+-3 leds vertes<br>
+-3 leds rouges<br>
+-1 MCP23008<br>
+-3 résistances de 0Ω<br>
+-9 résistances  470Ω (possibilité de 280Ω)<br>
 <br>
+===={{Vert|Tableau de transcodage}}====
+* pour allumer une led il faut mettre '1'<br>
+* pour éteindre une led il faut mettre '0'<br>
+*exemple pour tout éteindre: 0x00<br>
+-GP1 LED Jaune 0x02 (0b00000010)<br>
+-GP2 LED Verte 0x04 (0b00000100)<br>
+-GP7 LED Rouge 0x80 (0b10000000)<br>
+-GP0 CNY 0x01 (0b00000001)<br>
 <br>
 <br>
-[[Fichier:BATAKBoardLED.PNG]]
+==={{Bleu|Deuxième version de la carte}}===
+===={{Vert|Nomenclature: carte capteur}}====
+-1 résistance 560kΩ<br>
+-1 résistance 270Ω<br>
+-un capteur CNY70<br>
+-1 connecteur molex bus I2C (mâle)<br>
 <br>
+===={{Vert|Nomenclature: carte voyant}}====
+-3 leds jaunes<br>
+-3 leds vertes<br>
+-3 leds rouges<br>
+-1 MCP23008<br>
+-4 résistances de 0Ω<br>
+-9 résistances  270Ω<br>
+-3 jumpers<br>
+===={{Vert|Tableau de transcodage}}====
+* pour allumer une led il faut mettre '0'<br>
+* pour éteindre une led il faut mettre '1'<br>
+*exemple pour tout éteindre: 0xFF<br>
+-GP0 LED Jaune 0xFE (0b11111110)<br>
+-GP2 LED Verte 0xFB (0b11111011)<br>
+-GP1 LED Rouge 0xFD (0b11111101)<br>
+-GP4 CNY 0xEF (0b11101111)<br>
 <br>
-<center>'''schematic'''
+=={{Rouge|Schematic(s) et board(s)}}==
+==={{Bleu|Version 1}}===
 <br>
+<center>'''Schematic carte voyant version 1'''<br>
+[[Fichier:Vv1sch.PNG]]<br>
+'''Board carte voyant version 1'''<br>
+[[Fichier:Vv1brd.PNG]]<br>
+'''Schematic carte capteur version 1'''<br>
+[[Fichier:Cv1sch.PNG]]<br>
+'''Board carte capteur version 1'''<br>
+[[Fichier:Cv1brd.PNG|800px]]<br>
+</center>
+==={{Bleu|Version 2}}===
 <br>
+<center>'''Schematic carte voyant version 2'''<br>
+[[Fichier:Vv2sch.PNG]]<br>
+'''Board carte voyant version 2'''<br>
+[[Fichier:Vv2brd.PNG]]<br>
+'''Schematic carte capteur version 2'''<br>
+[[Fichier:Cv2sch.PNG]]<br>
+'''Board carte capteur version 2'''<br>
+[[Fichier:Cv2brd.PNG|800px]]<br>
+</center>
+={{Rouge|Tests}}=
+=={{Bleu|Programmation}}==
+Afin de pouvoir programmer la carte et le bus mcp28003, ll est nécessaire de télécharger le librairie Arduino correspondant.
+Cette librairie permet alors de commander les bus avec des fonctions spécifique tout en prenant en compte de ces différents adresses après avoir été branché avec le connecteur I2C:
+<source lang=c>
+#include <Wire.h>
+#include "Adafruit_MCP23008.h"
+</source>
+Cette commande permet d’inclure la libraire Arduino pour le mcp28003.
+<source lang=c>
+mcp.begin(1);
+</source>
+Cette commande permet de choisir/démarer la carte avec son adresse que l’on souhaite programmer
+<source lang=c>
+mcp.writeGPIO(...); // adresse sur 7bits
+</source>
+Cette fonction indique l’état des bit pour allumer les segments de l’afficheur.
+<source lang=c>
+/***************************************************
+  This is a library for the MCP23008 i2c port expander
+  These displays use I2C to communicate, 2 pins are required to
+  interface
+  Adafruit invests time and resources providing this open source code,
+  please support Adafruit and open-source hardware by purchasing
+  products from Adafruit!
+  Written by Limor Fried/Ladyada for Adafruit Industries.
+  BSD license, all text above must be included in any redistribution
+ ****************************************************/
+#ifndef _ADAFRUIT_MCP23008_H
+#define _ADAFRUIT_MCP23008_H
+// Don't forget the Wire library
+#ifdef __AVR_ATtiny85__
+  #include <TinyWireM.h>
+#else
+  #include <Wire.h>
+#endif
+class Adafruit_MCP23008 {
+public:
+  void begin(uint8_t addr); // adresse
+  void begin(void);
+  void pinMode(uint8_t p, uint8_t d); // déclaration entrée/sorties
+  void digitalWrite(uint8_t p, uint8_t d); // 1 par 1
+  void pullUp(uint8_t p, uint8_t d);
+  uint8_t digitalRead(uint8_t p); // 1 par 1 //allumage led
+  uint8_t readGPIO(void); //global
+  void writeGPIO(uint8_t); //global //lire valeur capteur
+ private:
+  uint8_t i2caddr;
+  uint8_t read8(uint8_t addr);
+  void write8(uint8_t addr, uint8_t data);
+};
+#define MCP23008_ADDRESS 0x20
+// registers
+#define MCP23008_IODIR 0x00
+#define MCP23008_IPOL 0x01
+#define MCP23008_GPINTEN 0x02
+#define MCP23008_DEFVAL 0x03
+#define MCP23008_INTCON 0x04
+#define MCP23008_IOCON 0x05
+#define MCP23008_GPPU 0x06
+#define MCP23008_INTF 0x07
+#define MCP23008_INTCAP 0x08
+#define MCP23008_GPIO 0x09
+#define MCP23008_OLAT 0x0A
+#endif
+</source>
+Pour programmer on peut utiliser la méthode globale ou un par un
+=={{Vert|Programme de scan d’adresse}}==
+*Pour choisir une carte, il faut d’abord connaître son adresse inscrit dans le MCP23008 <br>
+*Pour cela un programme permet alors de détecter l’adresse de la carte : <br>
+<source lang=c>
+// --------------------------------------
+// i2c_scanner
+//
+// This program (or code that looks like it)
+// can be found in many places.
+// For example on the Arduino.cc forum.
+// The original author is not know.
+//
+// This sketch tests the standard 7-bit addresses
+// from 0 to 127. Devices with higher bit address
+// might not be seen properly.
+//
+// Adapted to be as simple as possible by Arduino.cc user Krodal
+//
+// June 2012
+// Using Arduino 1.0.1
+//
+#include <Wire.h>
+void setup()
+{
+Wire.begin();
+Serial.begin(9600);
+Serial.println("\nI2C Scanner");
+}
+void loop()
+{
+byte error, address;
+int nDevices;
+Serial.println("Scanning...");
+nDevices = 0;
+for(address = 0; address <= 127; address++ )
+{
+// The i2c_scanner uses the return value of
+// the Write.endTransmisstion to see if
+// a device did acknowledge to the address.
+Wire.beginTransmission(address);
+error = Wire.endTransmission();
+if (error == 0)
+{
+Serial.print("I2C device found at address 0x");
+if (address<16)
+Serial.print("0");
+Serial.print(address,HEX);
+Serial.println(" !");
+nDevices++;
+}
+else if (error==4)
+{
+Serial.print("Unknow error at address 0x");
+if (address<16)
+Serial.print("0");
+Serial.println(address,HEX);
+}
+}
+if (nDevices == 0)
+Serial.println("No I2C devices found\n");
+else
+Serial.println("done\n");
+delay(500); // wait 8 seconds for next scan
+}
+</source>
+=={{Vert|Test batak version 1}}==
+<source lang=c>
+//ajout des librairies
+#include <Wire.h>
+#include <Adafruit_MCP23008.h>
+Adafruit_MCP23008 mcp;
+float cny;
+void setup() {
+  // adressedu bus
+  Serial.begin(9600);
+  mcp.begin(3); // Utilisation de l'adresse "0" par défaut
+  // on choisit 3 car après le scan i2c l'adresse est 0x23
+  // E/S
+  mcp.pinMode(0, INPUT); // mise en entrée
+  //capteur cny70
+  mcp.pinMode(1, OUTPUT);//mise en sortie
+  //led jaune
+  mcp.pinMode(2, OUTPUT);
+  //led verte
+  mcp.pinMode(7, OUTPUT);
+  //led rouge
+  //initialisation
+  Serial.println ("step 1");
+}
+void loop() {
+  mcp.writeGPIO(0x80);// on
+  //led rouge
+  Serial.println ("led rouge A");
+  delay(500);
+  mcp.writeGPIO(0x00);// off
+  Serial.println ("led  rouge E");
+  delay(500);
+  mcp.writeGPIO(0x02);// on
+  //led jaune
+  Serial.println ("led  jaune A");
+  delay(500);
+  mcp.writeGPIO(0x00);// off
+  Serial.println ("led  jaune E");
+  delay(500);
+  mcp.writeGPIO(0x04);// on
+  //led verte
+  Serial.println ("led  verte A");
+  delay(500);
+  mcp.writeGPIO(0x00);// off
+  Serial.println ("led  verte E");
+  delay(500);
+    cny= mcp.digitalRead(0);
+if (cny >500)
+    { Serial.println("0");}
+    else {  Serial.println(" 1");}
+    Serial.print(" valeur cny70 : ");
+    Serial.print(cny,DEC);
+      delay(1000);
+}
+</source>
+=={{Vert|Test batak version 2}}==
+<source lang=c>
+//ajout des librairies
+#include <Wire.h>
+#include <Adafruit_MCP23008.h>
+Adafruit_MCP23008 mcp;
+float cny;
+void setup() {
+  // adresse du bus
+  Serial.begin(9600);
+  mcp.begin(7); // Utilisation de l'adresse "0" par défaut
+  // on choisit 7 car après le scan i2c l'adresse est 0x027
+  // E/S
+  mcp.pinMode(4, INPUT); // mise en entrée
+  //capteur cny70
+  mcp.pinMode(0, OUTPUT);//mise en sortie
+  //led jaune
+  mcp.pinMode(1, OUTPUT);
+  //led verte
+  mcp.pinMode(2, OUTPUT);
+  //led rouge
+  //initialisation
+  Serial.println ("step 1");
+}
+void loop() {
+  mcp.writeGPIO(0xFD);// on
+  //led rouge
+  Serial.println ("led rouge A");
+  delay(500);
+  mcp.writeGPIO(0xFF);// off
+  Serial.println ("led  rouge E");
+  delay(500);
+  mcp.writeGPIO(0xFE);// on
+  //led jaune
+  Serial.println ("led  jaune A");
+  delay(500);
+  mcp.writeGPIO(0xFF);// off
+  Serial.println ("led  jaune E");
+  delay(500);
+  mcp.writeGPIO(0xFB);// on
+  //led verte
+  Serial.println ("led  verte A");
+  delay(500);
+  mcp.writeGPIO(0xFF);// off
+  Serial.println ("led  verte E");
+  delay(500);
+    cny= mcp.digitalRead(4);
+if (cny <250)
+    { Serial.println("0");}
+    else {  Serial.println(" 1");}
+    Serial.print(" valeur cny70 : ");
+    Serial.print(cny,DEC);
+      delay(1000);
+}
+</source>
+=={{Vert|Test bouton+ leds}}==
+<source lang=c>
+//ajout des librairies
+#include <Wire.h>
+#include <Adafruit_MCP23008.h>
+Adafruit_MCP23008 mcp;
+float cny;
+void setup() {
+  // adresse du bus
+  Serial.begin(9600);
+  mcp.begin(7); // Utilisation de l'adresse "0" par défaut
+  // on choisit 7 car après le scan i2c l'adresse est 0x027
+  // E/S
+  mcp.pinMode(4, INPUT); // mise en entrée
+  //capteur cny70
+  mcp.pinMode(0, OUTPUT);//mise en sortie
+  //led jaune
+  mcp.pinMode(1, OUTPUT);
+  //led verte
+  mcp.pinMode(2, OUTPUT);
+  //led rouge
+}
+void loop() {
+    cny= mcp.digitalRead(4);
+if (cny <1)
+    { Serial.println("0");
+    mcp.writeGPIO(0xFD);
+    mcp.writeGPIO(0xFE);
+     mcp.writeGPIO(0xFB);
+    }
+//allume les leds sit la valeur du capteur cy est 0
+        else {  Serial.println(" 1");
+    mcp.writeGPIO(0xFF);
+    // éteint tout les leds si sny = 1
+    }
+}
+</source>
+Pour vérifier fonctionnement du CNY70, il faut utiliser un appareil numérique qui perçoit les IR <br>
 <br>
-[[Fichier:BATAKSchematicLED.PNG]]
+[[Fichier:Videobatak1.PNG|800px]]<br>
+{{Rouge|'''Voir ci-dessous le lien pour voir la vidéo du programme:''' <br>
+Le programme Arduino permet d'allumer les LEDS quand le bouton est appuyé. <br>}}
+https://www.youtube.com/watch?v=EKHmDXdy9Tg
+=={{Vert|Interface de jeu en utilisant processing}}==
+<source lang=c>
+//******************************************* Déclaration des variable *****************************************************
+//cercle 1
+float xCercle1 =400 ;
+float yCercle1 = 400;
+float RayonCercle1 = 200;
+//cercle 2
+float xCercle2 = 400;
+float yCercle2 = 400;
+float RayonCercle2 = 220;
+//Led Rouge
+float xLedRouge = 185;
+float yLedRouge = 160;
+float RayonLedRouge = 80;
+//Led Jaune
+float xLedJaune = 393;
+float yLedJaune = 160;
+float RayonLedJaune = 80;
+//Led Verte
+float xLedVerte = 600;
+float yLedVerte= 160;
+float RayonLedVerte = 80;
+//***********************************Fonction SETUP******************************************************
+void setup()
+{
+  size(800, 800);
+}
+//*********************************Fonction loop******************************************************
+void draw ()
+{
+  background( 30, 60, 70);
+  smooth();
+  // calcule de la distance entre la position de la souris et le centre du bouton
+  float distance = sqrt(((mouseX-xCercle2)*(mouseX-xCercle2))+((mouseY-yCercle2)*(mouseY-yCercle2)));
+  noStroke();
+  //bouton central
+  fill (76, 58, 58);
+  ellipse(xCercle2, yCercle2, RayonCercle2, RayonCercle2);
+  // second bouton contour
+  fill (78, 89, 80);
+  ellipse(xCercle1, yCercle1, RayonCercle1, RayonCercle1);
+  stroke(1);
+  //Led rouge
+  fill (78, 89, 80);
+  ellipse(xLedRouge, yLedRouge, RayonLedRouge, RayonLedRouge);
+  //Led Jaune
+  fill (78, 89, 80);
+  ellipse(xLedJaune, yLedJaune, RayonLedJaune, RayonLedJaune);
+  //Led Verte
+  fill (78, 89, 80);
+  ellipse(xLedVerte, yLedVerte, RayonLedVerte, RayonLedVerte);
+  //rectangle
+  rect(193, 702, 424, -122);
+  fill(0);
+  rect (205, 691, 400, -100);
+  // change le bouton de couleur lorsqu'il est appuyé
+  if (mousePressed && distance <= (RayonCercle2/2)  ) {
+    // le bouton devient vert
+    noStroke();
+    fill (25, 123, 50);
+    ellipse(xCercle1, yCercle1, RayonCercle1, RayonCercle1);
+    stroke(1);
+    //Led rouge
+    fill (215, 10, 10);
+    ellipse(xLedRouge, yLedRouge, RayonLedRouge, RayonLedRouge);
+    //Led Jaune
+    fill (255, 255, 0);
+    ellipse(xLedJaune, yLedJaune, RayonLedJaune, RayonLedJaune);
+    //Led Verte
+    fill (0, 208, 35);
+    ellipse(xLedVerte, yLedVerte, RayonLedVerte, RayonLedVerte);
+    fill (255, 255, 255);
+    textSize(40);
+    text("Bouton appuyé", 265, 650);
+  }
+  print("X=");
+  println(mouseX);
+  print("Y=");
+  println(mouseY);
+  println("");
+  println("");
+}
+</source>
+<br>
+=={{Vert|programmation avec raspberry pi 2}}==
+<source lang=c>
+#include <time.h>
+#include <stdio.h>
+#include <wiringPi.h>
+#include <mcp23008.h>
+#include <sys/time.h>
+int main (void)
+{
+  struct timeval tval_before, tval_after, tval_result;
+  wiringPiSetup () ;
+  mcp23008Setup (100, 0x27) ;
+  printf ("Raspberry Pi - MCP23008 Test\n") ;
+  pinMode         (100, OUTPUT) ;
+  pinMode         (101, OUTPUT) ;
+  pinMode         (102, OUTPUT) ;
+  pinMode         (104, INPUT) ;
+  digitalWrite (100, 1) ;
+  digitalWrite (101, 1) ;
+  digitalWrite (102, 1) ;
+   for (;;)
+  {
+    int cny;
+    digitalWrite (100, 1) ;
+    digitalWrite (101, 1) ;
+    digitalWrite (102, 1) ;
+    delay(3000);
+    cny=digitalRead (104);
+    gettimeofday(&tval_before, NULL);
+    digitalWrite (100, 0);
+    digitalWrite (101, 0);
+    digitalWrite (102, 0);
+    while ( cny == 1)
+{
+    cny=digitalRead (104);
+}
+   gettimeofday(&tval_after, NULL);
+   timersub(&tval_after, &tval_before, &tval_result);
+   printf("Time elapsed: %ld.%06ld\n", (long int)tval_result.tv_sec, (long int)tval_result.tv_usec);
+delay(2000);
+cny=digitalRead (104);
+while ( cny == 0)
+{
+    printf(" Release the button please.\n");
+    delay(500);
+    cny=digitalRead (104);
+}
+  }
+  return 0 ;
+}
+</source>
+<br>
+=={{Vert|Programme(s) à réaliser}}==
+*Par la suite l'interface processing sera relié à une programme Arduino <br>
+*Suite au projet batak une interface sera réalisé, les différents éléments de cette interface seront:<br>
+**Les différents modes de jeux<br>
+**le temps qu'il reste à jouer<br>
+**le score obtenu<br>
+={{Rouge|Utilisation de Charly robot pour détourage/perçage}}=
+Il existe façons d'utiliser Charlyrobot pour détourer ou bien pour percer une carte électronique.<br>
+Les étapes à réaliser sont les suivantes: <br>
+=={{Bleu|Préparation des fichiers sur eagle}}==
+==={{Vert|Pour le contour}}===
+{|
+|-
+|[[Fichier:Dxf.PNG|gauche]]||
+*Pour obtenir ce type de fichier il faut ouvrir le fichier board (.brd) sur Eagle.
+*Pour commercer il faut tout désélectionner (dans Layer Settings) sauf la couche contour.
+* Il doit donc rester à l'écran uniquement le parcours de la fraise lors du détourage du PCB.
+<br>
+*On génère ensuite un fichier DXF à partir de cette vue :<br>
+-avec la version eagle 6 : File -> export -> DXF<br>
+- avec la version eagle 6 : File -> export -> dxf<br>
+- avec la version eagle 5 : ULP -> dxf<br>
+*Il faut décocher les différentes options:
+- Always vector font<br>
+- Use wire widths<br>
+- Fill areas<br>
+|}
+==={{Bleu|Perçage}}===
+{|
+*Pour générer le fichier de perçage, il faut lancer l'outil '''CAM processor'''.
+*Ouvrir un nouveau '''job''',choisir '''excellon.cam'''.
+*Ajuster les paramètres en désélectionnant '''pos_Coord''', pour ne pas avoir un décalage entre contour et perçage
+*Puis il faut cliquer sur '''process job''' → Cela permet de trouver le fichier '''.drd''' dans le répertoire du projet eagle.
+|-
+| [[Fichier:Cam.PNG|gauche]]
+ [[Fichier:Job.PNG|gauche|]]
+|-
+| [[Fichier:Exc.PNG|gauche|]] ||
+|}
+=={{Bleu|Préparer le fichier "charlyRobot" avec '''Target'''}}==
+==={{Bleu|Nouveau projet}}===
+Ouvrir '''Target''' et créer un nouveau projet:
+ créer un board (1 face sans schéma)
+==={{Bleu|Contour}}===
+On commence par importer le fichier de contour :
+{|
+|-
+| [[Fichier:TargetDXF.png|gauche|400px]] || Dans le menu :
+Fichier -> Utilitaires:Import-EXport -> Importer en format DXF
+Sélectionner le fichier DXF créé avec Eagle
+Choisir les options d'importation comme indiqué ci contre.
+|}
+==={{Bleu|Perçage}}===
+{|
+|-
+| [[Fichier:TargetExcellon.png|gauche|600px]] || Dans le menu :
+Fichier -> Utilitaires:Import-EXport -> Importer des fichiers XGERBER/EXCELLON
+Sélectionner le fichier ".drd" créé avec Eagle
+Choisir les options d'importation comme indiqué ci contre.
+|}
+==={{Bleu|Fichier charlyRobot}}===
+On va exporter un fichier de fabrication (type *.pcb) export-> production-> fichier gravure par fraisage
+{|
+|-
+| [[Fichier:TargetCharly1.png]]
+|-
+| [[Fichier:TargetCharly2.png]]
+|-
+| [[Fichier:TargetCharly3.png]]
+<br>
+*Modifier les paramètres des fenêtres tel qu'indiqué sur les captures d'écran.
+*Se rendre ensuite dans l'onglet "Résultat" et lancer la création du fichier ".pcb"
+|}
+===Fabrication avec GPILOTE===
+*Sur une perceuse manuelle, faire les trous de centrage sur la carte aux emplacements prévus, avec un forêt de 3mm.
+*Positionner la carte dans la machine à l'aide des "piges" et en fixant un morceau de scotch double face sous la carte. Il n'est pas nécessaire et même déconseillé de recouvrir entièrement la carte de scotch.
+*Attention au sens : Mettre le cuivre au dessus (visible) si vous avez, comme indiqué plus haut, sélectionné "Face soudure cuivre seulement" lors de la production du fichier pour charlyRobot
+*Lancer le logiciel GPILOTE.
+*Charger votre fichier ".pcb"
+*Normalement la machine est déjà préréglée
+*Suivre les instructions
+**Le logiciel doit vous demander d'insérer le premier outil
+**Le premier outil à insérer devrait être en toute logique un foret
+**Attention, si le logiciel ne le demande pas, il faut toujours faire une mesure de l'outil
+**Le logiciel est prêt et doit proposer de lancer le cycle d'usinage
+**Fermer le capot avant de commencer
 <br>
+={{Rouge|Raspberry Pi 2}}=
+Le Raspberry Pi est un nano-ordinateur monocarte à processeur ARM conçu par le créateur de jeux vidéo David Braben, dans le cadre de sa fondation Raspberry Pi.
+Cet ordinateur, qui est assez petite (taille d'une carte de crédit), est destiné à encourager l'apprentissage de la programmation informatique et permet l'exécution de plusieurs variantes du système d'exploitation libre comme GNU/Linux et des logiciels compatibles. Il est fourni avec la carte mère seule, sans boîtier, alimentation, clavier, souris ni écran, dans l'objectif de diminuer les coûts et de permettre l'utilisation de matériel de récupération.
+<br>
+<br>
+Modèle de carte: Rasperry Pi 2 modèle B<br>
+Branchement à faire pour utiliser l'I2C<br>
+Il faut utiliser les ports:<br>
+- GND<br>
+-VCC (3.3V ou 5V selon utilisation)<br>
+- SDA<br>
+- SDL<br>
+=={{Bleu|Présentation générale de la carte:}}==
+[[Fichier: Rsp.PNG]]<br>
+<br>
+Le Raspberry Pi 2 Modèle B est la deuxième génération Raspberry Pi. Elle a remplacé l'original Raspberry Pi 1 Modèle B +.<br>
+Par rapport à la Raspberry Pi 1, il a:<br>
+*A 900 MHz quad-core ARM Cortex-A7 CPU<br>
+*1 Go de RAM (1GB RAM)<br>
+Comme le (Pi 1) Modèle B +, on a aussi:<br>
+*4 ports USB<br>
+*40 broches GPIO<br>
+*port HDMI complet<br>
+*port Ethernet<br>
+*jack 3,5 mm audio combinée et vidéo composite<br>
+*l'interface de l'appareil photo (CSI)<br>
+*L'interface d'affichage (DSI)<br>
+*Micro SD slot pour carte<br>
+*cœur graphique VideoCore IV 3D <br>
+Il dispose d'un processeur ARMv7, il peut fonctionner toute la gamme des distributions ARM GNU / Linux, y compris Snappy Ubuntu Core, ainsi que Microsoft Windows 10. Le Raspberry Pi 2 a une forme identique facteur à la précédente (Pi 1) Modèle B + et a une compatibilité totale avec Raspberry Pi 1.Le Raspberry Pi 2 Modèle B offre une plus grande souplesse que le (Pi 1) Modèle A + , ce qui est plus utile pour les projets et les projets intégrés qui nécessitent une très faible puissance.<br>
+[[Fichier: Gp.PNG]]<br>
+L'interface I2C est un standard très utilisé conçu pour permettre à un circuit intégré
+de communiquer avec une autre (maître et esclave). <br>
+Raspberry Pi est capable de dialoguer en I2C, on peut donc connecter une
+grande variété de composants et modules supportant le protocole I2C. <br>
+=={{Bleu|Utilisation de la carte:}}==
+Identification des différents modèles de Raspberry (en complément à ci-dessus)<br>
+La commande suivante permet de retourner les informations concernant le processeur de la Raspberry Pi:
+<source lang=c> cat /proc/cpuinfo
+</source>
+=={{Bleu|Équipements supplémentaires}}==
+==={{Vert|Équipements minimum}}===
+Le Raspberry Pi ne comprend pas :<br>
+*D'écran. Un écran ou un téléviseur peuvent être connectés via les sorties HDMI et Composite (sauf si un convertisseur dynamique est utilisé, les écrans VGA sont incompatibles) ;
+*De clavier / de souris. Pour l'utiliser, il faut donc le connecter à ces deux périphériques, via la prise USB
+Le modèle A n'offrant qu'un unique port USB, il faudra utiliser un Hub USB, ou un clavier intégrant un dispositif de pointage (trackball, trackpad, trackpoint) ou bien comprenant un port USB. Le dispositif de pointage (voire le clavier) ne sont cependant pas indispensables pour toutes les applications : serveur, utilisation d'autre type d'interface (manette, reconnaissance vocale, etc.). Sous Raspbian, le protocole SSH est actif par défaut, et le Raspberry Pi peut être contrôlé à distance dès le premier démarrage, sans avoir besoin d'un clavier ou d'une souris supplémentaire.
+*De carte mémoire SD contenant un système d'exploitation compatible. Dans un but d'économie, toute carte SD est compatible, la classe 6 étant néanmoins recommandée
+et les fichiers systèmes nécessaires seront disponibles en téléchargement gratuit. Il est ainsi possible de recycler d'anciennes cartes mémoire de capacité modeste pour utilisation avec le Raspberry Pi
+*De boîtier. Ceux-ci sont proposés en option ou en lot
+*D'alimentation. Le Raspberry Pi est compatible avec de nombreuses alimentations, micro-USB étant par exemple une norme pour les téléphones mobiles récents en Europe. Encore une fois, recyclage ou achat local sont l'objectif
+*D'horloge matérielle, dit composant HTR (le terme anglais est RTC : real time clock). La fondation justifie ce choix par le coût excessif du composant par rapport au budget initial très serré. La fondation suggère d'utiliser par exemple un composant GPS, qui contient une HTR très précise. Ce composant peut être branché via la prise GPIO. Il est aussi possible de synchroniser le temps du système grâce au protocole de réseau NTP, ce qui implique de se connecter via un réseau à un service NTP qui fonctionne soit sur un ordinateur sur Internet, soit sur un ordinateur d'un réseau local, ce dernier ordinateur devant être capable de se synchroniser avec une référence NTP sur Internet.
+==={{Vert|Équipements utilisant l'USB}}===
+Il est possible de connecter le Raspberry Pi avec :<br>
+*Pour le modèle A, une carte réseau Ethernet ou Wi-Fi, pour établir une connexion en réseau, notamment avec Internet.Le modèle B introduit durant l'été 2011 comporte une carte Ethernet intégrée.
+*Des unités de stockage externe, clés USB ou disques durs alimentés séparément
+*Tout autre périphérique USB disposant d'un pilote informatique compatible : clé Bluetooth, clé Wi-Fi, mémoire flash, imprimante, webcam<br>
+La fondation Raspberry Pi proposera à la vente une palette de périphériques validés compatibles. D'autres périphériques seront possibles, mais la disponibilité d'un pilote informatique adéquat, compatible avec le processeur, le système d'exploitation, le circuit d'interface, et le périphérique lui-même, devra être scrupuleusement vérifiée.
+==={{Vert|Équipements utilisant les ports séries}}===
+Ces ports permettront l'interfaçage avec d'autres circuits, pour la réalisation de projets électroniques, robotiques, physiques (par exemple, émettre en FM grâce à piFM).
 <br>
+=={{Bleu|Utilisation de Raspberry Pi 2:}}==
+[[Fichier:Port.PNG|800px]]
+==={{Vert|Lier arduino et raspberry via le bus I2C}}===
+Raspberry et Arduino ne sont pas opposés, ils ont des points communs et chacun a des avantages qui peuvent être bon de combiner.<br>
+[[Fichier:Imglg.PNG]]
 <br>
-[[Fichier:BATAKBoardCapteur.PNG]]
+Avec le Raspberry Pi on peut via les ports GPIO contrôler des composants externes et faire des projets en électronique. Pour lier les deux, on doit passer par le protocole I2C.<br>
+Plusieurs raisons à ça :
+*ne pas utiliser le port USB, le Raspberry Pi étant limité
+*ne pas utiliser le port série
+Le protocole I2C, avec une orientation domotique, permet à plusieurs composants de dialoguer entre eux de manière bidirectionnel mais en half-duplex uniquement.
+Il y a un principe de maitre et esclave. On utilise le Raspberry Pi en tant que maitre et l’Arduino en tant qu’esclave. Avant tout pour connecter les deux appareils il faut savoir quelles broches il faut utiliser. Pour le raspberry c’est sur les GPIO 2 et 3 (pour les cartes à partir du modèle B révision 2, ceux avec les trous de fixation dans la carte).
+==={{Vert|Configurer I2C}}===
+L'interface I2C est un standard très utilisé conçu pour permettre à un circuit intégré de communiquer avec une autre. Puisque Raspberry Pi est capable de dialoguer en I2C, nous pouvons donc connecter une
+grande variété de composants et modules supportant le protocole I2C.<br>
+Voici quelques projets qui utilisent des modules et composants I2C:<br>
+-GPIO Expander pour Raspberry Pi Ajouter des entrées/sorties digitales à votre Pi.<br>
+-Afficheur 16x2 lignes + Keypad pour Raspberry Pi<br>
+-Support RTC DS1307 (horloge temps réel) pour Raspberry PI<br>
+-Contrôleur LED (Led Backpack) pour afficheur 4x7 segments et matrice LED<br>
+-MCP4725 Convertisseur Digital Analogique 12-Bit<br>
+-Controleur PWM/Servo 16 canaux pour Raspberry Pi<br>
+-Mesure de pression avec le BMP085<br>
+Si on utilise Occidentalis, alors vme Pi est déjà prêt à supporter I2C (pour autant qu'il soit possible au programme d'accéder au broches matérielles).
+Par contre, si on utilise Raspbian, on aura besoin d'ouvrir LX Terminal et d'encoder la commande suivante:
+ <nowiki>sudo nano /etc/modules</nowiki>
+et d'ajouter les deux lignes suivantes à la fin du fichier
+ <nowiki>i2c-bcm2708
+i2c-dev</nowiki>
+==={{Vert|Descrption}}===
+L'interface I2C est un standard très utilisé conçu pour permettre à un circuit intégré
+de communiquer avec une autre (maître et esclave).
+Raspberry Pi est capable de dialoguer en I2C, on peut donc connecter une
+grande variété de composants et modules supportant le protocole I2C.
+Si on utilise Occidentalis, alors le Pi est déjà prêt à supporter I2C (pour autant qu'il soit possible au programme d'accéder au broches matérielles).
+Par contre, si on utilise Raspbian, on aura besoin d'ouvrir LX Terminal et d'encoder la commande suivante:
+sudo nano /etc/modules
+et d'ajouter les deux lignes suivantes à la fin du fichier
+i2c-bcm2708
+i2c-dev
 <br>
+Après la modification du fichier, on doit  redémarrer (c’est-à-dire rebooter) le Pi pour les modifications soient ainsi appliquées.
+Si on a des problèmes I2C avec le Raspbian, il est préférable de passer à la toute dernière version.
+Le bus I2C permet à plusieurs périphériques d'être connecté sur le Raspberry Pi, chacun avec une adresse unique. Cette adresse unique peut souvent être modifiée sur le module à l'aide de cavalier (ou bien de pontage à souder pour réaliser des connexions).
+Il est très utile de pouvoir visualiser les appareils qui sont connectés au Pi.  Cela est très pratique afin de s'assurer que tout fonctionne correctement.
+Pour effectuer cette étape il faut installer des utilitaires I2C, il est préférable d'utiliser la commande suivante dans un terminal pour les installer
+sudo apt-get install python-smbus
+sudo apt-get install i2c-tools
+Après installation , on peut taper la commande suivantes pour voir tous les périphériques connectés (si on utilise un Raspberry Pi Modèle B 512MB)
+sudo i2cdetect -y 1
 <br>
+Cela montre deux adresses I2C en cours d'utilisation – 0x40 et 0x70.
+Il faut noter que si on utilise l'un des premiers modèle de Raspberry Pi (Raspberry Pi Modèle B 256MB ) alors on aura besoin de changer la commande comme suit:
+sudo i2cdetect -y 0
+En effet, les concepteurs du Raspberry Pi ont modifié le brochage du port I2C entre les deux "release" de Raspberry.
+Pi B et Pi B+: la compatibilité du GPIO
+Avec l'arrivée du Raspberry Pi-3, Raspberry Pi-2 et Raspberry Pi-B PLUS, vient également un GPIO étendu de 40 broches rétro-compatible avec le GPIO des premières générations du Raspberry-Pi qui ne comportait que 26 broches.
+	On remarque que les 26 premières broches du GPIO sont  identiques entre le Raspberry-Pi modèle B et le Raspberry-Pi 3, Pi 2 (ou Pi B+), tout sur le GPIO du modèle B fonctionnera à l'identique autant sur un modèle B+, ou bien le Pi 2 ainsi que le Pi 3.
 <br>
-[[Fichier:BATAKSchematicCapteur.PNG]]
-</center>
+La seule vraie différence réside dans la longueur du GPIO du modèle Pi-3, Pi-2 ou B+ qui contient des broches en plus. et le Pi-Cobbler PLUS qui à également grandi pour accueillir les broches en plus.
+Avec l'apparition du Pi Zero, nous pouvons reparler de la correspondance des GPIO.
+ le GPIO du Pi Zero et du Pi 3 (ou Pi 2) sont identiques
+<br>
+Brochage
+Voici le nom des broches du bus I2C matériel et leurs positions sur le GPIO.
+Les 26 premières broches étant identiques entre le modèle Pi B et Pi B+, le schéma ci-dessous s'applique donc aussi à votre Pi PLUS .
+<br>
+Les ports I2C sont :
+•	SDA - Broche 3 - GPIO #0 (Ligne de donnée du Bus I2C, DATA)
+•	SCL - Broche 4 - GPIO #1 (Ligne du signal d'horloge du BUS I2C,  CLOCK et son diminutif CL ou CLK)
+Alors le Raspberry Pi et l’Arduino ne sont pas forcement aussi opposés, avec même des points communs mais chacun à des avantages qui peuvent être bons de combiner.
+Avec le Raspberry Pi on peut via les ports GPIO contrôler des composants externes en électronique.
+Par conséquent pour lier Raspberry et Arduino, on passe par le protocole I2C. Plusieurs raisons à ça : ne pas utiliser le port USB, le Raspberry Pi étant limité . Et ne pas utiliser le port série. Ici c’est un peu plus personnel, car j’ai une carte Slice Of Pi sur un Raspberry pour la station météo et elle utilise le port série pour les sondes sans fil.
+Le protocole I2C, créé par Philips avec une orientation domotique, permet à plusieurs composants de dialoguer entre eux de manière bidirectionnel mais en half-duplex uniquement.
+Il y a un principe de maitre et esclave. Ici nous va donc utiliser le Raspberry Pi en tant que maitre et l’Arduino en tant qu’esclave.
+Avant tout pour connecter les deux appareils il faut savoir quelles broches utiliser !
+Pour le raspberry c’est sur les GPIO 2 et 3 (pour les cartes à partir du modèle B révision 2, ceux avec les trous de fixation dans la carte)
+<br>
+Pour l’Arduino, ça se passe sur les broches A4 et A5 pour les cartes de type Arduino Uno.
+<br>
+Il faudra ajouter une connexion à la masse entre les deux. Donc vous aurez besoin de trois fils.
+Avant de connecter les deux appareils, il faut s’assurer qu’ils vont pouvoir communiquer. Toutes les informations sont sur le site d’adafruit mais en gros, voici ce qu’il faut faire.
+Définir l’Arduino comme esclave
+C’est relativement simple en incluant le module Wire dans le programme. On prend  l’adresse 0x12 mais vous pouvez choisir de 0x03 à 0x77 (en hexa) :
+#include <Wire.h>
+#define SLAVE_ADDRESS 0x12
+int dataReceived = 0;
+void setup() {
+    Serial.begin(9600);
+    Wire.begin(SLAVE_ADDRESS);
+    Wire.onReceive(receiveData);
+    Wire.onRequest(sendData);
+}
+void loop() {
+    delay(100);
+}
+void receiveData(int byteCount){
+    while(Wire.available()) {
+        dataReceived = Wire.read();
+        Serial.print("Donnee recue : ");
+        Serial.println(dataReceived);
+    }
+}
+void sendData(){
+    int envoi = dataReceived + 1;
+    Wire.write(envoi);
+}
+, le programme initialise l’Arduino avec l’adresse 0x12, définit la méthode de réception des données, la méthode d’envoi des données et c’est parti pour l’envoyer vers la carte avec l’interface.
+Activer la gestion I2C sur le Raspberry Pi
+Par défaut, des distributions de type Raspbian désactivent la gestion I2C pour économiser la mémoire utilisée par le module. Pour réactiver, rien de plus simple et c’est dans le fichier /etc/modprobe.d/raspi-blacklist.conf. Il faut mettre en commentaire avec un # la ligne :
+blacklist i2c-bcm2708
+Reste à activer le module lors de chaque démarrage. C’est dans le fichier /etc/modules, en y ajoutant à la fin une nouvelle ligne :
+i2c-dev
+Ensuite vous installez la suite des outils de gestion I2C
+apt-get install i2c-tools
+Il va vous falloir redémarrer le Raspberry pour faire apparaitre deux fichiers :
+<br>
+Grâce à eux vous allez pouvoir communiquer sur le bus I2C !
+Vous pouvez lister les périphériques avec la commande :
+i2cdetect -y 1
+Pour les modèles 256Mo (comme celui que j’utilise pour mes tests) :
+i2cdetect -y 0
+Voilà. Etape suivante : connecter l’Arduino et lui parler !
+Communiquer avec l’Arduino
+Vous pouvez maintenant relier l’Arduino au Raspberry et allumer tout ce petit monde !
+Attention, sur le schema, le raccordement SDA et SCL est inversé ! Le rouge en A5 et le balnc va en A4
+<br>
+Une fois fait, vous vous connectez sur le Raspberry Pi et vous relancez la commande i2cdetect avec le bon paramètre :
+<br>
+Le paramètre défini dans le sketch envoyé à l’Arduino, 0x12, apparait dans les périphériques détectés. On progresse !
+Il nous faut maintenant mettre en place le script sur le Raspberry Pi qui va envoyer/recevoir avec l’Arduino. Pour cela, le plus simple c’est d’installer le support d’I2C dans les scripts Python. C’est ce que va faire python-smbus
+apt-get install python-smbus
+Nous sommes donc maintenant équipé pour parler à notre Arduino. Pour ça un petit programme tout simple. Envoyer un chiffre entre 0 et 8 et nous retourner ce chiffre plus un :
+import smbus
+import time
+# Remplacer 0 par 1 si nouveau Raspberry
+bus = smbus.SMBus(0)
+address = 0x12
+print "Envoi de la valeur 3"
+bus.write_byte(address, 3)
+# Pause de 1 seconde pour laisser le temps au traitement de se faire
+time.sleep(1)
+reponse = bus.read_byte(address)
+print "La reponse de l'arduino : ", reponse
+Le résultat de l’exécution :
+<br>
+={{Rouge|Annexes}}=
+[[Fichier:Bran.PNG]]<br>
+Montage avec pull-up
+<br>
+[[Fichier:Cartebtk.PNG]]<br>
+Version 2 à gauche, version 1 à droite<br>
+[[Fichier:Cnytest.PNG]]<br>
+test du capteur CNY70
+<br>
+[[Fichier:Ledres.PNG]]<br>
+Montage choix résistances pour LEDS
+<br>
+[[Fichier:Oscss.PNG]]<br>
+Visualisation de SDA et SCL à l'oscillo (SDA en jaune/ SCL en Bleu)
+<br>
+[[Fichier:sdascl.PNG]]<br>
+Montage pour visualisation signaux SDA et SCL
+<br>
+[[Fichier:Gpilote.PNG|1200px]]<br>
+Interface de Gpilote pour détourage et perçage
+<br>
+[[Fichier:Mill.PNG]]<br>
+Utilisation de Milling sur eagle pour définir contour carte
+<br>
+[[Fichier:Perçage.PNG]]<br>
+Trou de perçage (obtenu avec Target)
+<br>
+[[Fichier:Target.PNG|1200px]]<br>
+Préparation fichier détourage/perçage avec Target
+<br>
+liens utiles:<br>
+*http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/pedagogiques/4346/4346-6-rpi-i2c.pdf
+*http://innovelectronique.fr/2013/03/02/utilisation-du-bus-i2c-sur-raspberrypi/
+*http://mchobby.be/wiki/index.php?title=Rasp-Hack-GPIO_Configurer_I2C
+*http://www.pihomeserver.fr/2013/08/13/raspberry-pi-home-server-arduino-lier-les-deux-via-bus-i2c/

Catégorie:Batak : Différence entre versions

Version actuelle datée du 30 mai 2016 à 07:01

Sommaire

Projet ER Semestre 3 : BATAK

Présentation

Principe de fonctionnement

Diagramme de Gantt

Fabrication de la carte

Vérifications préliminaires

Vérification des pistes

Mise en place des composants CMS

Soudures

Soudure des vias

Soudure des composants traversants

Perçage, découpage et soudure

Présentation du la connexion via le bus I2C

(Cahier des charges)

Conception

Entrées/Sorties

Documents ressources

Etudes préliminaires

Choix des résistances

Calcul résistance pour LEDs (carte voyant)

Calcul résistance pour LEDs (carte capteur)

Choix branchements des LEDs

Anode commune

Cathode commune

Choix pour branchement avec entrées analogiques du MCP23008

Première solution: utilisation de switch

Deuxième solution: utilisation de résistances

Troisième solution: utilisation de jumpers

Étude du CNY70

Présentation du bouton batak

Le bouton(cahier des charges)

Détection de la position du bouton

Fabrication

Première version de la carte

Nomenclature: carte capteur

Nomenclature: carte voyant

Tableau de transcodage

Deuxième version de la carte

Nomenclature: carte capteur

Nomenclature: carte voyant

Tableau de transcodage

Schematic(s) et board(s)

Version 1

Version 2

Tests

Programmation

Programme de scan d’adresse

Test batak version 1

Test batak version 2

Test bouton+ leds

Interface de jeu en utilisant processing

programmation avec raspberry pi 2

Programme(s) à réaliser

Utilisation de Charly robot pour détourage/perçage

Préparation des fichiers sur eagle

Pour le contour

Perçage

Préparer le fichier "charlyRobot" avec Target

Nouveau projet

Contour

Perçage

Fichier charlyRobot

Fabrication avec GPILOTE

Raspberry Pi 2

Présentation générale de la carte:

Utilisation de la carte:

Équipements supplémentaires

Équipements minimum

Équipements utilisant l'USB

Équipements utilisant les ports séries

Utilisation de Raspberry Pi 2:

Lier arduino et raspberry via le bus I2C

Configurer I2C

Descrption

Annexes

Menu de navigation

Rechercher