Le Monde de GrandDiego

Un moniteur série (UART) matériel avec Arduino

noreply@blogger.com (Unknown) — Sat, 24 Dec 2016 17:04:00 +0000

Une liaison série UART permet une communication entre deux systèmes électroniques, elle est par exemple utilisée par votre carte Arduino lors de l'envoie du programme ou lors de la communication avec un ordinateur.

Schéma d'une communication UART

Dans le logiciel Arduino IDE, le "moniteur série" permet de savoir ce qu'il se passe sur la liaison série matérielle de l'Arduino. Dans le cas de l'Arduino UNO par exemple, la liaison série matérielle se trouve sur les entrées/sorties 0 (broche de réception) et 1 (broche de transmission), et elle est utilisée notamment pour l'envoie d'un programme au microcontrôleur.

Imaginons que vous êtes en train de réaliser un système électronique, mettant en jeu un microcontrôleur et une puce GSM, ou encore GPS (en effet les modules GSM et GPS utilisés dans le monde Arduino communiquent pour la plupart via liaison série UART). Si vous désirer "écouter" ce qu'il se dit sur cette liaison, il va vous falloir soit programmer le microcontrôleur pour qu'il rapporte via un autre moyen ce qu'il se dit sur la liaison série, soit vous utilisez un autre microcontrôleur ou équipement qui va "espionner" la communication.

Voilà le projet que je veux partager avec vous dans cet article : un moniteur série matériel. Il permet de visualiser facilement et rapidement les données échangées via une liaison série sans la perturber. Il est bien sur possible de régler la vitesse de la communication (en bauds) et on peut distinguer la provenance de chacun des messages (pour savoir de quel côté de la liaison série viennent-il).

Alors comment écouter sur deux lignes séries (une liaison = deux lignes, TX et RX) en même temps à l'aide d'un Arduino ? L'Arduino UNO ne possèdent qu'une seule liaison série matérielle, donc une seule broche de réception (nommée RX). On pourrait utiliser un port série logiciel (software serial) mais j'ai préféré employer la solution de facilité et simplement utiliser un microcontrôleur disposant de deux ports série matériels : le ATMega644.

Ce microcontrôleur présente d’autres intérêts par rapport au traditionnel ATMega328 équipant l'Arduino UNO :

	ATMega328	ATMega644
Flash [ko]	32	64
RAM [ko]	32	64
ROM [ko]	1	2
IO	23	32
ADC	8	8

Les trois types de mémoire ont le double de capacité et il dispose aussi d'un plus grand nombre d'entrée/sortie pour un prix "seulement" deux fois supérieur à l'ATMega328.

Ce microcontrôleur existe dans un boitier DIP facilement utilisable avec une breadboard par exemple mais j'ai préféré faire fabriquer une petite carte pour l'accueillir.

Photo de la carte pour l'ATMEGA644 nue

Cette simple carte accueille l'ATMEGA644 (ou l'ATMEGA1284, ces deux sont compatibles) ainsi qu'une alimentation, un circuit de Reset et un cristal à 16MHz.

Photo de la carte pour l'ATMEGA644 assemblée

J'utilise ensuite un écran LCD de type ILI9341 pour afficher de différentes couleurs les messages venant des deux lignes séries surveillées.

Photo de l'écran d'affichage

J'ai monté tout ça sur une carte à trou avec deux interrupteurs pour désactiver à la demande l'affichage d'une des deux lignes de la communication série (pour n'écouter qu'un seul coté de la liaison par exemple), un bouton permettant de parcourir les différentes vitesse de communication (en bauds) et deux LED pour afficher sur quelle ligne série a eu lieu la dernière communication.

Photo du système

J'ai placé un tampon à base d'amplificateurs opérationnels en montage suiveur sur les deux lignes séries pour qu'il n'y ait aucunes chances qu’elles soient perturbées par "l'espion".

Schéma du double AOP LM358 configuré en deux montages suiveurs

Il me suffit donc d'alimenter ma carte en 5V et je peux ensuite surveiller une liaison série UART sans la perturber.

Il est sans doute largement possible d'améliorer le montage par exemple avec une carte SD pour enregistrer les données de communication etc... Mais ce petit montage m’a suffi pour faire fonctionner le module GSM que je souhaitais.

Voici le programme Arduino utilisé :

#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"
#define TFT_DC 3
#define TFT_CS 4
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);

char inchar1;  //caractère entrant
char inchar2;
String message1 = ""; //message entier
String message2 = "";

const byte led1 = 0;
const byte led2 = 2;
const byte act1 = A5;
const byte act2 = A7;
const byte bp = A2;

unsigned int ixe = 11; //position x d'écriture

#include <EEPROM.h>
const byte addrEE = 52;  //on enregistre la vitesse de la communication dans la case 52

byte selbaudrate = 2; //on sélectionne 9600 bauds au début
unsigned long baudrate = 0;

void setup() {

  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(act1, INPUT_PULLUP);
  pinMode(act2, INPUT_PULLUP);
  pinMode(bp, INPUT_PULLUP);

  fctchangebaud(); //on initialise la liaison série et l'interface graphique
}

void loop() {

  if (digitalRead(bp) == LOW) {
    delay(5); //anti-rebond
    if (selbaudrate == 7) selbaudrate = 0;
    else selbaudrate++;
    EEPROM.write(addrEE, selbaudrate);
    fctchangebaud();
  }

  if(digitalRead(act1) == LOW) {

    while (Serial.available() && message1.length() < 53) {
      inchar1 = Serial.read();
      message1 += inchar1;
      delay(10);  //le temps que le prochain caractère arrive, IMPORTANT !
    }

    message1.trim();
    if (message1 != "") {
      digitalWrite(led1, LOW);
      digitalWrite(led2, HIGH);

      if (ixe > 230) {
        ixe = 11;
        tft.fillScreen(ILI9341_BLACK);
        tft.setCursor(0, 0);
        tft.setTextColor(ILI9341_WHITE);
        tft.print("SERIAL MONITOR - ");
        tft.print(baudrate);
        tft.print(" bauds");
        tft.drawLine(0, 9, 320, 9, ILI9341_WHITE);
      }

      tft.setCursor(1, ixe);
      tft.setTextColor(ILI9341_GREEN);
      tft.print(message1);
      ixe = ixe + 10;
    }
  }
  else while(Serial.available()) Serial.read();  //on vide quand même le buffer de l'autre serial

  if(digitalRead(act2) == LOW) {

    while (Serial1.available() && message2.length() < 53) {
      inchar2 = Serial1.read();
      message2 += inchar2;
      delay(10);  //le temps que le prochain caractère arrive, IMPORTANT !
    }

    message2.trim();
    if (message2 != "") {
      digitalWrite(led2, LOW);
      digitalWrite(led1, HIGH);

      if (ixe > 230) {
        ixe = 11;
        tft.fillScreen(ILI9341_BLACK);
        tft.setCursor(0, 0);
        tft.setTextColor(ILI9341_WHITE);
        tft.print("SERIAL MONITOR - ");
        tft.print(baudrate);
        tft.print(" bauds");
        tft.drawLine(0, 9, 320, 9, ILI9341_WHITE);
      }

      tft.setCursor(1, ixe);
      tft.setTextColor(ILI9341_RED);
      tft.print(message2);
      ixe = ixe + 10;

    }
  }
  else while(Serial1.available()) Serial1.read();  //on vide quand même le buffer de l'autre serial

  message1 = ""; //Vide la variable "message"
  message2 = "";
}

void fctchangebaud()  {

  Serial.end();
  Serial1.end();

  switch (selbaudrate) {
  case 0:
    baudrate = 2400;
    break;
  case 1:
    baudrate = 4800;
    break;
  case 2:
    baudrate = 9600;
    break;
  case 3:
    baudrate = 19200;
    break;
  case 4:
    baudrate = 28800;
    break;
  case 5:
    baudrate = 38400;
    break;
  case 6:
    baudrate = 57600;
    break;
  case 7:
    baudrate = 115200;
    break;
  }

  Serial.begin(baudrate);
  Serial1.begin(baudrate);

  tft.begin();
  tft.setRotation(3);
  tft.fillScreen(ILI9341_BLACK);
  tft.setCursor(0, 0);
  tft.setTextColor(ILI9341_WHITE);
  tft.setTextSize(1);
  tft.print("SERIAL MONITOR - ");
  tft.print(baudrate);
  tft.print(" bauds");
  tft.drawLine(0, 9, 320, 9, ILI9341_WHITE);

  ixe = 11;

}

