dimanche 13 septembre 2015

DomoPotame - ESP8266

Alors je me suis essayé à l'ESP8266 il n'y a pas longtemps, ce petit chip Wifi très lowcost mais qui offre quand même pas mal de possibilité.

Le seul inconvénient de ce petit chip, c'est que ces sorties GPIO ne fournissent pas beaucoup d'intensité en sortie, mais on peux rajouter des petits transistors pour couvrir ce manque.

Mon premier petit projet avec, fut de domotiser la veilleuse de ma fille, son hippo (qui était à sa mère avant elle).

Voici la bête modifié :


Il y a un esp8266 dedans, avec un strip LED 12V piloté par un MOSFET pour pouvoir faire varier l'intensité lumineuse.
J'ai rajouté deux LED vertes au niveau des oreilles, ces LED servent de réveil pour lui indiquer qu'elle peux se lever.
Il y a également un switch pour allumer le strip led sans téléphone (un appui passe le strip à 10%, un autre 30%, puis 50% puis 100%).
Et en petit plus une sonde de température/humidité DHT22.
Le tout alimenté par un bloc alim 12V.

Voici le schéma physique du potame :

L'esp8266 est programmé en IDE Arduino.
Pour faire de l'arduino avec l'ESP, il faut passer par ce github qui fourni tout :
https://github.com/esp8266/Arduino

Et voici le sketch de l'ESP potame :

#include "DHT.h"
#include <ESP8266WiFi.h>

    const char* ssid     = "SSIDNAME";
    const char* password = "SSIDPWD";

// Créé une instance WEB
// Sur le Port 80
WiFiServer server(80);
// Défini le Port GPIO du DHT
#define DHTPIN 12
// Défini le type de DHT (DHT11-DHT21-DHT22)
#define DHTTYPE DHT22
// Crée le DHT
DHT dht(DHTPIN, DHTTYPE, 15);
int valu = '0';
int buttonState = 0;
int buttonrelease = 0;

void setup() {

  //Prépare la serial
  Serial.begin(115200);
  delay(10);
  //Initialise le DHT
  dht.begin();
  // Défini les GPIO 14 et 4 en sortie
  pinMode(5, OUTPUT);
  pinMode(14, OUTPUT);
  pinMode(13, INPUT);
  // Met à 0 les GPIO
  digitalWrite(5, 0);
  digitalWrite(14, 0);
  // Connection au WiFi
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  // Met l'ESP uniquement en station et pas Access Point
  WiFi.mode(WIFI_STA);
  // Connection au WiFi
  WiFi.begin(ssid, password);

  for (int i=0; i<60; i++) {
    if (WiFi.status() == WL_CONNECTED) {
    i = 60;
    }
    delay(500);
    Serial.print(".");
  }

 
  if (WiFi.status() == WL_CONNECTED) {
 
  Serial.println("");
  Serial.println("WiFi connected");
 
  // Démarre le server WEB
  server.begin();
  Serial.println("Server started");

  // Affiche l'adresse IP obtenue
  Serial.println(WiFi.localIP());
  }
}

