Les Joystick et bouton de la PSVita sur Unity

Après quelques galères j’ai enfin réussi à faire fonctionner les joysticks et boutons de la Vita avec Unity.

Les boutons

La définition est la suivante :

  • × KeyCode.JoystickButton0
  • ○ KeyCode.JoystickButton1
  • □ KeyCode.JoystickButton2
  • △ KeyCode.JoystickButton3
  • L KeyCode.JoystickButton4
  • R KeyCode.JoystickButton5
  • SELECT KeyCode.JoystickButton6
  • START KeyCode.JoystickButton7
  • up KeyCode.JoystickButton8
  • right KeyCode.JoystickButton9
  • down KeyCode.JoystickButton10
  • left KeyCode.JoystickButton11

Jusque là rien de sorcier, un code simple dans l’update permet de récupérer le bouton sur lequel on appuie pour effectuer une action.

if (Input.GetKeyDown(KeyCode.JoystickButton8))
{
transform.Translate(new Vector3(0, 0, speed) * Time.deltaTime);
}

Dans ce code on déplace un objet (d’où le Translate) lors de l’appuie sur le bouton 8 (donc quand on va ver le haut avec le Pad de la Vita).

Les Joysticks !

De ce coté la c’était un poil plus complexe, mais voici la solutions. Cliquez sur « Edit -> Projet Setings – > Input » et vous verrez apparaitre sur la droite un panel dans lequel nous définirons nos JoySticks et leurs paramètres.

Définissez alors vos 4 axes en respectant bien les paramètres qui sont sur la capture. Vous pouvez par contre les nommer différemment, c’est ce nom qui vous permettra de récupérer les données dans le code.

il faut bien faire attention aux paramètres « Dead, Sensivity et à l’inversion sur les Y ».