Et voici le schéma électrique complet du système (cliquez pour agrandir) :

Schéma éléctrique du moniteur série matériel

A bientôt !

Liens externes :
Bibliothèque Sanguino : https://github.com/Lauszus/Sanguino
Bibliothèque ILI9341 : https://github.com/adafruit/Adafruit_ILI9341
ATMega644 : http://www.atmel.com/devices/ATMEGA644.aspx

Plusieurs boutons sur une seule entrée Arduino

noreply@blogger.com (Unknown) — Sat, 28 Nov 2015 12:05:00 +0000

Si pour un projet Arduino vous venez à manquer de broches d’entrée/sorties mais qu’il vous faut encore ajouter quelques boutons de commande, cette astuce va surement vous intéresser.

6 boutons sur 1 entrée Arduino

La technique est simple et ne nécessite pas forcément un Arduino pour fonctionner, n’importe quel microcontrôleur fera l’affaire.

On utilise un pont diviseur de tension dont une des deux résistances est en réalité un jeu de résistances de valeurs différentes qui sont connecté par le biais de boutons poussoirs.

On utilise une entrée analogique du microcontrôleur pour lire la valeur de la tension à la sortie du pont diviseur. Cette tension est bien sûr dépendante du bouton sur lequel on appui, ce dernier peux donc être retrouvé facilement grâce à quelques ligne de code.

Voici un schéma pour mieux comprendre :

Fig.1 : Schéma du pont diviseur multiple

La technique consiste alors à mesurer la valeur donnée par le convertisseur analogique-numérique du microcontrôleur pour chaque boutons poussoir.

Voilà un exemple avec un Arduino Nano (CAN 10 bits et VCC = 3,3V) :

Bouton appuyé	BP 1	BP 2	BP 3	BP 4	BP 5	BP 6	Aucun
Valeur de sortie	0	65	180	305	485	670	1023

Fig.2 : Tableau des valeurs de sortie du convertisseur analogique-numérique pour le montage de la fig.1

Il s’agit enfin de tester la valeur donnée par le CAN avec une valeur prise au milieu de l’écart de valeur entre deux boutons poussoir afin avoir une bonne marge :

Valeur = analogRead(A0);

