Le75::TangoDelta

Etat du projet le 25/12/2015

1 - Projet : un oeil dans le dos

Après avoir envisagé une caméra de surveillance embarquée sur mon vélo, puis y avoir renoncé pour des raisons évidentes de sécurité, pour le remplacer par un projet de surveillance des mes amis et proches puis y avoir renoncé pour des raisons évidentes de respect pour le remplacer par un projet d'autosurveillance puis y avoir renoncé pour des raisons évidentes d'achat devenu alors inutile d'un raspberry pi...

j'envisage désormais l'usage de la raspberry pi comme caméra espion embarquée dans mon sac à dos.

Outil de captation numérique détourné:

caméra numérique raspberry NoIR (infra-rouge..) Le détournement de l'outil ne sera pas direct, mais ce fera dans la réinterprétation des données vidéos collectées.

Comment ?

Avec l'aide d'un as de la programmation, la main de mon cerveau, Nathan Lapel (..cousin du susdit cerveau). Nous avons (... il a) élaboré un programme d'interprétation des données - octets - constitutifs de l'ensemble de la vidéo pour obtenir un visuel fixe dont les proportions correspondent à celles du format A4, A3, etc (cf. le complexe calcul plus bas ..)

Pourquoi ?

Le projet traite de vidéosurveillance (et de l'ensemble des débats que ça peut animer sans que j'ai nécessairement envie d'en parler ici..). Les vidéos relatent des évènements, plus ou moins importants, liés à mes déplacements. Le seul élément objectif restant de ces vidéos sera les dates, heures et lieux de captation. L'image générée aléatoirement parlera alors d'un évènement survenu dans ce contexte, devenu extrêmement énigmatique, à décoder ou pas, selon qu'on est curieux ou non. La série relatera une journée.

2 - Matériel nécessaire

> Un raspberry Pi

Le Raspberry en question est le modèle B+. Ici, en lien, les qualités du bidule : https://www.raspberrypi.org/products/model-b-plus/

> Un module caméra infrarouge

Le modèle en question est le Pi NoIR Camera. Ici, le descriptif du machin : https://www.raspberrypi.org/products/pi-noir-camera/

> Une batterie Lithium

Celle achetée : 1000 mAh, 3,7 V Fonction : source d'alimentation de l'ensemble.

> Li-Po Rider

Le modèle choisi est Li-Po Rider Pro de Seeed Studio. ... dont voici le petit descriptif : http://www.seeedstudio.com/wiki/index.php?title=Lipo_Rider_Pro Fonction : intermédiaire entre la source d'alimentation et le raspi'spositif

> Une carte micro SD

Il est conseillé de prendre une carte de classe 10. Fonction : configuration et installation de RaspBian sur le Raspberry Pi.

> Un espace de stockage des données vidéos collectées

... qui sera mon disque dur externe personnel.

3 - Préparation, assemblage, construction

1 - Installation et configuration de Raspbian

2 - Installation et programmation du module caméra Pi Noir

- Configurer la captation : J'ai calculé ... .. pour imprimer une image A3 d'une résolution de 300 dpi Surface en cm² d'un A3 avec des marges d'un pouce : (42-5,08)*(29,7-5,08) cm²

... qu'on divise pour obtenir l'équivalent en pouce carré (1 pouce = 2,54 cm) : (42-5,08)*(29,7-5,08)/(2,54²)

... qu'on multiplie par la résolution 300 dpi au carré ... (42-5,08)*(29,7-5,08)/(2,54²)*300²

... qu'on multiplie par le nombres d'octets contenus dans un pixel, 3, correspondant aux trois couleurs Rouge, Vert, Bleu ... (blablabla...)*3

... qu'on divise par 1024² pour obtenir le résultat en mégaoctets

Résultats : 36,278235741591104

Environs : 36,278 MégaOctets...

Ce qui veut dire que pour pouvoir retranscrire le maximum d'informations captées en 300 dpi, la vidéo captée ne doit pas excéder les 36,278 MégaOctets. Ils varient selon la durée, la taille de l'image et sa qualité, le format de compression.

- test autonomie de la batterie lithium : chargée, son autonomie n'est que de 4h.

Script de la raspicam :

> Echec #1 script 1 : captations de 10 secondes, à intervalle d'une heure, sur 24h. Application: rtcwake.. Non disponible dans le raspberry (contre toute-attente). Disponible avec une horloge rtc à ajouter... à mes frais !

> Proposition #2 : une captation de 1h.

Nathan tente de concevoir un programme qui, selon mon format d'images voulues et celui des images sources, alligne les pixels d'une vidéos sur un même plan. Ainsi, pour savoir exactement combien de temps est synthétisé en une seule image, il me faut faire correspondre le format avec la résolution de la capture ..

Fichier:P2060008.JPG

Variables : A régler dans le TangoDeltaProgram :

> image cible : format, taille et résolution selon qu'elle est projetée(72dpi) ou imprimée(300dpi)

A régler dans le raspi code : https://www.raspberrypi.org/documentation/usage/camera/raspicam/raspivid.md https://www.raspberrypi.org/documentation/raspbian/applications/camera.md

> nombre d'images secondes : 1, 12 (anim), 16 (impression de fluidité), 24 (vue humaine européenne), 30 (vision ultrasonique japonaise)

--framerate, -fps Specify the frames per second to record

At present, the minimum frame rate allowed is 2fps, the maximum is 30fps.

> résolution images capturées

--width, -w Set image width <size>

Width of resulting video. This should be between 64 and 1920.

--height, -h Set image height <size>

Height of resulting video. This should be between 64 and 1080.

> durée de la captation :

raspivid -o video.mp4 -t 10000 pour 10 secondes (-t x millisecondes)

> fichier cible

--output, -o Output filename <filename>.

Specify the output filename. If not specified, no file is saved. If the filename is '-', then all output is sent to stdout.

Premiers tests :

3 - Fabrication d'un étui de protection.

4 - Sources et références

ohé, du bateau ?

- Le site des fanatiques mondiaux de raspberry : www.raspberry.org - Le site français des makers fanatiques de arduino et raspberry : http://www.framboise314.fr/ - Un projet de RaspiCam avec détection de mouvement : http://www.zem.fr/fabriquer-une-camera-hd-de-surveillance-raspicam-avec-votre-raspberry-pi/ - Un article sur l'anatomie de la bête : http://raspberrypis.net/les-branchements-du-raspberry-pi/ - Le projet de Christoph Buenger (internet et détection de mouvement) : http://www.framboise314.fr/une-camera-de-surveillance-video-avec-le-raspberry-pi/

- Cf:Programme Jonathan Puckey - Skycatcher

---

- penser la "boite" qui contiendra le dispositif (sécurité)

- tester le poids que prend une vidéo sur la carte

- selon le poids, utiliser soit un disque externe soit une carte sd plus importante

---

Logiciels, programmes et projets traitant de la réinterprétation du code binaire :

Logiciels hexadécimaux (délivre les codes binaires bruts) : ouvrir n'importe quel fichier numérique avec ces logiciels permet d'en révéler le code binaire source - sous windows : free hex editor - sous linux : bless hex editor ou wx hex editor.

Autres logiciels : - sous Windows : Binarization image Processor (binariser les images numériques)

Sites : - www.text-images.com, traduit des images en code binaire visuel. - http://www.supportduweb.com/convertisseur-textes-binaire-code-ascii-numerique-ordinateur-secret-encoder-text-binary-chiffrer.html, convertit du texte en langage binaire (ex : pour retranscrire une conversation) - http://www.dcode.fr/image-binaire, convertit une image fixe en code binaire

Configuration raspicam :

https://www.raspberrypi.org/documentation/usage/camera/raspicam/raspivid.md

https://www.raspberrypi.org/documentation/raspbian/applications/camera.md

écrire un script (oui oui .. encore là !)https://fr.wikibooks.org/wiki/Programmation_Bash/Scripts

Fonctionnement du module caméra : http://www.epingle.info/?p=2756

---

Processing

Code animation :

int positionYa;
int positionXa;
int positionYb;
int positionXb;
int vitesse1;
int vitesse2;

void setup(){
  size(800,800);
  background(3,252,234);
  positionYa=200;
  positionXa=600;
  positionYb=100;
  positionXb=100;
  vitesse1=1;
  vitesse2=2;
}

void draw(){
  background(3,252,234);
  noStroke();
  fill(180,22,22);
  triangle(400,400,positionXa,positionYa,positionXb,positionYb);
  positionXa=positionXa+vitesse1;
  if(positionXa==800){
    vitesse1=-1;
  }
  if(positionXa==100){
    vitesse1=1;
  }
  positionYa=positionYa+vitesse2;
  if(positionYa==600){
     vitesse2=-2; 
  }
  if(positionYa==0){
    vitesse2=2;
  }
  positionXb=positionXb+vitesse1;
  positionYb=positionYb+vitesse2;
  
  fill(255,230,103);
  ellipse(positionXb+positionXa,positionYa+positionYb,15,15);
}

Code animation "2 espaces indépendants" :

float ellipX;
float ellipY;
float vitesX;
float vitesY;
int red;
int green;
int blue;
int vitesred;
int vitesgreen;
int vitesblue;
int ellipseX;
int ellipseY;
int vitesseellipseX;
int vitesseellipseY;
int pointb;
int vitesseb;

void setup(){
  size(550,800);
  
  noStroke();
  fill(158,192,193);
  rect(0,0,550,550);
  
  noStroke();
  fill(255,220,155);
  rect(0,550,550,250);
  
    ellipX=150;
    ellipY=300;
    vitesX=1;
    vitesY=0.5;
    ellipseX=400;
    ellipseY=650;
    vitesseellipseX=1;
    vitesseellipseY=2;
    red=158;
    vitesred=1;
    green=192;
    vitesgreen=1;
    blue=193;
    vitesblue=1;
    pointb=1;
    vitesseb=1;

}

void draw(){
  //mouvement rect 1
  // une ellipse dont la couleur de remplissage varie
  //rebondit sur chaque cotés du rectangle
  //sa couleur de remplissage
  noStroke();
  fill(158,192,193);
  rect(0,0,550,550);
  
  noStroke();
  fill(red,green,blue);
    red=red+vitesred;
      if(red==178){
        vitesred=1;
      }
      if(red==255){
        vitesred=-1;
      }
      
     green=green+vitesgreen;
       if(green==192){
         vitesgreen=1;
       }
       if(green==255){
         vitesgreen=-1;
       }
       
      blue=blue+vitesblue;
        if(blue==193){
          vitesblue=1;
       }
        if(blue==255){
          vitesblue=-1;
        }
        
  ellipse(ellipX,ellipY,100,100);
    ellipX=ellipX+vitesX;
      if(ellipX==500){
        vitesX=-0.5;
      }
      if(ellipX==50){
        vitesX=1;
      }
    ellipY=ellipY+vitesY;
      if(ellipY==500){
        vitesY=-1;
      }
      if(ellipY==50){
        vitesY=0.5;
      }
       
  
  //mouvement rect 2
  //1 disque sans contour rebondit sur les côtés du rectangle
  //sa couleur de remplissage dépend de sa position
  noStroke();
  fill(255,220,155);
  rect(0,550,550,250);
  
  noStroke();
  fill(255,ellipseX-200,ellipseY-400);
  ellipse(ellipseX,ellipseY,100,100);
    ellipseX=ellipseX+vitesseellipseX;
      if(ellipseX==500){
        vitesseellipseX=-1;
      }
      if(ellipseX==50){
        vitesseellipseX=1;
      }
      
    ellipseY=ellipseY+vitesseellipseY;
      if(ellipseY==750){
        vitesseellipseY=-2;
      }
      if(ellipseY==600){
        vitesseellipseY=2;
      }

//une ligne
  //qui se dessine de gauche vers la droite
  //qui quand elle touche le bout se rétracte
  //puis repart

noStroke();
fill(0);
rect(0,550,pointb,3);
pointb=pointb+vitesseb;
if(pointb==550){
vitesseb=-1;
}
if(pointb==1){
vitesseb=1;
}
   
}

Code : Interpréter des consignes

// faire un triangle 
// qui se déplace dans un cercle 
// en rebondissant sur les bords
// en changeant de couleurs à chaque intersection
float absycentr;
float ordocentr;
float vitesseabsy;
float vitesseordo;
int green;
int blue;
int red;

void setup(){
  size(600,600);
  background(152,40,209);
  absycentr=100;
  ordocentr=100;
  vitesseabsy=2;
  vitesseordo=3.5;
  red=250;
  green=250;
  blue=250;
}

void draw(){
  
  background(152,40,209);
  fill(20,255,0);
  ellipse(absycentr,ordocentr,100,100);
  absycentr=absycentr+vitesseabsy;
  if(absycentr>=550||absycentr<=50){
  vitesseabsy=-vitesseabsy;
}
  ordocentr=ordocentr+vitesseordo;
  if(ordocentr>=550||ordocentr<=50){
  vitesseordo=-vitesseordo;
}
  fill(red,green,blue);
  if(absycentr>=550){
    red=0;
    green=30;
    blue=250;
  }
  if(absycentr<=50){
    red=50;
    green=0;
    blue=100; 
}
  
  if(ordocentr>=550){
  red=80;
  green=0;
  blue=10;
}
  if(ordocentr<=50){
  red=0;
green=50;
blue=50;
}

  triangle(absycentr-35,ordocentr,absycentr,ordocentr+30,absycentr+22,ordocentr-20);
  

}