Suite à une erreur lors de la mise à jour de Wordpress. Tous les commentaires ont été perdu... j'en garde cependant une copie.
Avant même d’acheter ma Wii j’avais acheté une Wiimote pour pouvoir faire mumuse avec. Un peu comme ce monsieur: http://johnnylee.net/projects/wii/ .
J’ai à l’époque réalisé des programmes équivalents à ceux présentés par Mr Lee pour:
- pouvoir écrire au tableau avec un crayon IR (cf. un autre article que je vais bientôt écrire),
- faire du head tracking en faisant bouger une théière OpenGL mais ça n’a pas très bien réussi.
Après ces petites expériences, j’ai fais un petit jeu pour refermer ma page “Wiimote”. Pour y jouer il faut la Wiimote et un Nunchuk. Ce jeu est très simple, il faut suivre le plus longtemps possible le cercle mobile à l’aide du Joystick du Nunchuk.
Pour pouvoir compiler ce programme, il faut avoir un ‘nux avec les librairies SDL et libcwiid (et bien sûr un bluetooth fonctionnel et une Wiimote).
Le code source: ici
Tags : Wii
Voici un jeu qui m’a occupé pendant tout mon lycée … enfin surtout les
cours de Français et de philo.
Le but est de remplir un carré de n*n (initialement de 10*10) avec des
chiffres de 1 à n*n et ce en sautant deux cases pour les déplacements
verticaux et horizontaux. Par contre, une seule case doit être sautée pour
les autres déplacements. On ne peut repasser par la même case.
Exemple:
-----------------------------------------
| 1| 30| 22| 7| 29| 21| 6| 35| 46| 14|
-----------------------------------------
| 26| 18| 3| 32| 17| 11| 38| 16| 66| 37|
-----------------------------------------
| 23| 8| 28| 20| 5| 34| 47| 13| 63| 54|
-----------------------------------------
| 2| 31| 25| 10| 39| 82| 65| 36| 45| 15|
-----------------------------------------
| 27| 19| 4| 33| 48| 12| 62| 53| 67| 94|
-----------------------------------------
| 24| 9| 40| 81| 75| 57| 44| 83| 64| 55|
-----------------------------------------
| 72| 60| 49| 78| 61| 52| 68| 95| 98| 85|
-----------------------------------------
| 41| 80| 74| 58| 43| 89| 92| 56| 88| 93|
-----------------------------------------
| 50| 77| 71| 51| 76| 70| 97| 84| 69| 96|
-----------------------------------------
| 73| 59| 42| 79| 91|100| 87| 90| 99| 86|
-----------------------------------------
Le programme suivant permet de donner toutes les solutions de ce problème en
parcourant de façon intéligente l’arbre des solutions:
jeu_du_25.c
Ce que vous pouvez faire avec ce programme:
- le passer sous linux… c’est assez facile: c’est anoté,
- modifier la taille de la grille en modifiant “TAILLE_GRILLE”,
- déplacer la place du 1 (en jouant sur la variable “pos_element[0]“),
- le débugger… oui, il doit en rester encore un ou deux,
- générer une solution aléatoire en initialisant aléatoirement
deplacement[*].
- la taille maximale est de 31*31… à cause de du “%3d” dans les “printf”
mais je ne suis jamais monté aussi haut dans les tailles.
Moi qui n’en ai rien à faire du climat, je pense que ces présentations (cours filmés au Mines de Paris) sont VITALES à la compréhension des temps à venir. Ces informations doivent être intégrées pour tout ingénieur qui se respecte.
Lien vers le site des mines de Paris
Ca fait un moment que je n’ai pas touché à ce site alors, vu que je n’ai pas le temps et surtout l’envie, je vous laisse un petit document sur l’inversion de matrice à l’aide de polynômes de matrice.
Je m’étais amusé à démontrer ca en prépa (et oui ce document est rédigé depuis des lustres). Je n’avais jamais vu passer ce genre de propriété pourtant très simple dans mes études et pourtant ca peut être utile pour beaucoup de démonstrations.
ICI
A vous de trouver l’erreur:
EDIT:
La réponse est au niveau de la seconde l’égalité. Cette égalité n’est vraie que pour des éléments entiers.
Sur Wikipedia.
Jeudi soir 20h, je suis submergé de boulot (entre rapports et exams à préparer) … bref j’avais pas envie de les faire. Bon comment s’occuper? Tiens allons faire un tour sur Youtube.
http://www.youtube.com/watch?v=s1eNjUgaB-g
Oui j’ai entendu votre appel: “Rha je veux faire pareil!”… voici la base:
Bon alors, il faut:
- Un PC avec une carte audio plus elle est performante meilleur le résultat sera,
- un oscilloscope assez rapide,
- un câble pour relier la sortie audio à l’oscillo (sortie droite sur X et gauche sur Y)
Deux solutions s’offrent à vous pour la génération du signal à envoyer dans la carte son:
- générer un fichier Wav que vous faites lire par votre lecteur préféré,
- faire un programme qui gènère le son et l’envoi directement dans le ‘/dev/dsp’.
Voici un programme qui génère un son et l’envoie dans le ‘/dev/dsp’. Cependant, à la réflexion, ca n’est pas la meilleure solution à cause d’un petit temps entre deux lectures. La version proposée, essaye de mettre en place deux buffers en ping/pong… mais sans trop de succes.
Lorsque vous codez, évitez de faire sauter trop souvent le point de l’oscillo sinon, vous aurez de belles traînées. Essayez de faire comme si vous dessiniez sans lever le stylo.
Le points de chaque coté de l’écran permettent de donner une valeur moyenne nulle les signaux. Sinon les filtres passe-bas de l’oscillo (en mode alternatif) décaleraient l’image vers le haut ou vers le bas en permanance.
Voilà, à vous de jouer!!
Etape suivante, remplacer le PC par un ATmega et la carte son par les PWM de l’ATméga plus des filtres passe-bas.
PS: Si l’oscilloscope et/ou la carte sont ne sont pas assez rapide, il risque d’y avoir des traînées sur l’écran de l’oscollo lors de passage rapide d’un point à un autre (levé de crayon).
Nous (JD et moi) avons tenté d’écrire un message dans les airs en utilisant la persistance rétinienne. Pour cela, on a pris une rangé de LEDs derrière laquelle on a mis un accéléromètre. Connaissant l’accélération, on en déduit la position.
JD a réussi à souder un accéléromètre dans un boitier QFN sur une plaque d’essai. Ne souhaitant pas faire une double intégration pour savoir où se trouve l’objet dans l’espace, nous avons pensé utiliser la courbe théorique de l’accélération. Cette dernière ressemble à une sinusoïde: les maximas et les minimas correspondent aux extrémités du mouvement.
Cet essai est un échec partiel: ca marche mais pas très bien (sûrement à cause de la méthode utilisée et le code fait en 2 min un soir de pluie).
Vidéo et code pour ATMega32 (librairie aversive).
A la rentrée, nous allons réessayer avec une double intégration.
EDIT:
La version 2 de ce programme n’a pas pu être testé car l’accéléromètre est tombé en panne.
Peu de gens savent qu’une simple diode peu servir en émetteur de lumière mais aussi en récepteur (à sa fréquence d’émission).
En effet (partie technique),polarisée en inverse, une diode est assimilable à un condensateur dont la valeur change avec l’éclairement qu’elle recoit (à sa fréquence d’émission). On a donc testé avec des LED superflux dans le domaine visible (bleu, rouge et blanc) mais on a obtenu de meilleurs résultats dans l’IR.
Une fois le hack en place, on a ainsi pu faire un interrupteur à LED (vidéo et code à l’appui), un détecteur de balles (vidéo et code à l’appui) et un variateur de lumière en fonction de la distance du doigt (vidéo et code à l’appui) sur un simple ATMega32.
Beaucoup de personnes pensent que je suis un peu taré, et bien voici un article qui ne va pas arranger les choses.
Je me suis amusé, à reprendre un code (trouvé sur le net) permettant d’afficher un texte arbitraire sur le LCD d’une imprimante HP, à faire une petite animation: voici la vidéo.
et le code
Bien sûr le code n’est pas propre, même très crad (pas un for), mais il a le bon gout de marcher.
Nounours
PS: C’est mon premier script python
Qui ne s’est jamais demandé pourquoi les verres du RU ne cassent pas au premier impact mais après 3 ou 4 rebonds?… Comment ça personne?
C’est pas logique: alors qu’il on perdu la plupart de leur énergie totale (cinétique et potentielle) ils se cassent..
Plusieurs propositions ont été avancées:
- A chaque impact, le verre se met à vibrer à sa fréquence caractéristique et lorsque les impacts se rapprochent il n’a plus le temps d’arrêter de vibrer et l’impact suivant le casse.
- A chaque impact, il se fragilise un peu plus jusqu’au moment où il casse
Voici les vidéos répondant à ces questions (merci de les enregistrer sur le disque avant de les visualiser):
http://francetest.free.fr/autres/verre1_comp2.avi
http://francetest.free.fr/autres/verre2_comp2.avi
Ces vidéos ont été faites avec des verres identiques à ceux du RU et à l’aide d’une caméra rapide appartenant au Laboratoire d’Acoustique de l’Université du Maine.
J’adore ces vidéos de ralentis. Si vous les voulez non compressé faites moi signe. D’ailleurs, elles ont été compressés à l’arrache donc si quelqu’un veut bien refaire la compression ça serais cool.
La réponse à la question était donc que le verre ne casse pas au premier impact car il tombe sur le cul (une partie très lesté et très solide) mais lors des rebonds il tombe sur la tranche, une partie fine qui casse facilement.
On s’est donc planté dans nos prédictions. JD aurait encore dit: “Ha ces élecs ils passent leurs temps à tenter d’expliquer des trucs bizarres sur leurs cartes avec des intégrales dans tous les sens alors qu’ils ont oublié de souder une résistance”.
Il parait que casser un verre c’est super dangereux car ça fout du verre partout et ça vole super bien.