if (Valeur< 32) Serial.println("BP 1);

else if (Valeur< 119) Serial.println("BP 2);
else if (Valeur< 232) Serial.println("BP 3;
else if (Valeur< 368) Serial.println("BP 4);
else if (Valeur< 572) Serial.println("BP 5);
else if (Valeur< 846) Serial.println("BP 6);
else if (Valeur> 846) Serial.println("Aucun");

Dans cet exemple j’affiche simplement dans la console série le numéro du bouton qui a été pressé mais libre à vous d’y faire ce que vous voulez.

6 boutons + interruption sur 2 entrées Arduino

Parfois il se peut que votre programme soit occupé par une tache, et pendant ce temps-là vous ne pouvez pas utiliser les boutons poussoirs connectés à votre microcontrôleur.

Heureusement celui-ci dispose de broches d’interruptions matérielles. Lorsque l’une d’elle est activée, au moindre changement d’état de celle-ci, le programme se met en pause pour exécuter une fonction particulière que vous pouvez définir.

Lorsque cette fonction a fini de s’exécuter le programme reprend là où il s’était arrêté.

On utilise le même montage que précédemment mais avec une porte OU à diode qui permet d’actionner l’interruption dès que l’un des boutons poussoir est pressé.

Fig.3 : Schéma du pont diviseur multiple avec diodes d’interruptions

Par exemple, pour un Arduino UNO, les broches D2 et D3 peuvent être configurés avec une interruption¹. Dans notre cas nous paramétrons l’interruption pour quelle se déclenche sur niveau bas :

attachInterrupt(0, Fonction_interruption, LOW); //interruption sur broche D2 (interrupt 0)

La fonction “Fonction_interruption()” est appelée dès que la broche D2 passe à l’état bas (LOW).

Voici le programme complet :

const byte bouton = A0; //Entrée analogique des 6 boutons
byte BP_appuye = 0; //Variable stockant le bouton appuyé

void setup() {
pinMode(bouton, INPUT); //entrée analogique des boutons réglée en entrée
attachInterrupt(0, InterruptBouton, LOW); //interruption sur pin D2 (interrupt 0)
}

void loop() {

}

void InterruptBouton() {
int ValeurBouton = analogRead(bouton);
if (ValeurBouton < 32) BP_appuye = 1;
else if (ValeurBouton < 119) BP_appuye = 2;
else if (ValeurBouton < 232) BP_appuye = 3;
else if (ValeurBouton < 368) BP_appuye = 4;
else if (ValeurBouton < 572) BP_appuye = 5;
else if (ValeurBouton < 846) BP_appuye = 6;
else if (ValeurBouton > 846) BP_appuye = 0;
}

Comme vous pouvez le voir je n’ai rien mis dans la fonction Arduino loop, à vous d’y placer votre programme.

Références :

Construction d’un système d’alarme (Partie 3)

noreply@blogger.com (Unknown) — Sat, 28 Feb 2015 22:20:00 +0000

Dans la première partie je vous avais rapidement exposé le projet tandis que dans la deuxième, j’avais fait du shoping pour trouver les composants nécessaires au module de détection de mouvement.

Dans cette troisième partie j’aimerais vous parler plus en détail du circuit imprimé, de la tentative de réduction de consommation du système et de la programmation associée.

J’avais commencé par graver moi-même un premier prototype du circuit imprimé du détecteur de mouvement grâce à la technique dont je vous avais parlé il y a quelques mois.

Figure 1 - Capture du logiciel Fritzing, circuit du détecteur de mouvements

Le cœur du circuit est un microcontrôleur Atmel ATMEGA328. Celui-ci communique avec un module radio nRF24L01+ par l’intermédiaire d’un bus SPI.

Après avoir validé ce circuit, je l’ai fait fabriquer afin que celui-ci ait une apparence plus professionnelle et soit plus résistant.

J’ai utilisé le service d’Elecrow qui m’a permis d’avoir 10 copies de cette carte pour un prix d’environ 13€.

Figure 2 - Photos recto/verso du circuit imprimé

Je voulais tester un circuit imprimé de couleur blanche, et je trouve que ça rend super bien. En revanche les pistes ne sont plus très visibles et le circuit est bien plus salissant lors de la soudure.

Monté, le circuit est identique au prototype :

Figure 3 - Photo de l'intérieur du module de détection de mouvement monté

Comme expliqué dans la partie 2, j’ai préféré utiliser plusieurs modules tout fait plutôt que de réaliser ces circuits moi-même :

· Un circuit de charge de la batterie Lithium-ion par USB

· Le circuit de traitement du signal du capteur de mouvement (PIR)

· Le circuit du module radio nRF24L01+

Cela permet de diminuer la complexité du travail et surement même d’économiser de l’argent.

Concernant la consommation du module, j’utilise maintenant la bibliothèque Arduino Low-power.

Elle me permet de faire chuter la consommation électrique grâce à un système d’interruption.

Le petit circuit du détecteur de mouvement infrarouge que j’utilise contient un circuit de traitement de signal et offre une sortie de type tout-ou-rien. C’est-à-dire que lorsque que le capteur voit quelque chose devant lui, sa sortie est à l’état 1 (5V) et s’il ne vois rien sa sortie est à 0.

Figure 4 - Photo du dos du module de détecteur infrarouge (PIR)

Cette sortie tout-ou-rien est reliée à la broche D2 du microcontrôleur Arduino. Cette broche dispose d’une fonction d’interruption, c’est-à-dire qu’elle peut réveiller l’Arduino lorsque qu’un changement d’état lui est appliqué.

L’Arduino est donc plongé dans un sommeil très peu consommateur d’énergie jusqu’à ce que le module infrarouge détecte un mouvement et fasse changer d’état cette broche d’interruption.

En utilisant la bibliothèque « sleep » standard, j’obtenais une consommation en veille de 180µA sous 4,2V. Maintenant la consommation chute à 70µA, ce qui nous fait en théorie une autonomie de 2 ans et 3 mois pour une batterie de 2Ah.

L’autonomie réelle n’attendra surement jamais ça, mais la facilité de rechargement des détecteurs (une simple prise USB comme un téléphone) l’emporte.

Elément	Consommation en veille sous 4,2V
Microcontrôleur ATMEGA328	11µA
Module radio nRF24L01+	1,8µA
Capteur PIR	57µA

Figure 5 - Consommation électrique des différents éléments du module de détections de mouvements

Le système n’est bien évidement pas toujours en veille, voici les différentes phases de fonctionnement et leur consommation associés. Je n’ai pas pu chronométrer la durée de ces phases mais elles sont extrêmement courtes :

Veille	Mouvement détecté, envoi de l’alerte	Mise en veille	Veille
70µA	240µA	170µA	70µA

Figure 6 - Phases de fonctionnements et leur consommation

Et pour finir voici le programme Arduino utilisé : Programme détecteur de mouvement.

A bientôt.

Construction d’un système d’alarme (Partie2)

noreply@blogger.com (Unknown) — Mon, 10 Nov 2014 21:15:00 +0000

Cet article est la suite de l’article Construction d’un système d’alarme (Partie1).

J’avais terminé la première partie avec une simple communication sans fil entre deux Arduino, aujourd’hui je vais vous présenter une partie de la solution matérielle que j’ai choisie ainsi qu’un prototype du logiciel.

Comme dit précédemment j’ai choisi la plateforme Arduino pour sa facilité de programmation. Les différents modules de l’alarme intègreront un microcontrôleur Atmel ATMega328. La communication sans fil se fera à l’aide de modules nRF24L01+.

Les modules capteurs de mouvement :

Les modules capteurs de mouvement seront des petits modules sans fil et autonome placé de manière stratégique dans mon habitation, j’en prévois pour l’instant 5 pour surveiller les zones proches des entrées (portes et fenêtres).

Le capteur infrarouge (P.I.R.) :

Comme je vous l’ais dis, je cherche à créer un système simple et peu cher.

Voici le capteur de mouvement que j’ai utilisé :

C’est un module de 25*35mm qui comprend un capteur infrarouge et une lentille permettant un grand angle de vision (le dôme).

Pour un lot de 10, ce genre de module me coute 0,75€ par pièce sur le site Alibaba.

Le module comprend une puce permettant de traiter le signal et de m’indiquer simplement par un 1 logique si il y a un mouvement ou par un 0 si tout est calme.

L’alimentation électrique :

Le détecteur de mouvement doit pouvoir fonctionner sans être recharger pendant plusieurs mois, pour cela j’utilise un accumulateur au lithium de type 18650.

Celui-ci délivre une tension nominale de 3,7V et possède une capacité de 2,6Ah.

Le ordinateur portables traditionnels en contiennent souvent 4 ou 8, j’ai récupéré les miens mais ils coutent environs 5€ pièce.

La consommation totale au repos est d’environ 180µA, ce qui, en théorie permettrait d’alimenter le détecteur de mouvement pendant 1 an et 8 mois. Ce fameux accumulateur est placé dans un socle adapté, acheté pour 0,50€ pour un lot de 10 sur Alibaba.

Enfin, pour recharger cet accumulateur j’utilise un petit module de charge qui accepte un câble mini-USB d’un côté et une batterie lithium de l’autre. Cela me permet de recharger très facilement ces détecteurs de mouvement.

Ce module coute 0,60€ pour un lot de 5 encore sur Alibaba.

Le boitier

Je devais choisir un boitier assez petit pour que le détecteur de mouvement reste assez discret mais assez grand pour accueillir tous les éléments.

Le boitier choisi est en plastique noir, il mesure 100*60*30mm et tous les éléments rentrent parfaitement dedans.

Ce boitier coute 1,81$ sur le site FastTech.

J’ai fait un trou rond sur le dessus pour y laisser passer la lentille du capteur infrarouge. Et un deuxième trous sur la tranche du bas pour y faire passer le port mini-USB de recharge.

J’ai essayé aussi une version blanche (dont j’ai un peu raté le trou rond du capteur infrarouge).

Le circuit électronique

Voici le schéma (moche) du système :

Comme vous pouvez le constater, j’utilise un régulateur 3,3V de type MCP1700 pour alimenter l’émetteur sans fil nFR24l01+ et le capteur infrarouge (PIR).

Le microcontrôleur en revanche est directement alimenté par l’accumulateur.

J’ai utilisé la méthode de création de circuit imprimé dont je vous avais parlé il y a quelques temps pour faire un prototype. Voilà à quoi ça ressemble après que tous les éléments soit monté :

Le programme

Le programme du capteur de mouvement est très simple :

Lorsque le capteur infrarouge (PIR) détecte un mouvement, sa sortie est à 1. Cette sortie est branchée sur le microcontrôleur, et dès que celui-ci détecte cet état logique haut, il se réveil et envoi une alerte grâce au module de communication sans fil.

Dès qu’il n’y a plus de mouvement, celui-ci envoi un deuxième message pour en informer le central. Puis il se met en veille.

Ce programme utilise la bibliothèque Arduino Mirf.

Le lien du programme Arduino : Mouvement.ino

Ce programme est bien sûr un prototype, en effet celui-ci se contente d’envoyer une simple valeur pour alerter le central.

Le test

J’ai monté un prototype du central, avec deux LED indiquant lequel des deux capteurs que j’ai construits a détecté un mouvement : (Ne faite pas attention à la carte Neoduino, c’est simplement un Arduino avec une breadboard).

Le programme répond bien et la porté est très bonne (couvre tout mon domicile).

Voilà ! C’est tout pour aujourd’hui. A bientôt pour la suite de ce projet.

Construction d’un système d’alarme (Partie1)

noreply@blogger.com (Unknown) — Sun, 19 Oct 2014 11:04:00 +0000

J’ai décidé il y a peu, de me construire mon propre système d’alarme. En plus d’un besoin de protéger mon lieu d’habitation (ou du moins de m’alerter d’une présence) je pense que ce projet me permettra d’apprendre et d’expérimenter pas mal de chose.

Mon but est d’utiliser des composants peu chers et facilement utilisables. J’ai par exemple choisi d’utiliser des microcontrôleurs AVR compatibles avec le logiciel Arduino pour me faciliter la tâche.

J’envisage différents modules qui communiqueront ensemble par radiofréquences :

Des modules de détection (chiens de garde) : capteurs de mouvement ou d’ouverture, voire de fumée.
Un module que j’appellerai « portier ». Placé à cote de la porte d’entrée, permet d’activer et de désactiver le système d’alarme.
Un central, connecté au réseau mobile pour me prévenir par SMS d’une intrusion. Relié également à une sirène extérieure.

Le chalenge est de faire des modules sans fils et, pour les modules de détection, alimentés par des accumulateurs électriques. La durée de vie de ces derniers devra être de quelques années.

Je tiens également à créer des interfaces intuitives et un système facile à utiliser pour les autres personnes de la maison.

Voici un schéma rapide du système que je compte réaliser :

Communication sans fils :

La communication sans fils se fera grâce à des modules émetteur-récepteur nRF24L01+. Ce sont des modules radiofréquences à 2,4GHz assez faciles à mettre en place et avec une très faible consommation compte tenu de leurs capacités. En plus ils ne coutent pas cher.

Ma première expérience avec ces modules a été d’allumer une LED à distance. Pour cela j’utilise deux Arduino et la bibliothèque Mirf.

Ces modules utilisent le bus SPI de l’Arduino (SCK-MOSI-MISO) et deux autres ports qui sont configurables (CE et CSN) et sont par défaut sur D9 et D10 dans la bibliothèque Mirf.

Attention ces modules peuvent être alimenté uniquement en 3,3V. Les ports d’entrée/sortie sont néanmoins compatibles avec un microcontrôleur 5V.

Comme vous l’avez peut-être remarqué ces modules nRF24L01+ sont peu pratiques à utiliser sur une plaque de prototypage (breadboard), j’ai donc fabriqué des petits adaptateurs.

Pour tester la liaison il suffit de flasher le programme d’exemple de la bibliothèque Mirf nommé « ping_server » sur le premier Arduino et « ping_client » sur le deuxième. Ouvrez ensuite un moniteur série et vous pourrez voir le délais en millisecondes qu’il y a dans la communication entre les deux Arduino.

Voila, le projet en est à ce stade aujourd’hui. J’espère pouvoir vite poster la suite.

Liens utiles :

[Arduino] Transmission valeur analogique par nRF24L01+, sur skyduino.wordpress.com

Low-Power Wireless Sensor Node, sur maniacbug.wordpress.com

nRF24L01, sur playground.arduino.cc

Créer un circuit imprimé rapidement

noreply@blogger.com (Unknown) — Sun, 26 Jan 2014 18:16:00 +0000

J’ai trouvé il y a peu une technique de gravure de circuit imprimé que je trouve excellente, non seulement elle utilise des produits disponibles dans tout les magasins de bricolage pour pas trop cher mais en plus elle permet une précision remarquable. Je partage donc cette technique avec vous.

La technique consiste à imprimer le circuit sur du papier glacé avec une imprimante laser pour ensuite le transférer sur la plaque de cuivre avec un fer à repasser. Puis enfin graver le cuivre avec un mélange particulier.

/!\Cette technique présente un danger puisqu’elle nécessite l’emploi de produits nocifs. Il faudra donc porter des gants, des lunettes et ne pas respirer les vapeurs/!\

Il vous faudra un petit peu de matos :

Une plaque cuivré en époxy, bakélite ou autre avec du cuivre sur une seule face. J’achète les miennes chez Tayda pour 1,4€ la plaque de 15*15cm.
Une imprimante laser. C’est très important car c’est le toner de l’imprimante qui vas protéger les pistes que vous voulez tracer.
De l’acide chlorhydrique à environs 30%. Produit nocif, utilisé notamment dans le traitement des piscines.
De l’eau oxygénée à 130 volumes. Produit nocif, utilisé notamment pour le blanchissement du bois.
De l’eau du robinet, aussi appelée monoxyde de dihydrogène, vous en avez surement déjà bu (-:
Du papier glacé type papier publicitaire.
Un fer à repasser, usé de préférence, la manipulation risque de le salir, vos chemises seront crades sinon, c’est pas top.
Des bocaux en verre, pour verser les différents réactifs. Anciens pots de moutarde acceptés.
Une grosse cuillère pour faire les dosages.
Un récipient où placer votre circuit imprimé pour la réaction. J’utilise un truc plat de peinture, très pratique et permet de ne pas gâcher des réactifs.
De l’acétone pour nettoyer le toner après la gravure.
Un papier à poncer avec des petits grains comme du 40 ou du 80.
Une petite perceuse/visseuse ou un outils de type dremel avec un support à colonne pour faire les trous des composants.
Un foret de 1mm. J’utilise des foret pour le métal.
Un logiciel de conception de circuit imprimé comme Fritzing que j’utilise pour sa simplicité.

La première chose à faire est réaliser ou récupérer le typon (image du circuit imprimé) que vous souhaitez graver.
J’utilise le logiciel Fritzing que je trouve très simple d’utilisation et qui permet de créer un fichier pdf du circuit que vous pouvez imprimer directement.

Il existe des tas de tutoriel notamment sur le site Fritzing pour apprendre à le faire.

Un conseil, moins il a de cuivre à enlever et plus la réaction sera rapide et efficace, penser donc à remplir de cuivre toutes les parties du circuit où il n’y à pas de piste (remplissage de la masse), comme sur l’image ci dessous :

Je vous conseille une largeur de piste minimale de 24mil (1mil = un millième de pouce). Des pistes plus fines fonctionnerons parfois très bien mais c’est plus sûr pour commencer.
Vous pouvez également bien sûr récupérer un fichier d’un circuit déjà fait sur internet.

Il s’agit maintenant d’imprimer ce typon sur le papier glacé avec votre imprimante toner. Si le papier glacé que vous avez découpé d’un magazine n’as pas la taille d’une feuille A4 vous pouvez le coller avec un bâton de colle sur une feuille de papier.
Vous devez également penser à l’imprimer dans le bon sens car la face avec les pistes de cuivre est la face inférieur. Avec Fritzing il faut juste imprimer la face inférieur dans le sens normal.
Avant de lancer l’impression pensez à régler votre imprimante de façon à ce qu’elle crache le plus de toner possible, désactiver l’économie de toner, pousser la densité et la résolution à fond.

Vous voila avec votre circuit imprimé sur votre feuille de papier glacé. La prochaine étape consiste à transférer le toner à l’aide d’un fer à repasser.
Placer l’image du circuit contre la face cuivré du circuit que vous aurez préalablement découpé avec une scie à métaux ou un dremel par exemple et légèrement poncé et nettoyé à l’acétone.

Appliquez le fer à repasser réglé sur la plus haute température sur l’ensemble. Pas besoin de bouger le fer s’il est assez grand mais vous pouvez un peu appuyez dessus. Un conseil, ne faites pas ça sur une table à repasser mais plutôt sur un établi.
Le toner va se transférer sur la face cuivrée en environs 3 minutes de chauffe. Vous n’avez aucun moyens de vérifiez que c’est prêt mais l’opération n’est pas définitive, vous pouvez donc réimprimer le circuit et recommencer si le toner ne s’est pas complètement transféré.

Ensuite placer votre plaque sous l’eau du robinet, utilisez un peu de savon pour aider à retirer le papier. Fait attention au toner car il est un peu fragile. Vous devriez vous retrouver avec quelque chose comme ça :

Si le circuit n’est pas bien imprimé, frottez le tout avec le papier à poncer et recommencez.

L’étape suivant est la plus dangereuse, enfilez donc vos gants, lunettes et si possible masque de protection.
Commencez par préparer le matériel :

Sachez que pour 1 litre d’acide chlorhydrique et 1 litre d’eau oxygénée vous en aurez pour environs 10€ en magasin de bricolage et vous pourrez réaliser des dizaines de circuits.
Ne faites le mélange qu’au dernier moment car il ne se conserve pas et n’est utilisable qu’une fois.
Le mélange dans les proportions normales est le suivant :

4 doses d’eau du robinet
2 doses d’acide chlorhydrique
1 dose d’eau oxygénée

Et toujours dans cet ordre. Ne versez jamais de l’eau dans de l’acide !

En fonction de votre récipient, vous devrez peut-être utiliser plusieurs fois ces doses. C’est pourquoi le récipient à peinture (voir photo au dessus) est bien utile.

Plongez ensuite votre plaque dans le mélange, des petites bulles devraient apparaitre. Vous pouvez tout au long de la gravure remuer un peu le mélange.
Le temps de gravure dépend des quantité d’acide et d’eau oxygénée mais aussi de la surface de cuivre à dissoudre. J’ai pour habitude de laisser la plaque environs 10 minutes. La gravure est terminée lorsque vous ne voyez absolument plus de cuivre. Vous pouvez sortir la plaque à l’aide d’une pince pour observer l’avancement.

Après la gravure placez la plaque dans de l’eau du robinet pour stopper la réaction.
Vérifiez qu’il ne reste pas de cuivre visible, vous pouvez replonger un peu la carte s’il en reste.

Il s’agit maintenant d’enlever le toner qui reste sur les pistes, pour cela prenez un essuie-tout et mettez un peu d’acétone dessus puis frottez la carte jusqu'à ce qu’il n’y ais plus une trace de toner :

Votre circuit imprimé est maintenant presque prêt, il ne vous reste plus qu’à percer les trous et à souder les composants.
Pour le perçage j’utilise un dremel monté sur un support à colonne mais j’ai aussi déjà testé, et c’est faisable avec une petite perceuse/visseuse qui ne tourne pas trop vite. Utilisez un foret de 1mm.

Et voila, avec ça vous pouvez créer n’importe quel circuit simple face en peu de temps et d’argent.

Un écran HD44780 sur bus I2C avec Arduino

noreply@blogger.com (Unknown) — Sat, 04 Jan 2014 19:02:00 +0000

Les écrans HD44780 sont surement les plus utilisés dans le monde de la bidouille Arduino, notamment grâce au fait qu'ils soient peu chers (3€ en chine et environs 10€ chez nous) et plutôt simples à utiliser.

Le problème de ces écrans est le fait qu'ils utilisent un bus de données parallèle sur 4 bits et que 2 bornes de plus sont nécessaire à leur fonctionnement. On se retrouve donc avec un écran qui a besoin de 6 pins de notre microcontrôleur pour fonctionner. L'Arduino par exemple ne possède que 14 pins, ce qui en consomme presque la moitié.
Heureusement la plupart des microcontrôleurs (dont celui de l'Arduino) possède un bus I²C qui une méthode de connexion très simple sur seulement 2 bornes et sur lequel on peut connecter un grand nombre de périphérique. Donc sur ces 2 bornes I²C on va pouvoir connecter une horloge par exemple ou dans notre cas, un extenseur 8 bits pour faire fonctionner notre écran.

Cet extenseur 8 bits est le PCF8574, il coute entre 1 et 2€. C'est un composant traversant de 16 pins. Il en existe différentes variantes comme le PCF8574AP que j'ai, mais ils fonctionneront tous de façon similaire.

Voici le montage simple :

Ce montage requière un potentiomètre de 10KOhm pour régler le contraste de l'écran.
Le PCF8574 possède 3 bornes d'adresse pour permettre d'utiliser par exemple plusieurs écrans sur les même bornes I²C.

Ces 3 broches sont A0, A1 et A2 (voir schéma ci-dessous). Si vous désirez n'utiliser qu'un seul écran, il faut mettre ces trois broches sur 0v. Ce qui donne une adresse 0x38 pour les PCF8574A et 0x20 pour PCF8574.

Je me suis donc fabriqué une petite carte d'essai avec tout le nécessaire dessus :

Voici le schéma des bornes de l'écran LCD HD44780:

Pour information, la borne RS sert à sélectionner le registre dans lequel on écrit, la borne R/W permet de commuter entre lecture et écriture, on souhaite seulement "écrire" sur l'écran dont elle sera tout le temps à 0v. Et la borne E permet d'activer l'écriture dans un registre.

Mais tout ça est trop compliqué à faire "manuellement", sur Arduino une bibliothèque va le faire pour nous, on n'aura juste à lui dire quoi afficher sur l'écran.

Cette bibliothèque nommée LiquidCrystal_I2C utilise la même mise en forme que la bibliothèque LiquidCrystal intégré par défaut au logiciel Arduino. Je vous invite donc à la télécharger ici et à l'installer dans votre répertoire C:\Program Files (x86)\Arduino\libraries .

Voici un exemple de code :

#include <Wire.h> //bibliothèque série i2c
#include <LiquidCrystal_I2C.h> //bibliothèque du couple extenseur i2c + écran

LiquidCrystal_I2C lcd(0x38,16,2);
//L'adresse de l'écran : 0x38 (trois pin d’adresse sur GND) pour un écran de
//16 colonnes et 2 lignes

void setup() {

lcd.init(); //on initialise l'écran
lcd.clear(); //on vide l'écran

}

void loop() {

lcd.setCursor(0,0); //on se place en haut à gauche de l'écran
lcd.print("Salut"); //on affiche du texte
lcd.setCursor(0,1); //on se place sur la deuxième ligne à gauche
lcd.print((millis())/1000); //on affiche nombre de seconde depuis l'allumage

delay(1000);

}

Quelques liens :

PCF8574AP pas cher : http://www.taydaelectronics.com/pcf8574-i2c-i-o-bus-expander-ic.html
i2c_scanner pour détecter l'adresse d'un élément I²C : http://playground.arduino.cc/Main/I2cScanner
Schéma en anglais expliquant comment contrôler le rétro éclairage : http://granddiego.besaba.com/img/sehcamecransuri2c.jpg

Pilotage d'afficheurs 8 segments avec le MAX7219 avec Arduino

noreply@blogger.com (Unknown) — Sun, 27 Oct 2013 18:36:00 +0000

Le MAX7219 est un contrôleur série d'afficheur 8 segments. Il permet de contrôler jusqu’à 8 afficheurs de 8 segments, donc 64 LEDs. On peu également les coupler pour contrôler un nombre infini de LED.
Il est très facilement utilisable avec les cartes Arduino grâce à la bibliothèque LedControl.
Ce contrôleur fonctionne uniquement avec les afficheurs à cathode (borne -) commune.
Cette puce est trouvable à presque 10€ mais il existe des copie fonctionnant parfaitement qui se vendent environs 2€ sur internet (c'est ce que j'ai choisi).

La puce est de type traversante, donc parfait pour une breadboard et possède 24 pins. Voici le schéma :

Elle peut donc s'utiliser facilement avec une résistance de 10Kohms et un condensateur de 0,1µF.
Notez que la résistance détermine le courant traversant l'ensemble des LEDs, il peut donc être utile de légèrement la modifier, mais 10Kohms est une bonne valeur pour commencer.
Sachez que lorsque que vous tenez un afficheur 8 segment à l'endroit, la borne 1 est celle en bas à gauche et la dernière borne est celle en haut a gauche.

Je me suis donc fabriqué une petite carte regroupant tout ces composants et des connecteurs bien pratiques.

Pour l'utiliser avec Arduino, il vous faut :

un Arduino (évidement)
l'IDE d'Arduino installé sur votre ordinateur
un ou plusieurs afficheur 8 segments à cathode commune (ou une matrice de LED)
la bibliothèque LedControl installé: playground.arduino.cc/Main/LedControl

Voyons un peu le code :

#include "LedControl.h"   //on ajoute la bibliotheque LedControl

//LedControl afficheur1=LedControl(DataIn,CLK,LOAD,nombre de MAX7219);
LedControl afficheur1=LedControl(12,11,10,1);

// prises de l'arduino sur lesquelles est branche le contrôleur.

void setup() {
  afficheur1.shutdown(0, false);  // allumer l'afficheur
  afficheur1.setIntensity(0, 15);  // regler la luminosite au maximum
  afficheur1.clearDisplay(0);   //vider l'afficheur

}

void loop() { 
  //afficheur1.setDigit(puce max7219, afficheur, nombre, point);
  afficheur1.setDigit(0,0,8,false);

//on affiche un 8 sur le premier afficheur du premier MAX7219 avec le point décimal éteins
  afficheur1.setDigit(0,1,1,true);

//on affiche un 1 sur le deuxième afficheur du premier MAX7219 avec le point décimal allume

}

Voici le résultat, on a bien le 8, puis le 1 et enfin le point décimal :

Quelques liens :

Bibliothèque LedControl : playground.arduino.cc/Main/LedControl

Quelques info intéressantes : www.pjrc.com/teensy/td_libs_LedControl.html

MAX7219 pas cher (j'ai acheté le mien là bas): www.taydaelectronics.com/max7219-7-segment-dot-point-common-cathode-serially-interfaced-display-driver-pdip-24.html

Une horloge sur bus I2C avec Arduino

noreply@blogger.com (Unknown) — Thu, 10 Oct 2013 18:26:00 +0000

Si votre arduino a besoin de se souvenir de l'heure qu'il est, et ce même après l'avoir débranché, vous avez besoin d'une RTC (real time clock ou horloge temps réel).
Le circuit RTC le plus répandus est le DS1307 et ce n'est pas pour rien; il est très simple, se branche sur bus I²C et ne coute que 1€ chez la plupart des vendeurs.

Le circuit DS1307 possède 8 pattes, mais une n'est pas utile, il s'utilise avec deux résistances de pull-up de 10kohms, un cristal à 32 768 kHZ et en option une pile de +3v de type CR2032.

Le SDA est la borne A4 de l'arduino et le SCL la borne A5.
Vous pouvez bien évidement acheter des modules tout fait mais je ne trouve pas ça marrant donc je me suis soudé moi-même le petit circuit en rajoutant un condensateur de 0.1µF entre le +5v et le GND.

Ensuite pour contrôler ça avec Arduino, j'utilise une librairie RTC classique : rtc-library.rar
Voici un exemple de code Arduino :

#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 RTC;

void setup () {
  Serial.begin(9600);

  Wire.begin();
  RTC.begin();

  if (! RTC.isrunning()) {
    Serial.println("Le RTC ne marche pas");
    // mise à l'heure :
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }


}

void loop () {
  DateTime now = RTC.now();

  Serial.print(now.year(), DEC);   //on affiche la date et l'heure sur le port série
  Serial.print('/');
  Serial.print(now.month(), DEC);
  Serial.print('/');
  Serial.print(now.day(), DEC);
  Serial.print(' ');
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.print(now.second(), DEC);
  Serial.println();

  Serial.print(" depuis 1970 = ");
  Serial.print(now.unixtime());
  Serial.print("sec = ");
  Serial.print(now.unixtime() / 86400L);
  Serial.println("jours");


  Serial.println();
  delay(1000);
}

Une petite horloge que j'ai monté :

Quelques liens :

Tuto DS1307 sur Adafruit : learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit

Description du bus I²C : mchobby.be/wiki/index.php?title=Arduino_I2C_Intro

Circuit DS1307 par cher (j'ai acheté le mien là): www.taydaelectronics.com/ds1307-maxim-64-x-8-serial-real-time-clock-ic.html

Ngrok - Ouvrir facilement des ports vers Internet

noreply@blogger.com (Unknown) — Thu, 26 Sep 2013 17:52:00 +0000

Si vous avez des logiciels disposant d’une interface web comme un contrôleur de téléchargement bittorrent par exemple ou même un simple serveur http et que vous voulez y accéder n’importe où dans le monde sans pour autant avoir à les installer sur un serveur avec un nom de domaine, alors testez ngrok.

ngrok permet d'exposer un serveur local à internet, il suffit que lui indiquer sur quel port le serveur fonctionne. Mais ce n’est pas tous car le logiciel fonctionne avec un service web qui vous permet d’attribuer une url du type xxx.ngrok.com à vos services web et même de placer un mot de passe d’accès à ces pages.
Le logiciel est disponible sur Windows, Linux et MacOS et il fonctionne en ligne de commande, je vais un peu vous expliquer comment l’utiliser sous windows.
Commencez par télécharger ngrok : https://ngrok.com/download puis extrayez l’archive dans un dossier comme C:\Program Files\Ngrok
Ensuite enregistrer vous sur le site, ce n’est pas obligatoire mais permet de nombreuses choses intéressante comme de réserver un nom de domaine du type xxx.ngrok.com : https://ngrok.com/signup
Comme je vous l’ais dit ce logiciel fonctionne en ligne de commande donc n’essayez pas de lancer le .exe comme ça, cela ne donnera rien.
En effet pour l’utiliser vous devez créer un fichier de commande .bat, cela se fait simplement avec le bloc note ou mieux notepad++
Un fois ouvert il faut commencer par ce placer dans le dossier où nous avons extrait ngrok tout à l’heure, sur la première ligne on entre donc : cd C:\Program Files\Ngrok
Votre fichier .bat sait donc où se trouve le logiciel ngrok, maintenant lançons le pour ouvrir le port 80 par exemple, on note donc sur la deuxième ligne : ngrok 80

Et voila, si vous enregistrer ces deux lignes dans un fichier .bat et le lancez, vous verrez une fenêtre de console avec votre url du type “3a4bfceb.ngrok.com” affiché. Maintenant voyons comment personnalisez un peu cette url.
Rendez-vous sur https://ngrok.com/dashboard puis copier votre “token”, cette liste de caractères permet de réserver des nombre de domaine.

Voici notre exemple avec cette modification :

cd C:\Program Files\Ngrok
ngrok -authtoken votretoken -subdomain votreUrl 80

Remplacez évidement “votretoken” par votre token et “votreUrl” par la valeur voulue, exemple : pour pouet.ngrok.com, mettez pouet.
Comme vous l’aurez peut être compris il suffit d’ajouter des arguments entre ngrok et le port. En voici un autre pour mettre un mot de passe à la page : -httpauth "utilisateur:mot de passe"

Et voilà, personnellement j’utilise ce logiciel sur mon serveur pour plusieurs tunnel :

Le gestionnaire de téléchargement de qBittorrent
Le gestionnaire de téléchargement de Mipony
HTTP File server : Pour accéder à distance aux disques dur
Open Hardware Monitor : Pour surveiller à distance les températures du système
TightVNC : Pour contrôler à distance le serveur.

La photorésistance

noreply@blogger.com (Unknown) — Wed, 18 Sep 2013 18:19:00 +0000

Qu'est-ce qu'une photorésistance ?
Les photorésistances sont des senseurs qui permettent de détecter la lumière.
Fondamentalement, les photorésistances sont des résistances dont la valeur résistive (en ohms Ω) change en fonction de la quantité de lumière qui atteint le capteur (la partie en serpentin sur le dessus).

Lorsqu'il fait sombre, le senseur ressemble à une grande résistance (jusqu'à 10MΩ)
Lorsque le niveau lumineux augmente, la résistance diminue.

Montage avec une carte Arduino
La façon la plus facile de mesurer un senseur résistif est de connecter une borne sur l'alimentation et l'autre sur une résistance Pull-Down (elle-même raccordée à la masse).
On raccorde ensuite le point de connexion entre "la résistance et la photorésistance" sur une entrée analogique d'un microcontrôleur comme Arduino (voir ci-dessous).

Exemple de code Arduino
Le programme permet d'allumer une LED uniquement lorsque l'ensoleillement est suffisant.

const int led = 7; //led sur la prise 7
int photocellPin = 0; // La photorésistance raccordée sur la PIN A0
int photocellReading; // Contient la valeur du senseur
int ensoleillement; // valeur de l'ensoleillement sur 100

void setup() {
pinMode(led, OUTPUT); //la led est une sortie
digitalWrite(led, LOW); //on éteint la led
}

void loop() {

photocellReading = analogRead(photocellPin); //lecture du capteur de lumière qui nous donne une valeur entre 0 et 1023
ensoleillement = map(photocellReading, 0, 1023, 0, 100); //nous transformons les valeurs de 0-1023 vers 0-100

if(ensoleillement > 75)
{
digitalWrite(led, HIGH); //on allume la led
delay(5000);
}
else
{
digitalWrite(led, LOW); //on éteint la led
delay(5000);

}

}

Automatiser votre vie sur internet

noreply@blogger.com (Unknown) — Sun, 10 Feb 2013 11:34:00 +0000

ifttt est un service web qui permet de faire le lien entre deux autres services et d'automatiser le tout. ifttt veut dire "If This Then That" ce que l'on pourrait traduire par : S'il se produit cela, alors fait cela.
Ce service propose par exemple de sauvegarder toute photo facebook sur laquelle vous êtes taggué dans votre dropbox ou encore d’envoyer dans Instapaper tout les post de Google reader que vous avez mis en favoris.

Il intègre en effet tout un tas de services web comme Gmail, Dropbox, Instapaper, Facebook, Twitter, Instagram, Evernote, Foursquare, Google reader, Youtube et bien d’autres…

Cela fonctionne sur un systèmes de “Task” que vous pouvez programmer comme bon vous semble.

Comment créer une Task ?

Il faut savoir que tout les services ont leurs spécificités. Pour créer une Task il faut assigner une action au “this” (le déclencheur).

Vous sélectionnez donc un service parmi les “Trigger channel”, les déclencheurs.

Dans notre exemple le service sera Facebook et le déclencheur sera lorsque quelqu’un vous tague sur une photo. J’ai choisi celui mais il y a bien sur d’autres option comme le fait que vous mettez en ligne une nouvelle photo ou le faite que vous ayez des notifications.
Une popup apparaîtra ensuite vous demandant d’autoriser ifttt à utiliser votre Facebook pour regarder toutes les 15 minutes si l’on vous à tagué.
Ensuite il s’agit de choisir un service cible (le “that” qui est l’action à réaliser).

Je choisi donc ici dropbox par exemple. Il faut donc configurer l’automatisation que nous venons de créer. Avec dropbox il faut régler le dossier dans lequel sera enregistrer la photo dans notre exemple.

Je viens donc de créer une Task qui va télécharger dans mon dossier dropbox toute les photos sur lesquelles on va me taguer (cela ne marche pas pour les anciennes). Sachez qu'une Task s'exécute toute les 15 minutes.
Si vous le désirer vous pouvez partager vos Task, cela ce fait en les transformant en Recipe (recette).

Quelques exemples de Task :

Je vous partage quelques recettes que j’ai trouvé sur le net :
1) Celle que nous venons de créer avec facebook et dropbox : http://ifttt.com/recipes/15
2) Automatiquement envoyer un message à vos nouveaux followers sur twitter : http://ifttt.com/recipes/32
3) Envoyez sur Instapaper les posts Google Reader que vous avez marqué comme favoris : http://ifttt.com/recipes/178
4) Envoyer toutes vos photos Instagram sur un album Facebook : http://ifttt.com/recipes/56
Vous pouvez donc automatiser tout un tas de chose ce qui en fait un site vraiment intéressant pour le peu que vous compreniez l’anglais.

Lien : ifttt

Sortie de Half Life : Black Mesa

noreply@blogger.com (Unknown) — Mon, 17 Sep 2012 17:57:00 +0000

Après sept ans d’attente, le remake de ce que l’on peut appeler sans trop ce tromper, meilleur FPS de tout les temps, vient de sortir. Il s’agit de Black Mesa, qui en 2005 s’annonçait comme une refonte complète du jeu Half Life sous le moteur Source de Half Life 2, et ça, ça trou le cul !
Il s’agis donc de refaire complètement le jeu avec de nouveaux graphismes mais également de nouvelles voix (anglaises), ce qui est donc un travail gigantesque. L’équipe qui a réalisé ce mod ne l’a pas encore achevé mais, croulant sous les demandes des fans, a décidée de proposer les huit premières heures de jeu, jusqu’au chapitre « Lambda Core ».
Ce travail est réalisé par une équipe de moddeurs -que l’on remercie au passage pour ce travail de titan- complètement indépendante de Valve et donc le jeu est entièrement gratuit ! Black Mesa est sortit le 14 septembre donc les serveurs ont eu le temps de reprendre leur souffle et vous pouvez le télécharger dès maintenant sur Steam.
Donc vous savez ce qui vous reste à faire , moi personnellement j’adore, même si j’ai toujours une préférence pour l’original sur lequel j’ai passé de nombreuses heures :-)
Site officiel : http://release.blackmesasource.com/
Lien DL : http://steamcommunity.com/sharedfiles/filedetails/?id=94128543

GameSave Manager - Faite un backup de vos sauvegarde de plus de 1200 jeux

noreply@blogger.com (Unknown) — Thu, 19 Jul 2012 10:46:00 +0000

Si vous formatez ou changez souvent de PC tout en étant un gamer, vous avez déjà dû réinstaller tout vos jeux et également vos sauvegardes une à une. C’est long et on ne sait pas forcement dans quel répertoire sont stocké les sauvegardes pour tel jeu. Et bien avec GameSave Manager, vous allez pouvoir faire des sauvegardes de vos sauvegardes, eh oui .
Et parce que l’on est pas à l’abri d’un crash de disque dur, vous allez même pourvoir envoyer l’intégralité de vos sauvegardes sur Dropbox, Google Drive, SkyDrive ou même un serveur ftp.

Donc vous pouvez télécharger le logiciel gratuitement à cette adresse : http://www.gamesave-manager.com/?s=download
Vous allez télécharger un fichier zip avec l’installateur à l’intérieur : (en rouge).
Lancez donc “gs_mngr_3.exe” et installez le programme.

Une fois le logiciel installé, il va scanner vos disques dur pour y trouver les jeux et leurs répertoire de sauvegarde.

Ensuite vous allez pouvoir lancer un backup de vos sauvegarde mais avant, allons faire un tour dans les paramètres.

Comme vous le voyez, j’ai choisi de regrouper toutes les sauvegardes dans un seul fichier (Sinon le logiciel crée un fichier par jeu) en décochant la première case dans l’onglet “backup Settings” . J’ai également choisi un dossier de backup par défaut sur mon disque dur.

Vous pouvez également choisir de transférer vos sauvegarde dans un service de Cloud comme Dropbox ou Google Drive.

Après avoir réglé les paramètres du programme, il est temps de faire notre première sauvegarde, pour cela revenez dans le menu principal et cliquez sur “Make a backup”.

Le logiciel va scanné vos jeux puis vous demander quel sauvegarde de quel jeu sauvegarder. Moi je les prend tous.
Pour lancer la sauvegarde cliquer sur l’icone exécuter en haut à droite.

Lancer le Backup.

Le logiciel va donc sauvegarder toute les sauvegardes que vous avez sélectionné. Il se peut qu’une fenêtre noire apparaisse, il y a moyen de la rendre invisible dans les paramètres.

La sauvegarde peut-être assez longue en fonction du nombre de jeux, soyez patient.
Et lorsque c’est enfin terminé vous pourrez découvrir un beau fichier (ou plusieurs) contenant les sauvegardes de vos jeux. Pour info, le mien fait 1Gio.

Et voila ! vous avez réalisé un backup de toutes vos sauvegardes de vos jeux, je vous conseil évidement de conserver cette sauvegarde sur un autre disque dur. Vous pourrez également voir que le logiciel GameSave Manager permet de faire bien d’autres choses comme par exemple de déplacer vos jeux steam dans un autre dossier ou disque dur etc…

Forcer votre PC à utiliser l’Ethernet au lieu du Wifi

noreply@blogger.com (Unknown) — Mon, 09 Jul 2012 13:53:00 +0000

Si parfois vous utilisez votre ordinateur en Ethernet au lieu du Wifi pour faire par exemple de gros transferts de fichier, vous avez surement dû remarquer que Windows continue à utiliser la connexion sans fil à la place de la connexion filaire et vous devez donc désactiver la puce wifi.
Mais il y a un moyen d’automatiser tout cela, si certains ordinateurs portables propose l’option dans le bios pour commuter automatiquement lorsqu’un câble Ethernet est branché, pour les autres il suffit d’aller chercher une option un peu cachée de Windows qui permet d’attribuer des priorités aux cartes réseaux.

Comment forcer Windows à utiliser l’Ethernet au lieu du Wifi ?
Appuyez sur les touches Windows + R, une fenêtre va s’afficher, entrez ncpa.cpl dans la zone de texte et cliquez sur OK.

Cela va ouvrir la fenêtre des connexions réseaux, appuyer sur la touche ALT pour faire apparaitre le menu puis cliquez sur Avancé>Paramètres avancés

Une autre fenêtre apparait, et c’est dans celle-ci que vous allez pouvoir modifier la priorité de vos cartes réseaux. Cliquez donc sur Ethernet et faite la monter en utilisant la flèche verte sur le côté.

Puis cliquez sur OK et c’est bon ! Donc voila grâce à cela, Windows va utiliser l'Ethernet au lieu du Wifi dès que celui-ci sera disponible.

Antidote HD, ou comment bien écrire français

noreply@blogger.com (Unknown) — Mon, 23 Apr 2012 09:30:00 +0000

Ça faisait longtemps que je n’avais pas écrit d’articles et j’avais envie de vous parler de ce logiciel qui me plait beaucoup.

Antidote HD est un correcteur orthographique et grammatical, mais pas n’importe lequel, il connait particulièrement bien la conjugaison et la grammaire française ; bien mieux que le correcteur de Word.

Le logiciel est spécialement conçu pour le français (d’ailleurs il ne connait que ça) donc les dictionnaires sont mis à jour très régulièrement et la correction est parfaite.

Le logiciel s’installe dans la suite office comme un add-on mais fonctionne aussi avec de nombreux logiciels.

Il s’intègre dans Word et même dans le bloc note.

Donc si vous voulez écrire des articles ou des emails pas trop dégueu et que vous avez un peu de mal avec le français, Antidote HD est le logiciel approprié.

Le logiciel coute environs 100€ sur Amazon : http://www.amazon.fr/Druide-Antidote-HD/dp/2922010112/ref=sr_1_1?ie=UTF8&qid=1335170723&sr=8-1

Mais si vous voulez le tester un peu (ou beaucoup), le voilà ici : http://thepiratebay.se/torrent/6187450/Antidote_HD

Le logiciel dispose aussi d’une version pour macintosh.

Naviguer plus rapidement avec un RAMdisk

noreply@blogger.com (Unknown) — Mon, 05 Mar 2012 00:01:00 +0000

Comme vous le savez surement, la mémoire vive de votre PC est bien plus rapide que votre disque dur ou même votre SSD. Et si vous utilisiez celle-ci afin de surfer plus rapidement sur le net en y déplaçant le cache du navigateur (avec des chargements réduits de 20% environs). Pour cela vous pouvez utiliser un RAMdisk et créer un volume virtuel dans votre mémoire vive afin qu’il s’affiche dans votre explorateur comme un disque dur classique. Cela permet d’accélérer grandement le chargement des sites que vous avez déjà visité, et dont les images et les pages web seraient déjà enregistrés dans ce RAMdisk.

Pour cela vous avez besoin du petit logiciel “Dataram RAMdisk” qui est gratuit pour des volumes de moins de 4Go, donc largement assez pour y mettre le cache d’un navigateur.

Apres avoir installé le programme, il faut le configurer, comme taille entrez 500Mo et le formatage doit être FAT32.
Cliquez sur "Start RAMDisk" en bas.
Puis, dans l’onglet “Load ans Save” cochez simplement "Load Disk Image at Startup" et "Save Disk Image on Shutdown".

Si il apparait des fenêtres vous demandant l’installation de pilotes, cliquez sur installer.
Vous remarquerez en ouvrant l’explorateur (WIN + E) qu’un nouveau volume est présent, notez sa lettre de ce nouveau RAMDisk, ici c’est E:

A la racine du RAMDisk, créez un dossier nommé "BrowserCache" ou sera stocké le cache de votre navigateur.

Maintenant vous devez donc déplacer votre cache de Google Chrome ou Firefox vers ce nouveau RAMDisk :

Google Chrome

1) Fermez toutes les fenêtres de navigateur et faites un clic droit sur l’icône de Chrome puis cliquez sur propriétés.
2) Dans l’espace appelé cible entrez après chrome.exe ceci : --disk-cache-dir="E:\BrowserCache" avec E lettre du lecteur.

3) Cliquez sur OK et appréciez.

Mozilla Firefox

1) Tapez about:config dans la barre d’adresse et acceptez l’avertissement.
2) Faites un clic droit puis Nouvelle/Chaine de caractères
3) Entrez browser.cache.disk.parent_directory dans la première fenêtre puis le chemin du dossier de cache dans la deuxième, E:\BrowserCache.