Tous les axes proviennent du Joystick sur la PSVita, les autres 2,3,… servent pour d’autres périphériques. Chaque axe est assigné a un Axe (X pour l’horizontale sur le joystick de gauche, 5eme axe sur le Y de celui de droite… tout ceci est défini dans la documentation officielle Sony.

Pour récupérer la valeur il faut juste mettre dans le code (ici pour l’axe X du Joy de gauche) :

valeur = Input.GetAxisRaw(« JoyLX ») * speed;
transform.Translate(new Vector3(valeur, 0, 0) * Time.deltaTime);

Et voila, maintenant que l’on sait faire bouger un objet on va pouvoir avancer sérieusement :!

Unity et la PSVita

J’ai récupéré une PSVita il y a peur afin de pouvoir jouer a FFX et en cherchant quelques informations sur celle-ci j’ai découvert que la PSvita est supporté par le SDK Unity.

J’ai trié toutes les informations que j’ai trouvé et je vous partage la méthode a suivre afin d’installer correctement un environnement Unity pour PSVita sur PC.

Pour commencer il faut récupérer tout le nécessaire sur le Net :

  • SDK PSVita 3.5
  • Unity 2017 4.2f2
  • Les outils Sony (détail plus bas)
  • La clé Unity pour PS4/PSVita
  • UnityTools qui nous permet de convertir ses build en vpk pour la Vita

On décompresse alors le SDK dans C:\PSVITA
On définie ensuite une variable d’environnement système que l’on nomme SCE_PSP2_SDK_DIR et que l’on fait pointer vers le SDK C:\PSVITA\sdk
puis une SCE_ROOT_DIR vers C:\Program Files (x86)\SCE

Puis on installe les outils suivant :

  • TMServer-3_60_0_2
  • USBDriver-Win64-1_80_0_70253
  • ContentManagerAssistant-3_3_0_7825 (Attention si vous avez le CMA déja installé, désinstallez le avant)USBDriver-Win64-1_80_0_70253
  • USBDriver-Win64-1_80_0_70253
  • PublishingTools-2_31_0_1669
  • Battery Monitor 3_60_1_12

Et pour finir, on installe dans l’ordre :

  • Unity Download Assistant
  • Unity Setup
  • Unity Setup Playstation Vita Support

Lors du lancement il faut alors saisir la licences PSVita ou PSVita/PS4 de Unity.

Et on se lance enfin dans la création d’un HelloWorld 🙂

Une fois le projet packagé il vous suffit de le transférer sur le Vita via VitaShell ou autre et de l’installer !

Et voila, a vous de coder 😉

Supervision de la serre (Web et Android)

Mon père a construit une serre il y a peu, et je me suis dit que ce serait intéressant d’analyser quelques données et pourquoi pas ensuite les exploiter ensuite afin de gérer l’ouverture automatique de celle-ci.

C’était aussi l’occasion de trouver une utilisation à mon Akeru (Arduino made in SnootLab qui utilise le réseau Sigfox) qui dormait depuis un moment.

Superviser ? Oui, mais quoi ?

Dans une serre, il y a deux choses importantes, la température et l’humidité. J’ai fouillé dans mon bazar et j’ai trouvé tout un tas de capteurs. Voilà ce que j’ai retenu :

  • Une sonde DS1820 étanche pour mesurer la température extérieure.
  • Une sonde DHT22 pour mesurer la température intérieure et l’humidité.
  • Un capteur RGB / Proximité / Lumière qui servira pour savoir s’il fait jour ou non et aussi pour déclencher l’affichage des valeurs en passant la main devant.
  • Une matrice de LED gérée par un MAX7219.
  • Et donc un Akeru (Arduino équipé d’un modem Sigfox).

La mise en place

Le câblage et l’utilisation de ce matériel est suffisamment simple, j’ai donc fait des programmes individuels afin de tester chaque capteur puis j’ai tout mis dans un sketch afin de récupérer toutes les données…. et ce fut un échec, pas assez de mémoire disponible sur l’atmega.

J’ai donc fait quelques tests et cherché comment réduire la taille de mon sketch. En premiers lieux j’ai mis toutes les chaînes constantes qui sont dans me « Serial.print » en progmem grâce à la fonction F mais ce n’était pas suffisant.

Je me suis alors penché sur les librairies. Par exemple pour la DHT22 j’utilisais la librairie de chez Adafruits qui est très bien mais qui occupe beaucoup de mémoire. 

Après avoir testé toutes les librairies pour les DHT j’ai choisi la TroykaDHT qui prend deux fois moins de place. J’ai fait de même pour la librairie du capteur RGB/Lumière (la Sparkfun est bien plus gourmande que celle d’Adafruit) et pour la gestion de la matrice de LED (je voulais utiliser la MD_Parola qui s’ajoute à la librairie MAX72XX pour proposer des fonctions de scrolling et d’autres dont je n’avais pas besoin j’ai donc codé le scrolling directement dans mon sketch).

Ces changements m’ont permis de diviser par 2 la taille de mon programme, il n’occupe donc que 60% de la mémoire ce qui me permettra d’ajouter des fonctionnalités plus tard comme un capteur de pluie, l’ouverture via un moteur …

Lecture des données

Le modem envoie des données sur le réseau Sigfox (un réseau bas débit disponible partout en France et dans beaucoup d’autres pays) qui les renvoie via un « callback » sur un serveur maison où je les stocke dans une base de données. J’ai ensuite fait une petite interface en utilisant chartJS afin de les visualiser.

Et sur ANDROID ?

Eh bien j’ai fait très simple; en utilisant l’objet « WebView » du SDK Android on peut encapsuler un site web dans une application.

package eu.rouanetnet.serreleminade;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.webkit.WebSettings;
import android.webkit.WebView;


public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

WebView myWebView = (WebView) findViewById(R.id.web1);
WebSettings webSettings = myWebView.getSettings();
webSettings.setJavaScriptEnabled(true);
myWebView.loadUrl("https://rouanetnet.eu/tempMazamet/");
}
}

Attention à ne pas oublier d’ajouter cette ligne dans le manifest sans quoi votre application n’accèdera pas a internet et vous ne verrez rien dans votre appli.

<uses-permission android:name="android.permission.INTERNET"></uses-permission>

Vous trouverez bientôt le code sur mon github.

Peu de nouvelles ces temps-ci….

Comme vous l’avez remarqué il n’y a pas eu de publication depuis un bon moment… La raison ? C’est la création d’une association « Rétro Happy Games » qui a pour but de promouvoir et  sauvegarder le patrimoine des jeux de café.


Nous proposons donc aux gens de venir avec nos machines sur des évènements mais nous aidons aussi les propriétaires de machines a les entretenir et à les réparer.


Vous trouverez sur notre page Facebook les différentes machines qui passent dans nos mains 😉


https://www.facebook.com/RetroHappyGames/