void loop() {
  //Déclare les variables Temp et humidity
  float temp;
  float humidity;
  buttonState = digitalRead(13);
  if (buttonState == HIGH && buttonrelease == 0) {
    //Bouton Potame HIGH
    if (valu == 0 && buttonrelease == 0) {
      valu = 40;
      analogWrite(5, valu);
      buttonrelease = 1;
      }
      else if (valu < 41 && buttonrelease == 0) {
      valu = 150;
      analogWrite(5, valu);
      buttonrelease = 1;
      }
      else if (valu < 151 && buttonrelease == 0) {
      valu = 550;
      analogWrite(5, valu);
      buttonrelease = 1;
      }
      else if (valu < 551 && buttonrelease == 0) {
      valu = 1024;
      analogWrite(5, valu);
      buttonrelease = 1;
      }
      else if (valu > 851 && buttonrelease == 0) {
      valu = 0;
      analogWrite(5, valu);
      buttonrelease = 1;
      }
  }else if (buttonState == LOW && buttonrelease == 1) {
    buttonrelease = 0;
    delay(500);
    }
  // Vérifie si quelqu'un se connecte sur le Web server
  WiFiClient client = server.available();
  if (!client) {
    return;
  }
 
  // Attendre que le client envoi des infos
  Serial.println("new client");
  while(!client.available()){
    delay(1);
  }
 
  // Lit la première ligne de la requête
  String req = client.readStringUntil('\r');
  Serial.println(req);
  client.flush();
  //Prépare la sortie JSON en success
  int val;
  String httpHeader = "HTTP/1.1 200 OK\r\nContent-Type:application/json\r\nAccess-Control-Allow-Origin:*\r\nCache-Control:no-cache\r\n";
  httpHeader += "Content-Length: ";
  String resultat = "{ \"success\": \"1\",";
  // Analyse de la requête client
 
  // si l'URI est /gpio2/0
  if (req.indexOf("/gpio2/0") != -1) {
    val = 0;
    // Met GPIO à 0 comme demandé
    digitalWrite(14, val);
    // Continue la réponse JSON
    resultat += "\"GPIO2\":\"";
    resultat += (val);
   
  // si l'URI est /gpio2/1
  } else if (req.indexOf("/gpio2/1") != -1) {
    val = 1;
    // Met GPIO à 1 comme demandé
    digitalWrite(14, val);
    // Continue la réponse JSON
    resultat += "\"GPIO2\":\"";
    resultat += (val);
   
  // si l'URI est /gpio/temp
  } else if (req.indexOf("/gpio/temp") != -1) {
    // Prépare une boucle en cas de non réponse du DHT
     int A=0;
     do {
       A++;
      delay(2000);
       humidity = dht.readHumidity();
       temp = dht.readTemperature();
       Serial.println(temp);
       Serial.println(humidity);
       // Si aucune réponse n'est valide au bout de 10 essai, Echec
       if (A == 10) {
           //Renvoi le JSON en success 0 et erreur
           String resultat = "{ \"success\": \"0\",";
           resultat += "\"TEMP\":\"Error\"";
           resultat += "\" }\n";
           httpHeader += resultat.length();
           httpHeader += "\r\n";
           httpHeader +="Connection: close\r\n\r\n";
           String MESSAGE = httpHeader + resultat;
           client.flush();
           // Send the response to the client
           client.print(MESSAGE);
           client.stop();
           Serial.println("Client disconnected");
         return;
         }
     } while (isnan(temp) || isnan(humidity));
    // Continue la réponse JSON
    resultat += "\"TEMP\":\"";
    resultat += temp;
    resultat += "\",\"HUM\":\"";
    resultat += humidity;
  // si l'URI est /gpio/demodim
  }else if (req.indexOf("/gpio/demodim") != -1) {
    val = 1;
      // Fait un PWM de 0 au MAX
      for (int i=0; i<1024; i++) {
        analogWrite(5, i);  // PWM the LED from 0 to 1024 (max)
        delay(1);
      }
      // Fait un PWM de MAX à 0
      for (int i=1023; i>=0; i--) {
        analogWrite(5, i);  // PWM the LED from 1024 (max) to 0
        delay(1);
      }
    // Continue la réponse JSON
    resultat += "\"GPIO\":\"DEMODIM\"";
    resultat += (val);
  // si l'URI est /gpio/dim 
  }else if (req.indexOf("/gpio/dim") != -1) {
      // Récupère le % désiré (entre 0 et 1023)
      String svalu = req.substring(14,18);
      valu = svalu.toInt();
      //
      analogWrite(5, valu);  // PWM the LED from 255 (max) to 0
    // Continue la réponse JSON
    resultat += "\"GPIO\":\"";
    resultat += (valu);
  // Requete invalide
  } else {
    Serial.println("invalid request");
    client.stop();
    return;
  }
  // Fini la réponse JSON
  resultat += "\" }\n";
  httpHeader += resultat.length();
  httpHeader += "\r\n";
  httpHeader +="Connection: close\r\n\r\n";

  String MESSAGE = httpHeader + resultat;

  client.flush();
  // Envoi la réponse JSON complète au client
  client.print(MESSAGE);
  delay(1);
  Serial.println("Client disconnected");

  // Déconnecte le client
}
Il y a plusieurs commandes possibles qui renvoi du JSON :

http://IP-DE-POTAME/gpio/temp
renvoi la mesure de température de la sonde DHT22
{ "success": "1","TEMP":"23.20","HUM":"75.50" }
http://IP-DE-POTAME/gpio2/0 ou http://IP-DE-POTAME/gpio2/1
Allume ou éteint les petites leds vertes et renvoi
{ "success": "1","GPIO2":"0" }