4) Appuyez sur OK et fermez Firefox puis ré ouvrez le et appréciez.

Peut-être que vous ne remarquerez pas l’amélioration au début mais une fois que vous irez sur des sites déjà visité vous verrez la différence. Egalement dans lors de changement d’onglets lorsque vous en avez beaucoup d’ouverts.

Sinon pour Mac, j’ai entendu parler de Espérance DV mais bon je m’étendrais pas trop dessus.

Installer Windows/Linux sur votre iPhone

noreply@blogger.com (Unknown) — Sat, 18 Feb 2012 19:01:00 +0000

Bochs est un émulateur libre portable de processeur x86 et x86-64 et de compatibles IBM-PC fonctionnant sur différentes architectures matérielles.

Vous pouvez simplement installer Windows ou linux sur votre iPhone/iPad grâce à ce logiciel qui a été porté sur iOS.
Pour installer Bochs sur votre iPhone, il faut que celui-ci soit jailbreaké. Ouvrez donc l’application Cydia et ajouter cette source : http://apt.philippe97.com
Ouvrez la source en question puis installer le logiciel Bochs et si vous le voulez les images des systèmes d’exploitation (Win95,Win3.1 ou 2.1).
Quand vous lancer l’application Bochs, sélectionnez le système a utiliser et celui-ci va se lancer. Windows 95 met 10min pour se lancer sur mon vieux iPod Touch 2G mais avec un appareil plus neuf ça devrait le faire.