N’hésitez pas nous contacter, même par simple curiosité ou juste pour passer faire une petite partie !


Cependant je travaille sur un « Gros » projet qui sera bientôt dévoilé ici même.

A bientôt,

Brice.

Un mod TV pour mon flipper

Depuis peu nous avons un flipper « Bugs Bunny » à la maison, et j’avais déjà vu passer sur certains (adams, simpson,…) des mods pour y intégrer une mini télévision qui diffuse des images du film. Plutôt que d’en acheter un j’ai décidé de me le faire.

Matériel nécessaire :

Vous trouverez ici les fichiers 3D pour imprimer le boitier (je l’ai fait couleur carotte forcément) . C’est un boitier assez simple car le design 3D c’est pas trop mon truc.

https://github.com/tmator/pintv/tree/main/3d

Je propose maintenant une image (Téléchargeable ICI) à installer sur une carte SD de 16Gb ou plus, décompressez l’images puis mettez la sur votre carte SD via Win32DiskImager ou Balena.

Une fois que votre SD sera prête vous verrez apparaitre un lecteur de 4Go dans lequel vous pouvez déposer les fichier dans le dossier PinTV.

Pour les vidéos, je conseille du 640×480 en AVI/Xvid.

Enjoy !

PinTV démo

——————————- Ci dessous l’ancien Tuto ——————————-

Préparation du raspberry pi

Il faut en premier installer Raspbian puis le driver de l’écran :

https://raspberrypiwiki.com/2.8_inch_Touch_Screen_for_Pi_zero

Ensuite on install mplayer qui servira pour lire les vidéos ;

apt-get update; apt-get install mplayer

On crée un dossier pintv dans /home/pi dans lequel nous mettrons les vidéos, et nous déposons le fichier pintv.sh (dispo sur le github) dans /home/pi (vous pouvez utiliser filezilla par exemple pour transférer les fichiers). Il faut ensuite rendre le fichier exécutable :

chmod +x /home/pi/pintv.sh

Puis on ajoute le lancement de celui-ci a la fin du fichier /home/pi/.bashrc afin qu’il se lance tout seul.


/home/pi/pintv.sh

On modifie le /boot/cmdline.txt pour désactiver la mise en veille en ajoutant en fin de ligne :

consoleblank=0

Ensuite nous allons supprimer la partie graphique et passer le système en lecture seule afin d’allonger la durée de vie de notre carte SD car le Raspberry s’arrêtera brutalement lorsque nous arrêterons le flipper.

apt-get remove --purge lightdm

 wget https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/read-only-fs.sh

 sudo bash read-only-fs.sh

 CONTINUE? [y/N] y
 Enable boot-time read/write jumper? [y/N] n
 Install GPIO-halt utility? [y/N] n
 Enable kernel panic watchdog? [y/N] y
 Target system type:
 Pi 3 / Pi Zero W
 All other models 
 SELECT 1-2: 1
 Boot-time R/W jumper: NO
 Install GPIO-halt: NO
 Enable watchdog: YES (Pi 3 / Pi Zero W)
 CONTINUE? [y/N] y
 REBOOT NOW? [y/N] y

Et voila, si tout va bien on a une superbe MiniTV 🙂

PinTV démo

Si vous avez besoin de faire des modifications sur le raspberry, voici les commandes pour repasser le système de fichier en écriture :

sudo mount / -o remount,rw
sudo mount /boot -o remount,rw

L’IOT au service de l’IT

En cette période estivale caniculaire, un onduleur n’a pas supporté l’arrêt inopiné de la climatisation et a rendu l’âme, merci au fabricant de ne pas avoir inclus de sécurité liée à la température… Du coup nous avons commencé à regarder les solutions afin d’être prévenu en cas de surchauffe et j’en ai profité pour faire un petit POC avec du matériel de récupération que j’avais à la maison.

Matériel nécessaire

  • Un Akeru pour envoyer les informations via le réseau SIGFOX
  • Une sonde DS18B20
  • Une résistance 4.7K pour la sonde
  • Un module de charge de batteries Lipo
  • Une batterie Lipo
  • Un petit écran Oled pour afficher la température

On câble tout ça et voila le résultat (sans scotch ni colle !)