http://IP-DE-POTAME/gpio/dim=0000 ou http://IP-DE-POTAME/gpio/dim=1023
Allume le strip LED à l'intensité demandé (de 0 à 1023) et renvoi
{ "success": "1","GPIO":"0" }
 Une petite vidéo de l'ensemble relié à l'Eedomus :



Pour info, ce montage tourne depuis 3 mois sans un plantage ni un raté, c'est assez hallucinant d'avoir une si grande fiabilité sur un composant de ce prix.

jeudi 22 janvier 2015

Php pour tout contrôler !

Chose promise, chose due.
Loin d'être fini, mais déjà une base que j'utilise depuis plusieurs mois.

J'ai mis ça sur un Github :
https://github.com/nono1024/Rasp-mcp23017

A faire sur le PI :

cd ~
On récupère le projet.
git clone https://github.com/nono1024/Rasp-mcp23017.git
cd  Rasp-mcp23017
On le copie dans le répertoire d'apache
cp -R * /var/www/
On mets les bons droits dessus
sudo chown -R www-data:www-data /var/www/
sudo chmod -R 775 /var/www/
Et normalement, avec un navigateur et en tapant directement l'URL de l'IP de votre PI vous devriez obtenir ceci :

C'est déjà pas mal !
Pour faire succint, Dans l'écran accueil vous avez un accès au 16 relais des banks du MCP23017.
Ici uniquement en ON OFF pour l'instant.

Dans l'onglet relais, vous avez un menu un peu plus complet sur l'action que l'on peux faire sur les relais (fugitif, on, off) mais aussi plus d'infos sur la config de chaque PIN.

Dans l'onglet Conf relais, on peux personnaliser chaque relais, en changeant son nom, le type (uniquement on off ou uniquement fugitif), et si il est nécessaire pour son activation qu'un autre relais soit activé.
Je m'explique, si sur un relais est branché des LED 12V, mais que l'alimentation 12V est sur un autre relais (pour éviter de la laissé branché), il faut linker le relais des LED à l'alimentation.
Ainsi, si vous allumez les LED, l'alim sera automatiquement allumé, et si vous éteignez et que aucun autre relais n'utilise l'alim 12V, l'alim sera éteinte aussi.

Pour rappel, un relais fugitif est un relais qui se comportent comme un poussoir avec un temps par défaut de 1s en état ON.


Il y a aussi un onglet sonde qui détecte automatiquement les sondes DS18B20 1wire et permet de les faire apparaitre sur l'écran principal (en les sauvegardant, cela permettra donc de les mettre sur l'écran d'accueil, mais aussi d'y faire appel par l'API).

Et enfin un onglet API qui permet de détailler les différents appels HTTP possible.


Voici ce que ça donne une fois configuré :

 

On voit que j'ai configuré les PIN B4 à B6 en fugitif, du coup, ça n'affiche sur l'accueil que le bouton ACTIONNER (comme un poussoir).

On voit les 3 sondes DS18B20, Et sur la page Relais :

On voit que j'ai linké aux PIN A0 à A3 le relais B7 qui correspond à mon alim 12V.
Ainsi, si j'actionne le relais A0 ou A1 ou A2 ou A3, il verifiera si l'alim est allumé et l'allumera au besoin.
Pareil pour l'extinction, il vérifiera que les PIN A0, A1, A2, A3 sont bien éteint avant d'éteindre l'alim 12V.

C'est tout pour le moment......

2% du code (la base du début début est d'origine Idleman : http://blog.idleman.fr/ ) Merci à lui pour l'orientation et puis pour son blog !!!! (mais pas pour ces vidéos :):) )

mardi 13 mai 2014

MCP23017 + Raspberry PI = Montage


Alors c'est parti pour apprendre à rajouter des sorties sur le Pi sans utiliser des GPIO (ou rajouter des entrées aussi, mais je les utilise uniquement en sorties, je garde les entrées sur le Pi directement)

Au niveau du Pi on va utiliser le bus I2C avec un MCP23017.
Le MCP23017 se présente de cette façon :


Il est séparé en 2 Banks de 8 GPIO (GPAx et GPBx) + alim (VDD, VSS) + adresse I2C (A2, A1,A0) + Bus I2C (SCL, SDA) + le RESET (à papa).