Ça fonctionne aussi sur un iPad et certain ont même réussi à lancer Windows XP ou linux (Damn Small Linux ou Puppy).
Il faut quand même avouer que le truc n’est pas très utile et pas très fluide non plus.

http://bochs.sourceforge.net/

Changer rapidement de DNS

noreply@blogger.com (Unknown) — Fri, 17 Feb 2012 20:32:00 +0000

Si vous utilisez plusieurs DNS et voulez changer rapidement ou si vous voulez connaitre quel est le serveur DNS le plus rapide chez vous il existe un petit soft : DNSjumper qui permet de jongler rapidement entre différents DNS prédéfinis, d’entrer le votre ou encore de sélectionner le plus rapide. Ca permet également de contourner un éventuel blocage DNS.

Ce logiciel est disponible en français et gratuitement a cette adresse.

Des mods pour Skyrim

noreply@blogger.com (Unknown) — Mon, 02 Jan 2012 16:12:00 +0000

Skyrim est un très bon jeu mais il est imparfait, comme le fait de ne pouvoir porter qu’un seul anneau (alors que l’on a 10 doigts) ou encore une interface assez “consoliste” puisqu’elle est identique à la version console, bref des petits détails mais qui peuvent devenir agaçant à la longue, sachant que la durée de vie est énorme (certains annoncent 100 heures de jeu).