Sur le backend Sigfox j’ai juste ajouté un callback qui envoie un email à chaque réception d’information, soit toutes les 12 minutes. Cela évite de dépasser la limite de message journalière et il nous en reste pour envoyer des alertes en cas dépassement du seuil de température d’alerte que nous avons fixé.

Les tests étant concluants je pense explorer cette piste (en Sigfox ou LoraWan) afin de surveiller quelques paramètre dans nos salles critiques.

Le Blagotron

Mais qu’est ce donc ? Tout simplement un distributeur de blagues.

L’idée est venue à cause de grâce à Lionel B, voisin de bureau qui nous raconte tous les jours pas mal de blagues. Il fallait donc trouver un « remplaçant » pendant ses congés.

Comment ça marche ?

L’idée d’origine était d’avoir un simple bouton qui lorsque l’on appuie dessus imprime un blague. Donc c’est assez simple mais pour rajouter un coté vintage je me suis senti obligé de ressortir encore une fois le Minitel.

Mise en oeuvre

Il faut :
1 – Arduino UNO.
1 – Raspi / Ordi
1 – Minitel
1 – Imprimante a ticket

Blagotron

L’Arduino est relié au Minitel via son port DIN et sert d’interface série entre celui-ci et le Raspi mais aussi à afficher l’interface sur l’écran du minitel. J’utilise la librairie de Jerome Saint-Clair aka 01010101 qui est issue du travail du Tetalab (Fabrice, Renaud, PG, Phil et Liodel). Il faut sur le Minitel désactiver l’echo « Fnct + T E ».
Un script python écoute sur le port série les informations envoyées depuis le Minitel via l’Arduino et sélectionne ensuite la blague à imprimer puis l’envoie à l’imprimante.
Pour la partie impression j’utilise une imprimante chinoise pas chère qui peut être utilisée directement en python avec la librairie python-escpos.

Utilisation

L’utilisation est simple, on choisit un thème de blague avec le clavier du minitel et ensuite elle est imprimée.

Petite vidéo de démonstration :

Le code sera très prochainement disponible ici.

Un peu de délire

En 1992, un jeu d’un nouveau genre est apparu sur nos écrans. Un jeu que l’on pourrait qualifier de jeu « Online visiophonique » !
Le principe de l’émission était simple, un jeu vidéo pour attirer les geeks en herbe et une présentatrice sympathique (la très sexy Karen Cheryl) pour faire grimper un peu plus l’audience.
Dans sa première version, le principe du jeu est plutôt basique, il s’agit de diriger le personnage via les touches 4 et 6 de son téléphone. Nous allons donc voir comment recréer facilement ce système de contrôle. Cette émission se nommait « Hugo Délire ».

Karen

Comment ça marche ?

Grace au DTMF (non ce n’est pas la dernière insulte à la mode mais plutôt l’abréviation de dual-tone multi-frequency ou fréquences vocales pour les français), on peut savoir sur quelle touche la personne appuie en fonction de la fréquence sonore et diriger ainsi le personnage en fonction.

DTMF

Mise en oeuvre

Il faut :
1 – Arduino UNO.
1 – Décodeur DTMF MT8870 .
1 – Ligne téléphonique avec un téléphone.
1 – Un PC avec le jeux Hugo et l’émulateur qui va bien (le jeux original tournait sur Amiga mais par souci de facilité j’ai utilisé la version PS1).
On connecte donc l’écouteur du téléphone au décodeur DTMF qui lui même est connecté à l’Arduino qui est lui même connecté au PC.

Montage

On relie donc :

– L’écouteur du téléphone au module DTMF via une prise jack (n’ayant pas de ligne fixe j’ai utilisé un portable, l’Iphone de droite).
– Le module DTMF a l’Arduino (STQ -> 5, les pins 1,2,3,4 vers leur homologues sur .l’arduino)
– l’Arduino en USB au PC

Setup

Voici le lien vers le code Arduino qui utilise UnoJoy pour que l’arduino soit reconnu comme un Joystick afin de l’utiliser dans l’émulateur.
Il ne reste plus qu’a lancer le jeu, appeler la ligne téléphonique en question et jouer 🙂

Restauration d’un flipper : Part 1

Depuis deux ans j’ai récupéré un flipper Staal Gunmen, une machine made in France de 1979. Comme beaucoup de choses que je récupère il ne fonctionne pas et est en mauvais (très mauvais) état.

Au boulot !