Alors, comme je vais utiliser les 16 sorties du MCP23017 pour piloter des relais, je vous fais la liste de course.
Il faut :
  • Un MCP23017 (au prix, en prendre plusieurs, on ne sait jamais...) ici 10€
Je conseille de le prendre avec DIP, ça permet de changer le MCP23017 si on le crame en 2s.
Total des courses : 64€50 pour le Pi complet et 17€50 les 16 relais soit un total de 82€ pour un serveur WEB avec 16 sorties relais, 8 entrées, sonde de température, etc... Imbattable !

Bon maintenant il s'agit de câbler le tout.
Voici le schéma logique de tout ça :

J'alimente en 5V le MCP23017 car je veux que ces sorties soit en 5V pour pouvoir piloter les relais.

ATTENTION : Des légendes urbaines précise que les broches SDA et SCL du MCP23017 vont amener du 5V aux broches I2 du Rasp (ce qui est vrai) mais les pin I2C ont 2 resistances pull-up qui va faire redescendre la tension à 3.3V, donc pas de panique.
Par contre il est précisé sur certains sites que si on branche plusieurs MCP23017, les resistances du Pi ne suffiront pas et il y a un risque. Perso j'utilise pour l'instant qu'un seul MCP23017, mais si je dois en mettre un deuxième, je mettrais un "level shifter" pour convertir le 5V des MCP23017 en 3.3V.

Voila donc au niveau câblage MCP23017 ça donne :
  • Pin 9 (VDD) est connecté au 5V
  • Pin 10 (VSS) est connecté à la Masse
  • Pin 12 (SCL) est connecté au Pin 5 du PI
  • Pin 13 (SDA) est connecté au Pin 3 du PI
  • Pin 18 (Reset) est mis au 5V (maintenu High) car sans cela, le MCP se met au tas de temps en temps.
  • Pins 15, 16 & 17 (A0-A2) est utilisé pour donné un adressage au MCP, si on en met plusieurs, il faut qu'il ai donc un adressage différent. C'est du binaire, donc ici 000, voir schéma ci dessous.
  • Les pins GPA0 à GPA7 sont connectés à la première carte de 8 relais
  • Les pins GPB0 à GPB7 sont connectés à la deuxième carte de 8 relais
Les différentes adresses possibles (marqué 3,3V mais 5V fonctionne aussi) :