Donc certains bidouilleurs, développeurs créent des mods; des modifications en Anglais.
Ces mods sont présent sur le site skyrimnexus.com/ et je vous conseille de les installer avec le “Nexus Mod Manager” qui est un petit logiciel qui va installer les mods à votre place.

Le logiciel permet d’ajouter mais aussi de retirer des mods, je précise aussi que ça fonctionne avec une version crackée du jeu

Installer le Nexus Mod Manager

Le gestionnaire de mod Nexus est un outil indispensable qui vous permet de gérer tous les mods dans les jeux Bethesda. Il permet le téléchargement de mods simultanément et vous indique si une mise à jour est disponilbe.
http://www.skyrimnexus.com/content/modmanager/
Au moment de télécharger un mod, vous n’aurez qu’à cliquer sur “Dowload With Manager”.

SkyUI

SkyUI change complètement l’interface du jeu avec un inventaire en différents onglet et une interface très bien adapté pour la souris et le clavier.
C’est un indispensable pour profiter au mieux du jeu.
http://www.skyrimnexus.com/downloads/file.php?id=3863

Skyrim HD - 2K Textures

Le mod Skyrim HD améliore grandement les textures du jeu (4 fois plus détaillées que celles d’origine). Le mod fait 1.25Go et utilise 200Mo de RAM en plus en jeu.
http://www.skyrimnexus.com/downloads/file.php?id=607