Commençons par le fronton (partie supérieure du flipper qui affiche le score). Chose étrange, le bois utilisé pour le flipper est du contreplaqué couvert d’une épaisseur (5 mm) d’aggloméré sur lequel il y a la peinture. Comme il n’a pas été entreposé dans un endroit sain, l’agglo s’est dégradé et ne semble pas récupérable.

fronton

On emploie alors les grands moyens et on fait sauter la couche d’agglo et on la remplace par du contre plaqué de 5 mm. Après de longues heures de travail, pas mal de colle, de pâte à bois et quelques coups de rouleaux de peinture le résultat est plutôt satisfaisant.

fronton_new

Il reste à faire les décors mais ce sera pour plus tard.

Un peu d’arduino

Je souhaite réutiliser au maximum les éléments d’origine, mais malheureusement sur ces flippers les cartes mères ont tendance à lâcher à causse des CPU de mauvaise qualité… Donc pas le choix, il faut tout refaire avec les moyens du bord. Sur le fronton les afficheurs 7 segments utilisent des circuits assez standard j’ai donc pu les faire tourner sans problème avec un arduino. Bien sur tout le code sera disponible sur mon github.

afficheur.jpg

Aux pieds !

Comme je le disais plus haut les flippers et l’humidité ne font pas bon ménage, les pieds sont assez fatigués …Les voici après un petit coup (quelques heures) de grattage intensif.

Il ne reste qu’a les lustrer pour que ça brille …

 

 

 

Développer sur Méga Drive : Part 2

Comme précisé dans le dernier articles nous allons parlé ici de Debug et de JoyPad.

Debug

C’est un peu la base quand on développe de pouvoir debugger son programme afin de savoir ce qu’il se passe et pouvoir résoudre d’éventuels problèmes. Le SDK fournis tout le nécessaire pour débugger en alliance avec Gens KMod (menu CPU->Debug). Il y a différents items dans le menue permetant de voir pas mal de choses (registres des cpu, video, son, …). Nous allons utiliser la méthode la plus simple, les messages; elle permet simplement d’envoyer des messages dans une console un peu comme si vous utilisiez des « printf ». Pour cela c’est très simple il suffit d’utiliser la fonction KDebug_Alert qui prend en paramètre un string et le tour est joué (ne pas oublier le #include <kdebug.h> pour inclure les entêtes de debug).

 

#include <genesis.h>
 #include <kdebug.h>
 
 int main()
 {
 
        VDP_drawText("GENESIS HELLO !", 1, 1);
        KDebug_Alert("debug genesis hello");
 
        while(1)
        {
                VDP_waitVSync();
        }
        return (0);
 }

 

Une fois la rom chargée, en allant dans CPU->Debug->Messages nous voyons notre magnifique message de debug apparaître, facile mais très utile.

debug_1

 

JoyPad

Passons maintenant aux contrôles. Le JoyPad de base avait 3 boutons (A B C), un bouton start et une croix directionnelle puis il y a eu ensuite une version avec 6 boutons et d’autres type de contrôleurs (souris, clavier, pistolet…) qui sont aussi géré par le SDK. La capture des événements se fait pas un callback que l’on défini dans le main avec la fonction JOY_setEventHandler(nom_de_la_fonction_de_callback).  Cette fonction prend trois paramètres (u16 joy, u16 changed, u16 state) :

  • joy étant le joypad utilisé (JOY_1, JOY_2, …)
  • changed définie si un bouton a été pressé
  • state définie si un bouton à été relâché

 

Petit code pour mieux comprendre ….

 

#include <genesis.h>
 #include <kdebug.h>
 
 
 void handleJoyEvent(u16 joy, u16 changed, u16 state)
 {
    KDebug_Alert("joy callback");
    if (joy == JOY_1)
    {
        if (state & BUTTON_UP)
        {
            KDebug_Alert("up press");
        }
        else if (changed & BUTTON_UP)
        {
            KDebug_Alert("up rel");
        }
    }
 }
 
 
 int main()
 {
 
 
        JOY_setEventHandler(handleJoyEvent);
 
 
        VDP_drawText("GENESIS HELLO !", 1, 1);
        KDebug_Alert("debug genesis hello");
 
        while(1)
        {
                VDP_waitVSync();
        }
        return (0);
 }

 

Le résultat

 

debug_2

Fin de cette deuxième partie…. Dans la suite nous parlerons de l’affichage.