Bon une fois que c'est fait, on va préparer le Pi.
sudo vi /etc/modules
On rajoute ça (ou on enlève le # devant s'il y sont déja) :
i2c-bcm2708
i2c-dev
Ensuite :
sudo vi /etc/modprobe.d/raspi-blacklist.conf
On commente ces deux lignes (en rajoutant un # au début):
#blacklist spi-bcm2708
#blacklist i2c-bcm2708
On installe les tools I2C :
sudo apt-get install i2c-tools
Sur mon install j'ai des problème de droit (obligé de passer en root) même en mettant mon user dans le groupe I2C. Donc faire un chmod 4755 pour permettre l'exécution avec les variables root.

sudo chmod 4755 /usr/sbin/i2cdetect /usr/sbin/i2cset /usr/sbin/i2cget /usr/sbin/i2cdump
Une fois que tout ça est fait, on pourra appeler l'I2C de n'importe quel user (surtout www-data).
Pour savoir si le montage fonctionne, on va commencer par voir si le MCP23017 est reconnu.

Sur un Raspberry Pi première génération en 256Mo faire un
i2cdetect -y 0
Pour une deuxième génération en 512Mo (celui en lien sur amazon) :
i2cdetect -y 1
 En cas d'erreur, essayer en rajoutant un "sudo" devant mais normalement si vous avez lancé le chmod, il n'y a pas besoin.

Voici la sortie normale de la commande :
xxxxx@rasp-garage ~ $ i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: 20 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
On voit le 20 en première colonne, 3ème ligne c'est l'adresse que l'on va donc utiliser (0x20 en fait car en Hexa).
Cette adresse est un résultat du câblage des pin A2, A1, A0.
Si A0 était branché au 5V au lieu de la masse, le MCP aurait 21 (0x21 en fait car en Hexa) comme adresse.

On va maintenant passer les 16 sorties du MCP en mode sorties (de base elles sont en entrées).

i2cset -y 1 0x20 0x00 0x00
i2cset -y 1 0x20 0x01 0x00
  • I2cset permet de faire des opérations sur le bus I2C.
  • -y est l'option de base qui permet de dire Yes pour éviter le mode interactif
  • 1 (i2cbus) pour désigner le bus I2C (lié à la version du Pi)
  • 0x20 (Chip Address) est l'adresse du MCP23017
  • 0x00 ou 0x01 (Data Address) désigne le bank de sortie du MCP (0x00 Bank A et 0x01 Bank B) Exactement IODIRA et IODIRB voir schéma plus bas.
  • 0x00 pour dire tout le monde est sortie.
Le 0x signifie qu'il faut parler Hexa, il y aura donc, à chaque fois, une gymnastique de l'esprit pour faire notre conversion binaire hexa (mais PHP le fera tout seul).

Pour info voici les ordres possibles au niveau Data Address :


Pour modifier l'état d'un PIN BANK A, on utilisera pour le champ Data address 0x12 ou 0x14 (même effet), pour la Bank B, ce sera 0x13 ou 0x15.

ATTENTION: Si vous avez acheté les mêmes cartes Relais que moi, les Pins sont INVERSÉS sur la carte relais pour éviter de la conso sur les sorties directement (la conso se fait sur la PIN VCC des cartes relais).
Si jamais c'est le cas, il faut agir inverser la commande.

Donc normalement quand on a les PIN en sorties, tous les relais sont sur OFF, mais avec notre carte relais il faut inverser, ce qui veux dire que de base quand on va mettre les PINs en sortie, les relais vont claquer de suite.
On va les remettre à zéro en faisant pour la bank A (GPA0-7) :
i2cset -y 1 0x20 0x14 0xFF
Pour des cartes relais normales, il faudra donc faire un
i2cset -y 1 0x20 0x14 0x00

Et pour la bank B (GPB0-7) :
i2cset -y 1 0x20 0x15 0xFF
Pour mettre à 1 la sortie GPB0, sur une carte relais normale, il faut faire
i2cset -y 1 0x20 0x15 0x01
Dans notre cas avec une carte relais inversé, il faudra faire
i2cset -y 1 0x20 0x15 0xFE
Le dernier élément de la ligne 0x01 (ou 0xFE en inversé) correspond au status des 8 relais de la Bank concerné.
A chaque ordre, nous renvoyons donc toute la Bank. Il faudra donc mettre en place une mémoire des états.

Si vous avez compris, tout se passe en binaire, on a 8 PINs, donc pour mettre à 1 le premier PIN (Pin 0), il faudra envoyer pour une carte relais normale

0000 0001 ce qui correspond à 0x01 en Hexa.

L'inverse pour une carte relais comme la notre est
1111 1110 ce qui correspond à 0xFE en Hexa.
Pour mettre à 1 les PINs 0, 3, et 7 sur une carte relais normale
1000 1001 ce qui correspond à 0x89 en Hexa.
Sur une carte relais inversé
0111 0110 ce qui correspond à 0x76 en Hexa.
Ici il faut juste comprendre que le Pin0 est le bit de poids faible et le Pin7 celui de poids fort. Un schéma est plus parlant...


Je ne vais pas faire une cours de conversion Binaire Hexa mais en gros voici la procédure :
Pour passer du binaire à l'Hexa, on passe par du décimal, qui lui utilise une table conversion pour aller à de l'Hexa.

Revenons à nos moutons, comme dit plus haut, au démarrage les PINs sont en entrée, on va donc créer un script de démarrage pour les passer en sortie au démarrage :
sudo vi ~/start.sh

Le fichier doit inclure 2 choses, passer en premier les ports à 0 puis les configurer en sortie, ainsi on évite le clac intempestif du démarrage des relais du à ma carte inversé. Copier tout dans le nouveau fichier :
#!/bin/bash
i2cset -y 1 0x20 0x14 0xFF
i2cset -y 1 0x20 0x15 0xFF
i2cset -y 1 0x20 0x00 0x00
i2cset -y 1 0x20 0x01 0x00
Pour une carte relais normale :
#!/bin/bash
i2cset -y 1 0x20 0x14 0x00
i2cset -y 1 0x20 0x15 0x00
i2cset -y 1 0x20 0x00 0x00
i2cset -y 1 0x20 0x01 0x00
Penser à le rendre Exécutable  :
sudo chmod 755 ~/start.sh
On va maintenant mettre ça dans un CRON qui se lance au démarrage :
crontab -e
Rajouter à la fin :
@reboot /bin/sh /home/nom-user/start.sh
Pensez à modifier le nom-user par le nom d'utilisateur avec lequel vous travaillez.
Le fichier CRONTAB se modifie avec nano, pas besoin de faire un "i" pour passer en édition, et pour sauvegarder, il faut faire un Ctrl+X puis Yes et entrée.
Pour que le crontab se modifie avec Vi, il faut modifier l'éditeur pas défaut (qui est nano), pour cela :
export EDITOR=vi
Voilà, normalement c'est fini pour la partie montage et paramétrage Rpi.
La suite : PHP pour contrôler tout ça.

jeudi 8 mai 2014

Base Pi

Premier pense bête alors on va commencer tout doux, j'utilise pas mal les Rpi pour ma domotique maintenant parce que c'est pas cher ! Et pis c'est fiable (avant de refaire celui de mon garage, l'install avait 1 an de bon et loyaux service).

Un raspberry Pi alias Pi alias Rasp alias Rpi c'est ça http://www.raspberrypi.org/


Alors on va commencer par préparer le Rasp.

First Step : On installe Raspbian sur la carte SD, 8Go c'est bien mais 4Go suffisant.
Voir : http://www.raspberrypi.org/downloads/

Normalement le SSH est activé par défaut, donc on se connecte en SSH dessus (via Putty) :
Login : pi
MDP : raspberry

Première étape, mise à jour des paquets :
sudo apt-get update
Ensuite on mets les paquets à jour :
sudo apt-get upgrade
Avant toute modif via VI, on installe le paquet VIM
sudo apt-get install vim
Comme on ne veux pas garder le user Pi parce que c'est pas secure, on créé un nouvel utilisateur :
sudo adduser nom-d'utilisateur
Plein de question seront posée, on y répond si on veux, et on fini par mettre le mot de passe de ce compte.
Maintenant on va donner tous les droits équivalent au user Pi à notre nouveau nom.
Pour ça, on fait un
sudo vi /etc/group
Pour l'utilisation de Vi, on appuis sur "i" pour passer en mode insertion, on fait les modifs, et pous sauvegardé, on enchaine "Echap" puis ":wq".
On rajoute notre nouveau nom d'utilisateur à coté de Pi en séparant par une virgule.
Une fois que c'est, on se reconnecte avec notre nouvel utilisateur, et on vérifie que tout fonctionne, à savoir un
sudo vi /etc/group
Si on peux modifier ce fichier et sauvegarder, c'est que c'est bon (on peux tester de supprimer le login Pi sur un groupe).
Une fois que c'est fait, on va conserver un peu le user Pi histoire de ne pas se retrouver bloqué.
On passe à la configuration du Pi, on fait un
sudo raspi-config
On fait en premier l'option 1, à savoir "Expand Filesystem", ça permet de prendre toute la place sur la carte SD. Faire l'option 4 également "Internationalisation Options" qui va permettre de passer le Pi en Locale FR + timezone FR et Disposition clavier FR (donc les trois options du menu 4).

On fait un Back puis Finish et on reboot le Pi.
Suite au redémarrage, on se reconnecte en SSH sur le Pi avec le nouveau user.
On va maintenant modifier le comportement de SSH pour que le login "root" ne soit pas permis.
sudo vi /etc/ssh/sshd_config
Dans l'encart "# Authentication:" on passe le "PermitRootLogin" à no
On sauvegarde "Echap" puis ":wq".

On va maintenant changer le nom du Raspberry, pour cela on va modifier 2 fichier.
Le premier
sudo vi /etc/hosts
Où on remplace la dernière ligne à savoir
127.0.1.1       nouveau-nom
Puis
sudo vi /etc/hostname
Où l'on remplace par le nouveau nom.
A ce stade, nous n'avons plus besoin du user Pi, après toutes ces modifs, ça veux dire que les droits sont corrects.
Pour le supprimer :
sudo userdel pi
Voila pour la configuration de base, maintenant on va installer quelque truc indispensable à un Pi.
La suite AMP, Apache pour le serveur Web, Mysql pour la base de données (pas obligatoire), et PHP parce que c'est la classe.
sudo apt-get install apache2 php5 libapache2-mod-php5 php5-common php5-cgi php5-cli
Puis
sudo apt-get install mysql-server mysql-client php5-mysql
Une fois que tout est installé, on va modifier Apache :
sudo vi /etc/apache2/apache2.conf
Au premier blanc, on ajoute :
ServerName localhost
Puis on redémarre le service apache :
sudo /etc/init.d/apache2 restart
Ça permet d'enlever l'erreur d'apache au démarrage "Could not reliably determine the server’s fully qualified domain name, using 127.0.1.1 for ServerName"

Maintenant on va donner les droits au nom d'utilisateur d'apache (www-data) et à votre utilisateur pour des simplifications lorsque nous allons créer le site WEB :

sudo chown www-data:www-data /var/www
sudo usermod -a -G www-data votre-utilisateur
sudo chmod -R 775 /var/www/
Pensez à modifier  votre-utilisateur par votre utilisateur.
Une fois que ça c'est fait, on va installer Postfix, pour pouvoir envoyer des mails en relais via un compte Gmail.

sudo apt-get install postfix
On va maintenant modifier la conf :
sudo vi /etc/postfix/main.cf
On rajoute où il y a de la place :
inet_protocols = ipv4
smtp_use_tls=yes
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options = noanonymous
canonical_maps = hash:/etc/postfix/sender-canonical
relayhost =  [smtp.gmail.com]:587
 On modifie les alias de la machine :

 sudo vi /etc/aliases
Voila à quoi doit ressembler le fichier :
# /etc/aliases
mailer-daemon: postmaster
postmaster: root
nobody: root
hostmaster: root
usenet: root
news: root
webmaster: root
www: root
ftp: root
abuse: root
noc: root
security: root
votre-utilisateur:root
root:votre-adresse-mail
Pensez à modifier votre-utilisateur par votre utilisateur et votre-adresse-mail par votre adresse mail sur laquelle vous voulez recevoir les notifications.

Maintenant on va configurer le compte Gmail avec lequel on va faire le relais :
sudo vi /etc/postfix/sasl_passwd
Le fichier doit ressembler à ça :
[smtp.gmail.com]:587 votre-adresse-mail@gmail.com:votre-mot-de-passe-mail
 Pensez à modifier votre-adresse-mail@gmail.com par votre adresse mail, et votre-mot-de-passe-mail par votre mot de passe de votre compte mail.

On va configurer avec quel @mail on va envoyer des message et suivant l'utilisateur.
sudo vi /etc/postfix/sender-canonical
 Le fichier doit contenir
root votre-adresse-mail@gmail.com
votre-utilisateur votre-adresse-mail@gmail.com
smmsp votre-adresse-mail@gmail.com
votre-utilisateur@nom-du-raspberry   votre-adresse-mail@gmail.com
postmaster  votre-adresse-mail@gmail.com
Pensez à modifier tous les champs.
Maintenant on compile tous les fichier créé :
sudo postalias /etc/postfix/sender-canonical
sudo postmap /etc/postfix/sasl_passwd
Puis on redémarre Postfix pour prendre en compte les modifications.
sudo /etc/init.d/postfix restart
On peux faire un test d'envoi de mail pour savoir si tout est OK en faisant :
mail  adresse-mail-destinataire
 on demande un Subject puis le contenu du message, et on termine par un point '.'
Ça ressemble à ça :
rasp@rasp ~ $mail xxxxx@gmail.com
Subject: test
blabla
.
Normalement ça devrait le faire.
Enfin, on va configurer le bash pour que dès qu'un user se connecte au Pi, ça envoi un mail.
sudo vi /home/votre-utilisateur/.bashrc
On rajoute à la fin :

# notification email de chaque connexion ssh
echo 'NOTIFICATION - Acces SSH sur le Raspberry nom-du-raspberry le:' `date` `who` | mail -s "NOTIFICATION - Connexion en Server via SSH depuis: `who | cut -d"(" -f2 | cut -d")" -f1`" adresse-mail-destinataire
Penser à modifier nom-du-raspberry et adresse-mail-destinataire
Voila pour moi c'est un Pi basique sur lequel on va pouvoir faire tout plein de chose.