Tytanis

Tytanis va ajouter à votre jeu de nombreux éléments et objets (armures, armes, sorts, compagnons, quêtes, et autres). Considéré comme le mod Ultime pour Skyrim, il augmente en plus la durée de vie du jeu.
http://www.skyrimnexus.com/downloads/file.php?id=1601

A Quality World Map

Vous trouvez la carte de Skyrim incomplète ? et bien ce mod remplace les textures de la map et rend même visible les routes et sentiers pour mieux vous repérer.
http://www.skyrimnexus.com/downloads/file.php?id=4929

Il y en a bien d’autres et je vous conseille d’aller vois sur le site tous les mods disponibles.

BugMeNot : non aux formulaires d'inscription

noreply@blogger.com (Unknown) — Wed, 19 Oct 2011 14:21:00 +0000

Lorsque l’on veut essayer un service Web ou accéder à un forum il faut passer par la case remplissage du formulaire.
Parfois il faut même attendre la réception d’un mail pour valider son enregistrement.

BugMeNot est un site Web qui met à disposition un grand nombre de login et de mots de passe pour s’affranchir de l’étape de l’enregistrement sur de très nombreux services et sites web dont il suffit d’indiquer l’URL pour obtenir un accès au service.

http://www.bugmenot.com/

Wake on LAN ou allumer un PC à distance

noreply@blogger.com (Unknown) — Mon, 17 Oct 2011 17:28:00 +0000

Wake on LAN est un standard des réseaux Ethernet qui permet à un ordinateur éteint d'être démarré à distance.
Pour cela, il suffit que votre carte mère soit compatible (99% des ordinateurs récents) et d'activer cette fonctionnalité dans le BIOS.

WakeMeOnLan est un logiciel gratuit qui scanne votre réseau local afin d'y collecter les adresses MAC de tous vos ordinateurs pour permettre de les allumer à distance que ils seront éteins.

http://www.nirsoft.net/utils/wake_on_lan.html