Avis aux lycéens et aux passionnés de tout âge de la programmation : la date d’ouverture officielle pour le challenge WinGineer 2011 est fixée au 4 décembre 2010. Les inscriptions sont déjà ouvertes et vous pouvez commencer dès maintenant à vous faire la main !

Quoi de neuf pour cette nouvelle édition ?

Thématique

Il est loin le temps des papillons, et les étoiles, quant-à elles, sont parties les rejoindre. Maintenant : place aux duels d’unités blindées ! Ca ne rigole plus ^^.

Nous sommes donc toujours dans un univers de tanks, mais maintenant votre hégémonie sur la moitié du territoire est symbolisée par un drapeau que vous devez protéger. Pour gagner, il faut conquérir et détruire le drapeau adverse afin de régner sur l’ensemble du territoire (“Minus, cette nuit, nous avons réussi !” Mouahaha).

Pour cela, vous disposez d’une unité blindée composée de 5 éléments mobiles. Vous choisissez vous-même le type de chacun de vos véhicules parmi deux catégories :
- les tanks (orienté attaque) : ils peuvent tirer et avancent lentement
- les bulldozers (orienté défense) : ils construisent et détruisent des murs de protection (bunkers) et ont une vitesse de déplacement plus élevée que celle des tanks.

Attention aux choix, ça fait partie de la stratégie ;-] (le dosage tank / bulldozer est particulièrement intéressant d’ailleurs).

Votre rôle, c’est de décrire le comportement de votre unité mobile. En d’autres termes, vous devez créer cinq IA (Intelligence Artificielle) de pilotage, une par véhicule.

Voici une petite vidéo pour illustrer tout cela :

Les défis et le classement

Ca c’est le gros changement de la troisième édition. Vous n’êtes plus un tank gladiateur essayant d’être le dernier survivant de l’arène en faisant des boulimies d’étoiles. Vous êtes désormais le commandant d’une unité stratège blindée et vous défiez dans des duels les autres challengers que vous aurez habilement choisis. Encore un level-up :-].

Tout se joue en côte et en points, à un rythme d’une vingtaine de duels par jour au maximum.

Les points : ce sont eux qui déterminent le classement. Plus vous avez de points, plus vous êtes bien classé (logique en soi). Pour gagner des points, il vous faut défier des adversaires. En cas de victoire (drapeau adverse écrabouillé), plus la côte de l’adversaire est haute plus vous gagnerez des points (points gagnés = 1 point + côte adverse). Autrement (votre drapeau en bouillie, ou match nulle) vous ne perdez pas de points (tentez donc David contre Goliath, ça rapportera le gros lot ! … si vous gagnez :p) et l’adversaire n’en gagne pas car ce n’est pas lui qui a défié.
En revanche, à chaque défis les côtes des deux opposants évoluent en fonction de l’issue du duel. La côte représente le total des victoires sur les dix derniers duels.
Ici aussi, la stratégie est de mise. Etudiez bien les vidéos des anciens duels des challengers avant de les provoquer en duel.

Le classement est affiché en live sur le site et les vidéos des duels sont postées sur la chaine Youtube.

Pour les candidats lycéens en terminale, un ticket pour la finale vous sera attribué si votre score cumulé ou bien votre score moyen sur 10 parties dépasse un certain seuil.

Il n’est donc pas obligatoire d’être le meilleur au classement pour obtenir une place en finale : le but est de récompenser le sens de l’observation, l’analyse, la capacité d’apprentissage, la persévérance, l’enthousiasme et la créativité. Ce sont des qualités essentielles pour la formation et le métier d’ingénieur.

Qui peut participer ?

Le challenge s’adresse en particulier aux lycéens de terminale (S, STI ou STL) qui souhaitent intégrer l’école après avoir passé leur BAC (poule 1A).

Pour tous les autres, curieux ou passionnés d’informatique, vous êtes invités à vous défier et à vous amuser dans le groupe fun (poule libre) spécialement conçu pour vous !

Le mot d’ordre du challenge pour tous : have fun !

Faut-il savoir programmer pour participer ?

Un challenge pédagogique

Ce challenge a un but pédagogique. Le principe est justement de vous faire découvrir l’informatique de manière ludique. Donc, cela va de soi, aucune, je dis bien aucune, connaissance n’est requise pour participer.
Il n’est évidemment pas concevable de vous demander des bases que la formation post-bac est censée vous apprendre elle-même…

Le langage de programmation utilisé, NetLogo, a été spécialement choisi pour coller à cet objectif pédagogique. Il est très proche du langage oral (grosso-modo : les lignes de commande sont des phrases en anglais sans les articles). C’est donc la stratégie (algorithmie) qui est mise en avant, plus que le langage lui-même.

Donc, de l’imagination, un papier et un crayon, et un accès à un ordinateur : c’est tout ce dont vous avez besoin.

Aide à disposition

Des exemples simples vous sont fournis avec un tutoriel pas à pas. Cela vous permettra de démarrer et d’appréhender le contexte.

Vous disposez également du forum sur lequel vous pouvez discuter avec les autres challengers. Vous pouvez y poser des questions sur le concours, sur des problèmes que vous rencontrez ou bien discuter sur des stratégies diverses. N’hésitez pas à vous entre-aider, cela vous permettra d’aller encore plus loin !

Pour ceux qui ont déjà des bases, ne pensez pas que cela sera simple étant donné que c’est la stratégie qui est jugée ici. Cela vous aidera seulement au début à pouvoir passer plus rapidement vos idées en lignes de codes. Et surtout n’ayez pas peur de vous ennuyer. IA is IA : il y a moyen de mijoter des petites stratégies particulièrement redoutables et diaboliques ;-].

A propos du challenge et des prix

Ce challenge est organisé par le groupe ESIEA qui rassemble deux écoles : l’ESIEA (Ecole Supérieure d’Informatique, électronique et Automatique) et In’Tech Info.

Ce n’est absolument pas un concours d’entrée, mais la possibilité pour des élèves souhaitant rejoindre l’une des écoles du groupe de remporter la gratuité de l’ensemble de leur scolarité.

Déroulement

Le challenge comprend deux phases :

Une première qui se déroule en ligne. Les candidats participent dans l’une des deux poules disponibles (libre ou candidats 1A) et lancent des défis pour gravir l’échelle des scores.

Une seconde qui s’adresse aux candidats de la poule 1A ayant reçus des tickets pour la finale. Ils seront invités à venir la disputer à huis clos dans les locaux de l’ESIEA Paris le samedi 9 Avril 2011. L’épreuve sera une variante de la première phase.

Prix

A l’issu de la finale, les trois premiers bacheliers 2011 recevront les récompenses suivantes :
- 1er prix : 100% des frais de scolarité pour 5 ans dans l’une des écoles du groupe ESIEA
- 2ème Prix : 50% des frais de scolarité pour 5 ans dans l’une des écoles du groupe ESIEA
- 3ème Prix : 25% des frais de scolarité pour 5ans dans l’une des écoles du groupe ESIEA

Sous réserve des conditions suivantes :

Ces bourses ne sont attribuées qui si vous réussissez les épreuves d’admission dans l’une des deux écoles (dernière session le 7 Mai 2011 pour l’ESIEA et le 15 Juillet 2011 pour In’Tech Info). Vous devez également suivre la procédure admission-postbac (deadline : 20 mars 2011) d’une part (pour l’ESIEA), et d’autre part avoir votre bac à la fin de l’année.

Liens utiles

Pour les inscriptions et le site officiel, rendez-vous ici : WinGineer
Voici la chaîne Youtube qui montre les vidéos des derniers défis : WinGineer on Youtube

Pour en savoir plus sur l’Esiea : Ecole Supérieure d’Informatique Electronique Automatique
Et sur In’Tech Info : In’Tech

Et pour les curieux : ;-]

Il est parfois utile de pouvoir afficher directement des graphiques sur iPhone / iPad. Cela peut être pour afficher beaucoup d’information dans un espace réduit, ou pour aider à visualiser des informations.

Installer CorePlot

L’installation de CorePlot est légèrement plus compliquée que pour d’autres librairies, et cela peut même parfois devenir plutôt pénible, surtout lorsqu’il faut compiler.

Télécharger CorePlot

Télécharger les sources complètes sur le projet Google Code. A l’heure de cet article le fichier à télécharger est l’Alpha Release 1. Cela risque bien évidemment de changer au cours du temps.

Configurer CorePlot pour le Projet

• Dézippez le fichier et renommez le en “coreplot”.
• Déplacez le dossier là où vous entreposez vos librairies. Il ne faut pas que cet endroit bouge car le lien avec le projet ne sera pas dynamique.
• Dans le dossier “coreplot/Source/framework”, vous devriez avoir un projet “CorePlot-CocoaTouch.xcodeproj”. Déplacez ce fichier dans votre projet xCode (dans le dossier “Other Sources” par exemple).
• Le fichier déplacé devrait contenir un “.a”. Déplacez ce dernier dans le dossier “Link Binary With Librairies” qui se trouve dans “Target/NOM-DU-PROJET/Link Binary With Librairies”.
• Ouvrez la fenêtre “Target Info” en double-cliquant sur le projet dans Target. Allez dans l’onglet “General” (le plus à gauche en principe), et rajoutez la dépendance directe de CorePlot.
• Maintenant ouvrez l’autre fenêtre de configuration : “Project Info” en double-cliquant sur le nom du projet tout en haut de la colonne. Vous devez passez à l’onglet “Build” et cherchez dans les configurations la clé “Header Search Paths” (en principe qui est vide de base pour un nouveau projet). Rajoutez-y le chemin vers votre librairie. Par exemple pour nous cela sera “$HOME/Library/SDKs/coreplot/Source/framework”, mais cela peut très bien être ~/Desktop/Librairies/path/to/dire/coreplot/Source/framework. Vérifiez avec un terminal que le chemin est le bon ! ATTENTION, veuillez à bien cocher le bouton “récursif” à coté du champ texte.
• Toujours dans la même fenêtre, cherchez la clé “Other Linker Flags” et rajoutez-y “-all_load -ObjC”.
• Dans votre controller, rajoutez la ligne d’import suivante : #import “CorePlot-CocoaTouch.h”
• Et enfin pensez à rajouter le framework QuartzCore dans votre projet !

D’après quelques tests, il semblerait quasiment nécessaire que l’iOS cible soit au moins le 4.0. Sinon on se retrouve avec des erreurs de compilations plutôt incompréhensibles !

Utiliser CorePlot – Configurer votre Graph

CPPlotDataSource

Une fois CorePlot au chaud, on a qu’une seule envie, sortir une courbe ! Dans notre cas nous allons directement programmer dans un UIViewController (celui de base du projet que vous pouvez télécharger en fin du billet). Par ailleurs ce dernier doit intégrer le delegate CPPlotDataSource, donc veuillez bien à ce que dernier apparaisse dans votre header file ! De même nous utiliserons deux classes que je vous conseille d’ajouter dans votre .h :

CPLayerHostingView *graphView;
CPXYGraph *graph;

Les deux sont reliées à l’affichage graphique mais la seconde joue plus le rôle d’un Layer qu’autre chose. Votre Interface devrait donc ressembler à quelque chose comme :

@interface CorePlot_GeckoGeekViewController : UIViewController <CPPlotDataSource> {
 
	CPLayerHostingView *graphView;
	CPXYGraph *graph;
 
}

Ensuite, implémentons la méthode qui permettra d’afficher le graphique. Rendez-vous donc dans la méthode loadView du ViewController

- (void)loadView {
 
	// Alloc & Init Main View
	UIView *tmpView = [ [ UIView alloc ] initWithFrame:CGRectMake(0.0, 0.0, 320.0, 480.0-20.0) ];
	[ tmpView setAutoresizingMask:UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight ];
	[ tmpView setBackgroundColor:[ UIColor whiteColor ] ];
 
	// Alloc Graph View
	graphView = [ [ CPLayerHostingView alloc ] initWithFrame:CGRectMake(0.0, 0.0, 320.0, 480.0-20.0) ];
	[ tmpView addSubview:[ graphView autorelease ] ];
 
	// Set MainView
	[ self setView:[ tmpView autorelease ] ];
 
}

Pour l’instant rien de très compliqué. On créé la vue qui se chargera d’afficher les données (CPLayerHostingView) et on l’ajoute en SubView à la vue principale.

Initialisation des préférences de CorePlot

Passons maintenant à la méthode viewDidLoad où nous allons initialiser l’allure des courbes. On commence par créer l’objet CPXYGraph qui va contenir nos courbes :

// Alloc CPXYGraph
graph = [ [ CPXYGraph alloc ] initWithFrame: self.view.bounds ];
// Link between the view and the Layer
graphView.hostedLayer = graph;
// Init Padding to 0
graph.paddingLeft = 0.0;
graph.paddingTop = 0.0;
graph.paddingRight = 0.0;
graph.paddingBottom = 0.0;

Notez qu’on remet les “padding” (espace interne) à 0 pour éviter d’avoir des marges blanches internes dans notre graphique. Là encore, rien de très compliqué. Passons maintenant aux courbes que vous souhaitez voir apparaître. Il faut les déclarer une à une et par ailleurs (de préférence) les personnaliser. Voici un exemple pour UNE courbe.

// Alloc
CPScatterPlot *plot1 = [[[CPScatterPlot alloc]initWithFrame:self.view.bounds] autorelease];
// Set ID
plot1.identifier = @"Plot 1";
// Set Line Width
plot1.dataLineStyle.lineWidth = 1.0f;
// Set Line Color
plot1.dataLineStyle.lineColor = [CPColor colorWithComponentRed:255.0/255.0 green:0.0 blue:0.0 alpha:1.0];
// Set Data Source Object
plot1.dataSource = self;
// Add Plot to the graph layer
[graph addPlot:plot1];

En principe les commentaires sont assez nombreux pour vous expliquer ce que font les lignes. Il existe probablement d’autres paramètres de personnalisation. Mais pour un graphique de base, vous n’avez pas vraiment besoin d’en écrire plus. Prenez une attention particulière au paramètre “identifier” qui vous permettra d’attribuer les valeurs Y de la courbe dans une méthode “data source”. On en parle plus bas ! Répétez la même chose pour le nombre de courbe dont vous avez besoin. Ici on en créera juste une seconde afin de vous montrer un graphique avec 2 courbes.

Plages de données

On passe maintenant à une configuration un peu plus poussée qui concerne les limites d’affichage sur les axes X et Y. Il vous faut définir les plages sur lesquelles vous souhaitez voir vos courbes d’afficher. Ce n’est en effet pas dynamique selon les données que vous indiquerez. Ici on donne des valeurs fixes, mais de manière générale il est conseillé d’effectuer des min/max/moy sur vos données.

// X & Y Range
// Get Default Plot Space
CPXYPlotSpace *plotSpace = (CPXYPlotSpace *)graph.defaultPlotSpace;
// Set X Range from -10 to 10 (length = 20)
plotSpace.xRange = [CPPlotRange plotRangeWithLocation:CPDecimalFromInteger(-10) length:CPDecimalFromInteger(20)];
// Set Y Range from -5 to 5 (length = 10)
plotSpace.yRange = [CPPlotRange plotRangeWithLocation:CPDecimalFromFloat(-5.0) length:CPDecimalFromFloat(10.0)];

Préférences des axes X & Y

Il ne reste plus qu’à indiquer les préférences de chaque axe. C’est probablement le passage le plus délicat est sur lequel on revient le plus souvent au début lorsque l’on souhaite configurer l’allure de son graphique. On vous explique ligne par ligne ce que fait chaque fonction dans le code suivant.

// Line Style
CPLineStyle *lineStyle = [CPLineStyle lineStyle];
lineStyle.lineColor = [CPColor blackColor];
lineStyle.lineWidth = 1.0f;
 
// Axis X Prefs
CPXYAxisSet *axisSet = (CPXYAxisSet *)graph.axisSet;
// Set the "major" interval length
axisSet.xAxis.majorIntervalLength = [ [ NSDecimalNumber decimalNumberWithString:@"5.0" ] decimalValue ];
// Set the number of ticks per interval
axisSet.xAxis.minorTicksPerInterval = 4;
// Set major & minor line style
axisSet.xAxis.majorTickLineStyle = lineStyle;
axisSet.xAxis.minorTickLineStyle = lineStyle;
// Set axis line style
axisSet.xAxis.axisLineStyle = lineStyle;
// Set length of the minor tick
axisSet.xAxis.minorTickLength = 5.0f;
// Set length of the major tick
axisSet.xAxis.majorTickLength = 10.0f;
// Set the offset of the label (beside the X axis)
axisSet.xAxis.labelOffset = 3.0f;
 
// Axis Y Prefs (same things)
axisSet.yAxis.majorIntervalLength = [ [ NSDecimalNumber decimalNumberWithString:@"2.0" ] decimalValue ];
axisSet.yAxis.minorTicksPerInterval = 1;
axisSet.yAxis.majorTickLineStyle = lineStyle;
axisSet.yAxis.minorTickLineStyle = lineStyle;
axisSet.yAxis.axisLineStyle = lineStyle;
axisSet.yAxis.minorTickLength = 5.0f;
axisSet.yAxis.majorTickLength = 10.0f;
axisSet.yAxis.labelOffset = 3.0f;

Utiliser CorePlot – Attribuer les valeurs

Maintenant il ne reste plus qu’à indiquer les valeurs de chaque variable grâce au dataSource que nous avons attribué au départ. Pour cela nous allons utiliser les deux méthodes delegate suivantes :

- (NSUInteger)numberOfRecordsForPlot:(CPPlot *)plot {
 
}
 
- (NSNumber *)numberForPlot:(CPPlot *)plot field:(NSUInteger)fieldEnum recordIndex:(NSUInteger)index {
 
}

Nombre de données à afficher

Dans un premier temps il faut indiquer le nombre de donnée que contient une courbe. Pour cela nous implémentons la méthode “numberOfRecordsForPlot:” qui nous indique en paramètre la courbe concernée.

- (NSUInteger)numberOfRecordsForPlot:(CPPlot *)plot {
 
	// If Plot 1
	if (plot.identifier == @"Plot 1")
		return 20;
 
	// If Plot 2
	return 10;
 
}

Pour la première courbe nommée “Plot 1″ nous déclarons qu’il y a 21 valeurs. Et pour la deuxième 11 valeurs. En général les données sont stockées dans un tableau. Ici nous enlevons cette contrainte. En cas de tableau vous pouvez directement faire un [ array count ].

Nombre à afficher en fonction de la courbe et de l’index

Et enfin il ne reste plus qu’à indiquer les données. Nous utilisons alors la deuxième méthode delegate “numberForPlot:::”.

- (NSNumber *)numberForPlot:(CPPlot *)plot field:(NSUInteger)fieldEnum recordIndex:(NSUInteger)index {
 
	// Number of the X axis asked
	if (fieldEnum == CPScatterPlotFieldX) {
 
		// Return -10, -9, -8, ... 8, 9, 10
		if (plot.identifier == @"Plot 1")
			return [ NSNumber numberWithInteger:-10.0+index ];
		// Return -5, -4, ..., 4, 5
		else if (plot.identifier == @"Plot 2")
			return [ NSNumber numberWithInteger:-5.0+index ];
 
	// Number of the Y axis asked
	} else if (fieldEnum == CPScatterPlotFieldY) { 
 
		// Return -10, -9, -8, ... 8, 9, 10
		if (plot.identifier == @"Plot 1")
			return [ NSNumber numberWithFloat:(-10.0+index)/2.0 ];
		// Return -5, -4, ..., 4, 5
		else if (plot.identifier == @"Plot 2")
			return [ NSNumber numberWithInteger:-5.0+index ];
 
	}
 
	// Return a default value, shouldn't be returned
	return [ NSNumber numberWithFloat:0.0 ];
 
}

Avec une condition on fait la différence entre a donnée pour l’axe X ou Y, puis une autre condition selon la courbe souhaitée. Attention à bien retourner des NSNumber !

Ceci nous retourne le résultat suivant :

Sources du projet Coreplot

Voici les sources de ce tutorial. Nous avons inclus en passant les sources de coreplot pour que vous puissiez compiler directement :
http://www.geckogeek.fr/static/files/Coreplot-Geckogeek.zip
Attention, n’oubliez pas d’installer le reste de coreplot comme il se doit. Le coreplot inclut dans le projet n’est que le wrapper iPhone / iPad.

C’est aujourd’hui (et plus précisément depuis 19h00) que se tenait la dernière Keynote d’Apple. Cette dernière était centrée sur le “Mac”, et nous avons eu le droit à notre lot de nouveautés. Faisons le tour de ce qu’il y a à retenir !

KeyNote 20 Octobre, des chiffres

• Apple profite d’une croissance de 27% cette année
• 13.7 millions de Mac vendus en 2010
• Le Mac représente 33% des revenus d’Apple

iLife 11 – iPhoto 11, iMovie 11

Les même Apps sont là. iLife peut s’upgrader pour un ancien iLife pour 49$. Et il est gratuit pour les nouveaux Mac ! Disponible dès aujourd’hui.

iPhoto 11

• Nouveau mode fullscreen pour afficher les photos.
• Meilleure intégration de Facebook.
• Nouveau slideshow pour afficher les images. Par exemple avec des images géolocalisée vous pouvez faire une animation des photos avec les emplacements sans rien devoir configurer. Une grosse dizaine d’animations différentes permettent ainsi de mettre en avant vos images avec une musique de fond.
• Envoi des photos par email amélioré. L’intégration des images dans un email est vraiment améliorée, et beaucoup plus intuitive.
• Grande amélioration dans la création de livres.

Animation d’images géolocalisées

Envoi de photos par Email

Création d’un Album photo

Visionner les Albums Photos

iMovie 11

• Simplification de la modification de l’audio pour aisément baisser / augmenter le son sur des parcelles d’une vidéo (bien plus simple qu’avant)
• Effet Audio : Dark Vador, Alien, … Démonstration saisissante !
• Les ajouts d’effets vidéos sont aussi simplifiés
• Création de movie trailer de manière simple. Il suffit de remplir des meta-datas, rajouter un logo, et iMovie fait le reste ! L’effet est excellent.
• Reconnaissance du nombre de personens dans les vidéos pour mieux départager les séquences (et aider à l’association des séquences)

Ajouter des meta-données à des séquences

Garage Band 11

• Quand le rythme de plusieurs instruments est mal synchronisé, il est possible de nominer un instrument comme “clé” et les autres s’accordent au rythme.
• Flex Time : il devient possible (facilement) d’augmenter ou baisser le durée de certaines parties d’une séquence audio en la sélectionnant, l’étirant.
• Nouvelles leçons de Guitares & Piano. Les leçons sont encore plus explicites comme avec la synchronisation des doigts. On a un historique de ses performances, de ses fautes, des stats, etc.

Liste des leçons

Tentative de Performance

Facetime

D’après Apple, 19 millions de devices ont utilisés Facetime durant ces 4 derniers mois. Facetime arrive maintenant sur Mac et peut se connecter à un autre Mac, ou même un iPhone 4 / iPod. La Beta de Facetime Mac est disponible dès aujourd’hui !

Discussion avec Phill

Mac OS 10.7

L’idée de “Lion” (Mac OS 10.7) est de ramener des features de l’iPhone / iPad sur Mac.

• La Gestion du multi-touch sur Mac est compliquée. Leurs tests ne sont pas concluant et donc ils sont toujours en Recherche.
• Map App Store : AppStore intégré sur Mac. Meilleure place pour découvrir des applications. Sortie dans 90 jours.
• “Auto-Save” de vos applications sur les applications.
• Launch Pad : Moyen facile d’accéder à toute ses applications. C’est une copie du système de dossier de iOS4 sur grand écran !
• Possibilité d’avoir les applications en fullscreen et revenir au desktop en un clic pour profiter pleinement de son écran.
• Mission Control : un sorte “Exposé” amélioré pour une meilleure navigation

Présentation d’une Application sur Mac App Store : ici Pages

Launch Pad

Mission Control

One More Thing : New Macbook Air

Apple annonce de nouveaux Macbook Air ! Plus fins, plus légers, ils durent 7 heures en connexion Web et 30 jours en “stand-by”.

• PRIX 11.6″ : 999$ (64Go)
• PRIX 11.6″ : 1199$ (128Go)
• PRIX 13.3″ : 1299 $ (128Go)

Les deux version sont disponibles dès aujourd’hui !

Donc en résumé, beaucoup de nouveautés qui vont sans aucun doute aider les actions d’Apple dans les prochains jours ! La sortie de Mac App Store va sans aucun doute augmenter les bénéfices d’Apple sur iTunes.

Vous pouvez choisir de fixer l’orientation de l’iphone pour votre application lors de son lancement. Par exemple dans beaucoup de cas, un jeu aura besoin de se lancer en mode landscape. Cela se paramètre dans le plist du projet. Mais dans des cas particuliers, vous pourriez avoir besoin de fixer l’orientation du device en cours d’exécution de votre application. Par exemple lancer l’application en mode portrait et vouloir, pour une vue donnée, passer en mode landscape (ce qui force l’utilisateur à tourner le device, d’où le cas exceptionnel de cet emploi : il faut vraiment que ça se justifie). La méthode setOrientation (de UIDevice) étant privée, voici une autre manière de l’effectuer.

Le Principe

Le principe est très simple : il est possible de le faire, mais il faut que le View Controller en question soit ajouté à la fenêtre “window” de l’AppDelegate. Ensuite il suffit d’indiquer dans la méthode “shouldAutorotateToInterfaceOrientation” que l’on veut un mode landscape pour cette view.

L’utilisateur est en mode portrait. La nouvelle vue qui arrive est en mode landscape, donc l’utilisateur tourne le device. Les vue suivantes resteront en landscape car le device est maintenant détecté en mode landscape (rotation).

Exemple de code

Pour illustrer cette fonctionnalité, nous allons réaliser l’application qui est représentée dans l’image ci-dessus. L’application s’ouvre sur une vue en mode portrait qui possède un label et un bouton. Le bouton envoie sur une nouvelle vue. Cette dernière est en mode landscape, et possède elle aussi un label et un bouton (qui renvoie sur la première vue).

Création des deux ViewControllers

Commençons par créer les deux View Controllers. Le premier s’appelera PortraitViewController, le second LandscapeViewController.

Voici le .h (c’est le même pour le second, échangez juste les noms portrait / landscape). On y place le label, le bouton, et la méthode qui est appelée quand le bouton est touché.

#import <UIKit/UIKit.h>
 
@interface PortraitViewController : UIViewController {
 
	// View elements
	UILabel *labelPortrait;
	UIButton *buttonSwitchToLandscape;
 
}
- (void)go2LandscapeView:(id)sender;
 
@end

On ajoute le label et le bouton dans le loadView du .m (la largeur et la hauteur des frames ne sont pas les mêmes selon le mode).

- (void)loadView {
 
	// Create Main View
	[ super loadView ];
	[ self.view setFrame:CGRectMake(0.0, 0.0, 320.0, 480.0) ];
	[ self.view setBackgroundColor:[ UIColor whiteColor ] ];
 
	// Label
	labelPortrait = [ [ UILabel alloc ] initWithFrame:CGRectMake(0.0, 150.0, 320.0, 30.0) ];
	[ labelPortrait setFont:[ UIFont boldSystemFontOfSize:22.0 ] ];
	[ labelPortrait setTextAlignment:UITextAlignmentCenter ];
	[ labelPortrait setBackgroundColor:[ UIColor clearColor ] ];
	[ labelPortrait setText:@"I'm a view in Portrait mode" ];
	[ self.view addSubview:[ labelPortrait autorelease ] ];	
 
	// Button  
	buttonSwitchToLandscape = [ UIButton buttonWithType:UIButtonTypeRoundedRect ];
	[ buttonSwitchToLandscape setTitle:@"Go to a Landscape View" forState:UIControlStateNormal ];
	[ buttonSwitchToLandscape setFrame:CGRectMake(60.0, 200.0, 200.0, 40.0) ];
	[ buttonSwitchToLandscape setShowsTouchWhenHighlighted:YES ];
	[ buttonSwitchToLandscape addTarget:self action:@selector(go2LandscapeView:) 
						forControlEvents:UIControlEventTouchUpInside ];
	[ self.view addSubview:buttonSwitchToLandscape ];
 
}

Faites la même chose pour le second View Controller : LandscapeViewController.

Ajout de l’appel au delegate

N’oubliez pas qu’il faut que ça soit le delegate qui gère l’échange des views, afin de pouvoir les ajouter à “window”. Pour cela, on l’ajoute dans les .h des View Controllers : #import “AppDelegate.h”.

Et donc dans la méthode du bouton, on appelle une méthode qui se trouve dans le delegate (et que l’on va écrire bientôt) :

[ (AppDelegate*)[ [ UIApplication sharedApplication ] delegate ] switchToLandscapeView ];

(Pareillement pour le second View Controller.)

L’AppDelegate

Du côté du delegate, on doit donc ajouter ces deux fonctions. Elles vont retirer la vue actuelle, désallouer le View Controller, allouer le nouveau et mettre sa view à la place. Voici l’exemple pour la première :

- (void)switchToLandscapeView {
 
	[ vcPortrait.view removeFromSuperview ];
	[ vcPortrait release ];
	vcPortrait = nil;
 
	vcLandscape = [ [ LandscapeViewController alloc ] init ];
	[ window addSubview:vcLandscape.view ];
 
}

N’oubliez pas d’ajouter une des deux vues par défaut à la création de l’app delegate qui apparaîtra au lancement de l’application. Dans notre exemple, ça sera la vue de vcPortait.

Le sens d’orientation

Il ne reste plus qu’à fixer le sens d’orientation dans vcLandscape :

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
 
	// Force the landscape mode 
	return UIDeviceOrientationIsLandscape(interfaceOrientation);
 
}

Récapitulatif

Voici l’ensemble du code des fichiers que nous venons de voir :

AppDelegate

// Created by GeckoGeek on 09/09/10
// AppDelegate.h
#import <UIKit/UIKit.h>
 
@class PortraitViewController;
@class LandscapeViewController;
 
@interface AppDelegate : NSObject <UIApplicationDelegate> {
 
    UIWindow *window;
 
	// Controllers
    PortraitViewController *vcPortrait;
	LandscapeViewController *vcLandscape;
 
}
@property (nonatomic, retain) UIWindow *window;
@property (nonatomic, assign) PortraitViewController *vcPortrait;
@property (nonatomic, assign) LandscapeViewController *vcLandscape;
 
- (void)loadPortraitView;
- (void)switchToLandscapeView;
- (void)switchToPortraitView;
 
@end
 
// Created by GeckoGeek on 09/09/10
// AppDelegate.m
#import "AppDelegate.h"
#import "PortraitViewController.h"
#import "LandscapeViewController.h"
 
@implementation AppDelegate
 
@synthesize window, vcPortrait, vcLandscape;
 
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:
								(NSDictionary *)launchOptions {    
 
	// Init Window
	self.window = [ [ [ UIWindow alloc ] initWithFrame:[ [ UIScreen mainScreen ] bounds ] ] 
								autorelease ];
 
	// Init Controllers
	vcPortrait = nil;	
	vcLandscape = nil;
 
	[ self loadPortraitView ];
 
	// Display
    [ window makeKeyAndVisible ];
 
    return YES;
 
}
 
- (void)switchToLandscapeView {
 
	[ vcPortrait.view removeFromSuperview ];
	[ vcPortrait release ];
	vcPortrait = nil;
 
	vcLandscape = [ [ LandscapeViewController alloc ] init ];
	[ window addSubview:vcLandscape.view ];
 
}
 
- (void)switchToPortraitView {
 
	if (vcLandscape != nil) {
 
		[ vcLandscape.view removeFromSuperview ];
		[ vcLandscape release ];
		vcLandscape = nil;
 
	}
 
	[ self loadPortraitView ];
 
}
 
- (void)loadPortraitView {
 
	vcPortrait = [ [ PortraitViewController alloc ] init ];
	[ window addSubview:vcPortrait.view ];
 
}
 
- (void)dealloc {
 
	// Dealloc Portrait View Controller if necessary
	if (vcPortrait != nil) {
		[ vcPortrait.view removeFromSuperview ];
		[ vcPortrait release ];
		vcPortrait = nil;		
	}
 
	// Dealloc Landscape View Controller if necessary
	if (vcLandscape != nil) {
		[ vcLandscape.view removeFromSuperview ];
		[ vcLandscape release ];
		vcLandscape = nil;		
	}
 
    [ window release ];
    [ super dealloc ];
 
}
 
@end

PortraitViewController

// Created by GeckoGeek on 09/09/10
// PortraitViewController.h
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
 
@interface PortraitViewController : UIViewController {
 
	// View elements
	UILabel *labelPortrait;
	UIButton *buttonSwitchToLandscape;
 
}
- (void)go2LandscapeView:(id)sender;
 
@end
 
// Created by GeckoGeek on 09/09/10
// PortraitViewController.m
#import "PortraitViewController.h"
 
@implementation PortraitViewController
 
- (id)init {
 
	if (self = [ super init ]) {
 
		labelPortrait = nil;
		buttonSwitchToLandscape = nil;
 
	}
 
	return self;
 
}
 
- (void)loadView {
 
	// Create Main View
	[ super loadView ];
	[ self.view setFrame:CGRectMake(0.0, 0.0, 320.0, 480.0) ];
	[ self.view setBackgroundColor:[ UIColor whiteColor ] ];
 
	// Label
	labelPortrait = [ [ UILabel alloc ] initWithFrame:CGRectMake(0.0, 150.0, 320.0, 30.0) ];
	[ labelPortrait setFont:[ UIFont boldSystemFontOfSize:22.0 ] ];
	[ labelPortrait setTextAlignment:UITextAlignmentCenter ];
	[ labelPortrait setBackgroundColor:[ UIColor clearColor ] ];
	[ labelPortrait setText:@"I'm a view in Portrait mode" ];
	[ self.view addSubview:[ labelPortrait autorelease ] ];	
 
	// Button  
	buttonSwitchToLandscape = [ UIButton buttonWithType:UIButtonTypeRoundedRect ];
	[ buttonSwitchToLandscape setTitle:@"Go to a Landscape View" forState:UIControlStateNormal ];
	[ buttonSwitchToLandscape setFrame:CGRectMake(60.0, 200.0, 200.0, 40.0) ];
	[ buttonSwitchToLandscape setShowsTouchWhenHighlighted:YES ];
	[ buttonSwitchToLandscape addTarget:self action:@selector(go2LandscapeView:) 
						forControlEvents:UIControlEventTouchUpInside ];
	[ self.view addSubview:buttonSwitchToLandscape ];
 
}
 
- (void)go2LandscapeView:(id)sender {
 
	// Call the switch method of the app delegate
	[ (AppDelegate*)[ [ UIApplication sharedApplication ] delegate ] switchToLandscapeView ];
 
}
 
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
 
	return UIInterfaceOrientationIsPortrait(interfaceOrientation);
 
}
 
- (void)viewDidUnload {
 
	labelPortrait = nil;
	buttonSwitchToLandscape = nil;
 
}
 
- (void)dealloc {
 
	NSLog(@"Dealloc Portrait View Controller");	
    [ super dealloc ];
 
}
 
@end

LandscapeViewController

// Created by GeckoGeek on 09/09/10
// LandscapeViewController.h
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
 
@interface LandscapeViewController : UIViewController {
 
	UILabel *labelLandscape;	
	UIButton *buttonSwitchToPortrait;
 
}
 
- (void)go2PortraitView:(id)sender;
 
@end
 
// Created by GeckoGeek on 09/09/10
// LandscapeViewController.m
#import "LandscapeViewController.h"
 
@implementation LandscapeViewController
 
- (id)init {
 
	if (self = [ super init ]) {
 
		labelLandscape = nil;
		buttonSwitchToPortrait = nil;
 
	}
	return self;
 
}
 
- (void)loadView {
 
	// Create Main View
	[ super loadView ];
	[ self.view setFrame:CGRectMake(0.0, 0.0, 480.0, 320.0) ];
	[ self.view setBackgroundColor:[ UIColor whiteColor ] ];
 
	// Label
	labelLandscape = [ [ UILabel alloc ] initWithFrame:CGRectMake(0.0, 100.0, 480.0, 30.0) ];
	[ labelLandscape setFont:[ UIFont boldSystemFontOfSize:22.0 ] ];
	[ labelLandscape setTextAlignment:UITextAlignmentCenter ];
	[ labelLandscape setBackgroundColor:[ UIColor clearColor ] ];
	[ labelLandscape setText:@"I'm a view in Landscape mode" ];
	[ self.view addSubview:[ labelLandscape autorelease ] ];	
 
	// Button  
	buttonSwitchToPortrait = [ UIButton buttonWithType:UIButtonTypeRoundedRect ];
	[ buttonSwitchToPortrait setTitle:@"Go to a Landscape View" forState:UIControlStateNormal ];
	[ buttonSwitchToPortrait setFrame:CGRectMake(140.0, 150.0, 200.0, 40.0) ];
	[ buttonSwitchToPortrait setShowsTouchWhenHighlighted:YES ];
	[ buttonSwitchToPortrait addTarget:self action:@selector(go2PortraitView:) 
						forControlEvents:UIControlEventTouchUpInside ];
	[ self.view addSubview:buttonSwitchToPortrait ];
 
}
 
- (void)go2PortraitView:(id)sender {
 
	// Call the switch method of the app delegate
	[ (AppDelegate*)[ [ UIApplication sharedApplication ] delegate ] switchToPortraitView ];
 
}
 
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
 
	// Force the landscape mode 
	// (it works, because this controller is added to the main window in the app delegate)
	return UIDeviceOrientationIsLandscape(interfaceOrientation);
 
}
 
- (void)viewDidUnload {
 
	labelLandscape = nil;
	buttonSwitchToPortrait = nil;
 
}
 
- (void)dealloc {
 
	NSLog(@"Dealloc Project View Controller");
    [ super dealloc ];
 
}
 
@end

Vous avez construit votre SeaPerch durant les phases 1 à 3. Il est temps maintenant de le tester et de le mettre à l’eau. Voici quelques recommandations à suivre.

Checklist

Avant chaque utilisation du SeaPerch et avant de l’alimenter :

• Vérifier si le fusible est bon
• Vérifier que tous les interrupteurs du boîtier de commande sont en position OFF
• Vérifier qu’il n’y a pas de court circuit
• Faire tourner les moteurs un par un et vérifier leur fonctionnement

Réglez l’alimentation en 12V. Accrochez la pince crocodile noire sur le terminal négatif de l’alimentation, puis la pince crocodile rouge sur le terminal positif.

Mise à l’eau

Mettez le SeaPerch à l’eau. Il va maintenant falloir le lester. Utilisez ce que vous voulez ce qui compte c’est le poids, et le fait que ça ne soit pas trop gros. Vous pouvez l’attacher au filet de charge utile. Ajustez le poids du lest jusqu’à ce que le dessus des flotteurs ne dépasse que très légèrement (max 5 mm) et soit stable. Quand le SeaPerch ne possède pas de charge utile, il lui faut entre 150 et 350 grammes de lest pour atteindre une flottabilité adéquate.

Si votre SeaPerch embarque de la charge utile et qu’il coule en le mettant à l’eau, c’est qu’il est trop lourd pour la taille de ses flotteurs.

Une fois que votre SeaPerch flotte comme il faut, il est prêt à nager ! Vous pouvez y aller, amusez-vous ! N’oubliez pas de le rincer à l’eau claire après chaque utilisation, notamment les axes des moteurs pour éviter la rouille.

Allez plus loin

Le projet ne s’arrête pas là, bien au contraire, il ne fait que commencer. Ce prototype est une base qui permet de faire plein de choses amusantes avec. Nous y avons déjà fait allusion, l’intérêt est de disposer d’un porteur qui fonctionne rapidement et à moindre coût. Ce qui permet d’utiliser le temps restant pour le customiser.

Vous pouvez lui ajouter par exemple tout un tas de capteurs comme des caméras avec retour vidéo, des capteurs de pression, de profondeur ou de température, un sonar, de la lumière, des hydrophones, …

Pour intégrer tout ce petit monde vous pouvez modifier la structure, mettre des moteurs plus puissants, modifier le boîtier de contrôle, …

Et pour pousser encore plus loin, vous pouvez peu à peu chercher à le transformer en AUV, c’est-à-dire à le rendre autonome. Ainsi vous pourrez travailler sur des algorithmes de vision et de navigation.

Bref, faîtes-vous plaisir !

Manuel Complet en PDF : http://www.geckogeek.fr/static/files/SeaPerch_Manual_V1.1.pdf

Site officiel : www.seaperch.org

Dans cette troisième et dernière partie de la construction du sous-marin, nous réalisons le boîtier de contrôle qui va nous permettre de diriger les moteurs et donc le SeaPerch lui-même. Son interface est très simplifiée et utilise des interrupteurs. Du coup, nous avons choisi de vous présenter la version filaire plutôt que celle avec carte électronique (qui serait plus utile dans le cas d’un boîtier plus compliqué). Deux interrupteurs permettront de contrôler les propulseurs bâbord et tribord et deux autres le propulseur vertical. Cette partie demande environ 3h.

Matériel & Outils nécessaires

Outils Nécessaires
Outil	Image	Outil	Image
Perceuse + mèches 6,5 mm & 2,5 mm		Pince à dénuder ou Cutter
Fer à souder + étain		Ruban Isolant (ou Gaine thermo)

Matériel : Propulsion
Qt	Pièce	Taille (cm)	Diamètre (mm)	Image
1	Boitier avec couvercle à vis	12x6x4	-
2	Interrupteur à Bascule	-	-
2	Interrupteur à Bouton Poussoir	-	-
2	Pince Crocodile	-	-
2	Gaine Pince Crocodile	-	-
1	Câble porte-fusible 1.25ʼʻx25ʼʼ	-	-
1	Fusible verre 10A	-	-

Préparation du matériel

Commencez par réunir le matériel nécessaire à la construction du boîtier. En voici une photo afin que vous puissiez bien identifier tous les éléments :

① Boîtier
② Interrupteurs à bouton poussoir
③ Interrupteurs à bascule
④ Fusible 10A
⑤ Pinces crocodiles et leurs gaines
⑥ Fils électriques rouge et noir
⑦ Câble porte-fusible
⑧ Câble d’alimentation

Voici le schéma électrique représentant ce que nous allons réaliser dans le boîtier de contrôle. L’alimentation sera distribuée à des switches (interrupteurs) qui s’occuperont de changer la polarité des moteurs pour tourner dans un sens ou dans l’autre (ou les arrêter).

Préparation du boîtier

Avec un marqueur, notez l’emplacement des trous selon le schéma ci-dessous. Ne vous placez pas trop près des bords au risque de casser le boîtier ou de ne pas pouvoir mettre les interrupteurs à cause des pas de vis du couvercle qui se trouvent généralement dans les coins.

① Deux trous sur le dessus pour le contrôle des propulseurs horizontaux
② Deux trous sur le côté de la façade avant pour le contrôle du propulseur vertical
③ Un trou au milieu de la façade avant pour la sortie du câble d’attache
④ Un trou au milieu de la façade arrière pour l’entrée du câble d’alimentation

Utilisez la mèche 6,5 mm et percez aux emplacements marqués. Vérifiez que les pas de vis des interrupteurs rentrent bien dans les trous correspondants. Il en va de même pour le câble d’attache et le câble d’alimentation. Agrandissez au besoin.

Préparation du câble d’alimentation

Cette étape est séparée en trois parties dont le résultat sera assemblé à la fin pour former le câble d’alimentation.

Câble porte-fusible

Nous commençons par préparer le câble porte-fusible. Il est constitué de deux pièces en plastique qui se referment l’une sur l’autre et se maintiennent fermées. Dans l’une d’elle, on trouve un ressort et dans les deux des connecteurs. Le fusible se place dedans. Il se peut que le câble arrive non coupé (un seul câble relie les deux pièces en plastiques) afin que les différents éléments ne se détachent pas lors de la livraison, vous devrez alors le couper vous même pour avoir les deux extrémités du câble.

Dénudez sur environ 6 mm les deux extrémités du câble. Enfilez d’un côté (il n’y a pas de sens obligatoire) la gaine rouge de la pince crocodile puis soudez l’extrémité du câble à la pince crocodile. Recouvrez la pince de sa gaine. Glissez le fusible dans son emplacement (il n’y a pas de sens) et mettez le câble porte-fusible de côté.

Alimentation générale

Prenez le câble d’alimentation. Il est composé de deux conducteurs, chacun séparé par leur couche d’isolant. Les deux parties sont différentiables soit par une marque soit par leur couleur. Nous considérerons la partie colorée ou marquée comme la partie positive, l’autre sera la partie négative.

Séparez en deux l’une des extrémités sur environ 2-3 cm sans abîmer les isolants. Dénudez les deux embouts sur environ 6 mm et rentrez cette partie du câble dans le trou du boîtier correspondant ④. Enfilez-le sur environ 10-15 cm et faîtes un noeud côté intérieur (pour relâcher la tension).

Séparez de la même manière l’autre extrémité du câble mais sur une longueur un peu plus grande (à peu près de la même longueur que le câble porte-fusible). Coupez le câble correspondant à la partie positive à 2-3 cm de la jointure (cette partie sera remplacée par le câble porte-fusible). Dénudez les deux embouts sur environ 6 mm.

Enfilez la gaine noire de la pince crocodile sur l’embout négatif (celui qui n’est pas coupé) puis soudez l’extrémité à la pince crocodile. Recouvrez la pince de sa gaine. Mettez le câble d’alimentation de côté.

Distribution de l’alimentation (pour les interrupteurs)

Prenez les fils rouge et noir. Ils doivent mesurer à peu près 60 cm de longueur. Coupez-les en quatre, cela vous fait 8 morceaux de 14-16 cm approximativement. Dénudez tous les embouts sur environ 6 mm.

Assemblage

Commençons par le côté du câble d’alimentation qui est enfilé dans le trou du boîtier. Prenez les 4 fils rouges que vous venez de découper et soudez-les à l’embout positif du câble d’alimentation. Soudez ensuite les 4 fils noirs à l’embout négatif (toujours côté boîtier). N’oubliez pas de couvrir les deux soudures de gaine thermo (si possible de la même couleur que le fil) ou de ruban isolant. Voilà pour la distribution de l’alimentation.

Pour finir, de l’autre côté du câble d’alimentation, il suffit de souder le câble porte-fusible (l’embout qui n’a pas la pince crocodile) à l’embout positif du câble d’alimentation. Couvrez la soudure de gaine thermo.

Fixation du câble d’attache

Prenez l’extrémité libre du câble d’attache (celle non soudée aux moteurs) et rentrez là sur 10-15 cm dans le trou du boîtier correspondant ③ et faîtes un noeud à l’intérieur du boîtier pour relâcher la tension. Dénudez la partie qui se trouve côté boîtier sur une dizaine de centimètre. Les quatre paires de fils bicolores sont donc maintenant à l’intérieur du boîtier. Dénudez leurs extrémités (sauf pour la paire Marron qui n’est pas utilisée).

Câblage des interrupteurs à bouton poussoir

Ces deux interrupteurs vont servir à contrôler la propulsion verticale.

Reportez-vous au schéma électrique et au schéma de câblage ci-dessous pour plus de clarté. Soudez un fil rouge du câble d’alimentation sur le connecteur NO d’un interrupteur à bouton poussoir, un fil noir sur le connecteur NC. Puis soudez le fil Orange-Blanc de la paire Orange du câble d’attache au connecteur C.

Recommencez pour le second interrupteur, mais sur le connecteur C vous souderez le fil Orange de la paire.

Si vous n’êtes pas sûr de la position des connecteurs, voici comment procéder pour les retrouver. Tout d’abord, munissez-vous d’un voltmètre en mode bipeur (mode où lorsque les deux sondes sont en contact le module émet un “bip” pour signaler un court-circuit). Ce module va nous permettre de déterminer qu’elles sont les pinoches en contact les unes entre les autres lorsque le bouton poussoir est appuyé ou non.

Au repos vous devriez avoir la pin NC (masse) et la pin C en contact, et en position appuyé, la pin NO (+) et la pin C en contact. Ce contact est traduit par le petit bip. Si toutefois vous disposez d’un connecteur du même genre sans désignation, vous n’avez qu’à appliquer la méthode suivante pour trouver les bonnes connections :

Bouton poussoir au repos :
Apposez une sonde sur une pin, n’importe laquelle. 
Apposez la seconde sonde tour à tour sur les deux autres pin restantes jusqu’à entendre le bip. Vous avez alors identifié les deux pin en contact au repos.

Ces deux pin en contact sont donc NC et C, reste à déterminer laquelle est qui. Quant à la troisième pin qui n’a pas produit de son, c’est NO.

Pour la suite, vous vous en doutez, vous reproduisez la même expérience, bouton poussoir appuyé. Placez votre première sonde sur la pin identifiée comme NO et apposez la seconde sonde tour à tour sur les deux autres pin jusqu’à entendre le bip. La pin qui produit le son sera C, et la troisième sera donc NC.

Voilà, vous avez maintenant établi les connections de l’interrupteur à bouton poussoir pour votre câblage.

Câblage des interrupteurs à bascule

Ces deux autres interrupteurs vont quant à eux servir à contrôler la propulsion horizontale.

Coupez quatre petits bouts sur le fil Blanc-Marron de la paire non utilisée (environ 4 cm pour chaque morceau) et dénudez leurs extrémités. Soudez-les en croisé sur chacun des deux interrupteurs comme indiqué sur le schéma.

Soudez ensuite les fils d’alimentation noirs et rouges sur les connecteurs NC et NO des deux interrupteurs (cf schéma). Puis soudez la paire Bleue sur les connecteurs C1, C2 de l’un des interrupteurs, et la paire Verte sur les connecteurs C1, C2 de l’autre (cf schéma).

Si vous n’êtes pas sûr de la position des connecteurs, procédez de manière similaire que précédemment. Reprenez le voltmètre en mode bipeur.

La différence réside dans le fait que ces types d’interrupteurs possèdent 3 positions. Ils présentent deux lignes de trois pins identiques mais avec des résistances à différents ampérages. Le but de l’interrupteur dans notre montage est de pouvoir utiliser ces deux lignes pour inverser le sens de rotation du moteur ou l’arrêter (cf schéma électrique).

En position OFF (centrale) aucune des quatre pin C1 à C4 n’est en contact. En position gauche, les pin C1 et NC sont en contact, et les pin C2 et NO le sont également. En position droite, ce sont C3 et NC qui sont en contact ainsi que C4 et NO.

Nous relions en croisé C1 et C4, et C2 et C3, donc quand la pin d’une paire est en contact avec NO ou NC, la seconde le sera aussi. On obtient donc les groupes de contact suivant pour la position OFF : C1-C4 et C2-C3, pour la position gauche : C1-NC-C4 et C2-NO-C3, et pour la position droite : C3-NC-C2 et C4-NO-C1.

Il nous suffit donc d’identifier NC et NO pour pouvoir reconnaitre toutes les pin. Placez l’interrupteur en position gauche et apposez votre sonde sur la pin du milieu qui se trouve à gauche. Si elle est en contact avec celle qui se trouve au dessus d’elle (potentiellement C1) alors il s’agit bien de NC. Si elle est en contact avec celle du dessous (potentiellement C3), il s’agit de NO. Reportez-vous au schéma électrique pour savoir comment se positionnent les pin C1 à C4 autour de NC et NO.

Finition du boîtier de contrôle

Vissez les interrupteurs dans leurs emplacements. Attention aux sens : pour les interrupteurs gauche-droite, mettez-les dans le même sens (les fils rouges NO à gauche), pour les interrupteurs haut-bas, le Orange (bas) au dessus du Orange-Blanc (haut) quand on regarde la boîte comme sur la photo ci-dessous.

Avant de fermer, il faut tester si tout marche bien. Placez tous les interrupteurs en position off. Alimentez en 12v et testez les interrupteurs un par un, dans un sens puis dans l’autre. S’il y a un problème, revenez sur les deux étapes précédentes et vérifiez vos connexions. Vérifiez également que les moteurs tournent dans le sens voulu par rapport à la commande. Si ce n’est pas le cas, plutôt que de refaire les soudures, vous pouvez intervertir les interrupteurs ou les faire pivoter.

Sinon vous pouvez rentrer tous les fils dans le boîtier et visser le couvercle. Votre boîtier de contrôle est maintenant terminé.

Rendez-vous maintenant pour le dernier billet : check-liste et mise à l’eau de votre sous-marin.

Manuel Complet en PDF : http://www.geckogeek.fr/static/files/SeaPerch_Manual_V1.1.pdf

La seconde partie de la construction du robot sous-marin consiste à monter le système de propulsion, c’est à dire les moteurs et les hélices. Comme les moteurs vont se retrouver dans l’eau, il va falloir les rendre étanches. Ce passage n’est pas évident à réaliser et demande un peu de temps. Vous pouvez compter environ 4h pour cette partie.

Matériel & Outils nécessaires

Outils Nécessaires
Outil	Image	Outil	Image
Ciseaux		Tournevis cruciforme
Perceuse + mèches 6,5 mm & 2,5 mm		Pince
Fer à souder + étain		Ruban Isolant
Ruban en Caoutchouc Butyle (peut être remplacé par la colle chaude)		Epoxy + Bâtonnet
Casserole + Pot (bain-marie)		Colle chaude (optionnel)

Matériel : Propulsion
Qt	Pièce	Taille (cm)	Diamètre (mm)	Image
3	Flacon plastique 50ml (boîte pellicule photo)	5,0	30,0
3	Moteur 12V	-	-
1	Câble à 4 paires torsadées (câble dʼattache)	1200	-
1/2	Anneau de cire de toilette	-	-
3	Hélice 1/8″ 0.19-0.35	-	40,0
3	Arbre de transmission 4-40 0.095″	-	-
6	Ecrou hexagonal en laiton	-	-

Préparation des conteneurs des moteurs

Avec une mèche 2,5 mm, percez un trou au centre de chacun des bouchons des trois boîtes de pellicules. Ce sont par ces trous que vont passer les fils.

Percez avec la même mèche le fond des boîtes. Vous devez percer exactement au centre et faire très attention à ne pas trop élargir le trou. Les axes des moteurs passeront par ces trous, c’est pour cela qu’ils doivent être parfaitement centrés. Testez si les moteurs rentrent bien dans les boites et leurs axes par les trous du fond.

Préparation des moteurs

Nous allons commencer par tester la polarité des moteurs. Alimentez-les en 12V avec un câble rouge et un câble noir sur chacun des connecteurs. Vous pouvez ajouter un bout de papier sur leurs axes pour mieux les voir tourner. Si l’axe tourne dans le sens inverse des aiguilles d’une montre quand il est orienté vers vous, alors vous êtes câblé dans le bon sens. Apposez une marque sur le connecteur sur lequel vous avez branché votre câble rouge : c’est le connecteur positif. S’il tourne dans l’autre sens, c’est qu’il est câblé à l’envers : vérifiez et apposez la marque sur l’autre connecteur. Cette marque vous permettra de repérer facilement la polarité quand le moteur sera tout emmailloté.

Recouvrez maintenant les trois moteurs (hormis leurs deux connecteurs et leur axe) avec du ruban isolant. Faîtes bien attention à ne pas laisser de trou ni de plis car la cire qui servira à les rendre étanches ne doit pas pouvoir entrer dans les moteurs (elle les endommagerai). Ne les rendez pas non plus trop gros car ils doivent toujours pouvoir se glisser dans la boîte de pellicule photo (en plus de la cire).

Pour plus de facilité, coupez des petits bouts de ruban pour les deux extrémités. Pour le dessus et le dessous, tendez les morceaux bien droit et appuyez pour que l’axe ou les connecteurs percent le ruban, ainsi le reste sera bien recouvert. Coupez des morceaux plus longs pour les enrouler autour du corps. Vérifiez bien qu’il n’y ait pas de trou, sinon les moteurs risqueraient de moins bien marcher ou de s’abîmer plus rapidement.

Vérifiez à nouveau que les moteurs rentrent bien dans les boîtes de pellicules photos.

Câblage des moteurs

Il s’agit d’un ROV, il est donc connecté à la surface par un câble d’attache dans lequel se trouvent 4 paires de fils torsadés.

Dénudez un bout du câble d’attache sur environ 38 cm en faisant bien attention à ne pas couper les fils qui se trouvent dedans. Séparer les quatre paires torsadées les unes des autres. La paire Marron ne sera pas utilisée et peut être laissée de côté.

Prenez une des trois paires de fils (n’importe quelle couleur) et enfilez-la à travers le bouchon d’une boîte de pellicule photo sur environ 10 cm. Faîtes un noeud sur le côté intérieur du bouchon pour relâcher la tension. Faire de même pour les deux autres paires de fils.

[TABLEAU CODE COULEUR]

Dénudez chaque embout des fils des trois paires sur environ 6 mm. Soudez ensuite pour chaque paire le câble coloré au connecteur positif d’un moteur et le câble bicolore (couleur + blanc) au second connecteur (négatif). Le tableau ci-dessus récapitule le code couleur utilisé.

Avant de passer à l’étape suivante (scellage des moteurs dans la cire pour les rendre étanches), n’oubliez pas de tester si les connections sont bonnes.

Etanchéité des moteurs

Il faut maintenant rendre les moteurs étanches. Pour cela nous allons utiliser de la cire qui va sceller les moteurs dans les boîtes de pellicule photo. Cette partie n’est pas évidente. Il est conseillé de se munir de gants, pour ne pas se salir les mains, ainsi que de protéger l’espace de travail (la cire va couler). Vous pouvez aussi porter un tablier pour protéger vos vêtements.

Coupez la moitié de l’anneau en cire (cela suffit pour trois moteurs) et faîtes la fondre au bain-marie (pas de micro-onde, ni directement dans la casserole, c’est dangereux). La cire doit être liquide et fluide mais elle ne doit pas non plus être trop chaude. Ce type de cire ne durci pas, cela permettra d’avoir un corps gras en permanence autour du moteur qui repousse l’eau tout en laissant l’axe tourner à son aise (la cire se reforme autour de lui).

Trouvez un support pour pouvoir maintenir les boîtes verticalement avec l’axe du moteur qui dépasse en dessous (vous pouvez utiliser un étau mais il ne faut pas trop serrer au risque de déformer les boîtes, les poser sur un support troué qui laisse passer les axes est préférable).

Mettez un bout de ruban isolant sur les trous du fond des boîtes (à l’extérieur). Cela empêchera la cire de couler tant que vous n’avez pas mis le moteur. Ne le mettez pas trop serré car il doit partir facilement quand vous plongerez le moteur. (Vous pouvez éventuellement le percer un peu avec l’axe du moteur au préalable pour éviter que trop de cire ne tombe quand vous plongez le moteur.)

Remplissez une première boîte avec la cire fondue sur à peu près 1 cm de hauteur. Plongez-y le moteur et remuez-le pour que l’axe ressorte comme il faut. La cire va remonter sur les côtés (et va sortir par le trou du dessous) mais ne doit pas remonter par dessus le moteur. La cire se solidifie rapidement au contact de l’air et du moteur qui sont froids. Mettez le bouchon pour éviter les déformations de la boîte, laissez refroidir et répétez l’opération sur les deux autres boîtes.

Maintenant il faut mettre une deuxième couche de cire. Débouchez les boîtes et ajoutez -y de la cire fondue afin qu’elle recouvre juste le dessus des moteurs (et non jusqu’en haut de la boîte). Penchez au besoin les boîtes pour retirer les bulles d’air tant que la cire est liquide. Attendez un peu que la cire refroidisse.

Et enfin la troisième et dernière couche. Vérifiez que les bouchons se fixent toujours bien et préparez les fils pour qu’ils se rentrent comme il faut. Remplissez une première boîte à ras bord puis rajoutez-en un peu afin que la surface soit bombée. Quand vous fermez le bouchon, la cire doit ressortir par le trou, laissez-la former un petit cône à cet endroit afin qu’il n’y ait pas de fuite. Répétez la manoeuvre avec les deux autres boîtes.

Laissez refroidir le tout. Si tout s’est bien passé, les moteurs sont maintenant étanches.

NB : pour un côté pratique, nous avons scellé les couvercles et leurs trous non pas à la cire mais à la colle chaude (en dégraissant bien les surfaces au préalable). Car, la cire restant un peu molle, à chaque mouvement des fils elle avait tendance à s’écarter.

Montage des hélices

Nettoyez bien la cire qui serait restée sur les axes des moteurs. Enfilez un écrou sur les axes des hélices presque jusqu’au bout. Observez les hélices, le côté doté d’une rainure est celui qui sera tourné vers le moteur.

Préparez votre plan de travail et installez bien en vue tous les éléments nécessaires à cette étape. L’époxy devient inutilisable au bout de 3 minutes, vous devrez donc aller vite. Avec la quantité d’époxy présente dans un paquet vous pouvez monter jusqu’à 10 hélices à la fois.

Mélangez l’époxy sur un morceau de papier avec un bâtonnet jusqu’à ce qu’elle devienne uniforme.

Utilisez le bâtonnet pour mettre une goutte d’époxy sur chacun des axes d’hélice juste derrière l’écrou, puis vissez l’écrou à fond.
Ajoutez une goutte sur l’axe juste au dessus des écrous et enfilez les hélices (la rainure vers le bas). Ajoutez à nouveau une goutte sur les petits bouts des axes qui dépassent et vissez-y les seconds écrous. Ce côté-là est terminé, reste la fixation à l’axe du moteur.

Ajoutez une goutte dans le trou de l’axe de l’hélice, et une sur le bout de l’axe du moteur. Glissez l’axe de l’hélice sur celui du moteur. Recommencez avec les deux autres. Pressez bien les axes des hélices sur ceux des moteurs pendant au moins trois minutes afin qu’ils ne soient pas repoussés en arrière à cause de la pression de l’époxy.

Laissez les moteurs reposer pendant au moins 60 minutes sans les toucher. Il faut 24 heures pour que l’époxy finisse de sécher totalement.

Montage des propulseurs sur le châssis

Dévissez les support moteurs. Glissez un moteur dans chacun des supports et vissez-les sur le châssis, hélices vers l’extérieur.

Commencez par celui du milieu (paire Orange), puis montez ceux des côtés (paire Bleue à gauche, paire Verte à droite). Reportez-vous au tableau ci-dessous pour la correspondance.

[TABLEAU CODE COULEUR]

Vous pouvez maintenant orienter les tubes PVC pour donner l’angle que vous souhaitez à vos moteurs selon le type de propulsion qui sera le plus adapté à votre mission. Vous obtiendrez une plus grande stabilité si les propulseurs sont parallèles à la ligne qui rejoint leur centre avec le centre de gravité du SeaPerch.

Etanchéité du câble d’attache

Mettez du ruban en caoutchouc butyle (nous avons mis de la colle chaude à la place) pour sceller l’embout de la gaine du câble d’attache afin que l’eau ne rentre pas dedans. Enroulez du ruban isolant par dessus cette intersection. Le câble d’attache est maintenant étanche.

Faîtes une boucle avec le câble et fixez-le avec un collier rilsan sur le bas du châssis pour relâcher la tension. Ainsi il ne tirera pas sur les moteurs.

La seconde partie est finie, nous allons maintenant monter le boîtier de contrôle.

Manuel Complet en PDF : http://www.geckogeek.fr/static/files/SeaPerch_Manual_V1.1.pdf

Dans cette première partie de la construction du SeaPerch, nous allons monter sa structure qui est essentiellement composée de PVC. Vous pouvez prévoir environ trois heures pour cette réalisation. Elle ne présente pas de difficulté particulière.

Matériel & Outils nécessaires

Outils Nécessaires
Outil	Image	Outil	Image
Règle		Marqueur
Coupe-tube PVC ou Scie		Ciseaux
Pince		Tournevis cruciforme
Perceuse + mèches 6,5 mm & 2,5 mm		Etau ou Serre-joint
Maillet en caoutchouc (ou marteau dans un chiffon)

Matériel : Châssis
Qt	Pièce	Taille (cm)	Diamètre (mm)	Image
1	Poutre PVC en H	38	9,5
1	Tube PVC Sch. 40	150	16 (21)
10	Coude PVC Sch. 40	-	16 (21)
4	T PVC Sch. 40	-	16 (21)
6	Vis à tôle acier inoxydable	~1,2	~7,0
6	Rondelle acier inoxydable	-	~7,0
2	Cylindre en mousse (flotteurs)	~12,5	~60,0
3	Collier de fixation de tuyau (support moteur)	~8,0	~30,0
1	Grillage en plastique	~20×30	-
6-8	Collier de fixation rilsan	-	-

Découpage des pièces du châssis

Prenez le tube de PVC. A partir d’un bord droit, mesurez et notez au marqueur les longueurs des différents segments à découper. Il vous faudra :

• 2 pièces de 6,4 cm de long
• 2 pièces de 10,2 cm de long
• 2 pièces de 11,4 cm de long
• 4 pièces de 3,8 cm de long
• 4 pièces de 12,7 cm de long
• 4 pièces de 2 cm de long

Vous pouvez découper votre tube PVC avec un coupe-tube spécialement fait pour ou avec une scie. Si vous utilisez une scie, faites bien attention à maintenir comme il faut le tube pour qu’il ne bouge pas. Découpez les pièces le plus droit possible selon les marques que vous avez notées.

Il devrait vous rester quelques chutes. Vous pouvez faire les finitions au papier de verre si vous le souhaitez.

Création de trous de drainage dans le châssis

Rassemblez les coudes en PVC. Maintenez en un dans l’étau ou dans le serre-joint. Equipez la perceuse de la mèche 6,5 mm et percez un trou sur le côté extérieur du coude. Répétez l’opération sur les neuf autres coudes.

Ces trous sont destinés à laisser rentrer l’eau dans la structure lorsque vous mettez le SeaPerch à l’eau et à la laisser s’écouler lorsque vous l’en sortez.

Assemblage du châssis

Prenez toutes les pièces PVC à l’exception de celles de 2 cm. Assemblez-les selon la figure suivante pour former la structure du châssis. Si la structure n’est pas trop grande comme ici, il n’est pas nécessaire de coller les jointures.

Voici le résultat que vous obtenez :

Ajout des flotteurs et renforcement du châssis

Coupez la poutre PVC en H en deux parties égales (environ 19 cm pour chaque morceau). Glissez chacun des morceaux dans un cylindre en mousse. Les bouts doivent dépasser.

Insérez les petits tubes PVC de 2 cm dans chacun des quatre coudes situés sur la partie haute du châssis. Fixez-y les embouts des poutres en H.

Appuyez fortement sur toutes les jointures de la structure pour bien fixer les tubes. Les poutres en H ne doivent pas pouvoir tomber de leur support. Utilisez un maillet en caoutchouc (ou un marteau dans un chiffon) pour bien resserrer les connections.

Ajout des supports moteurs

Ajoutez maintenant les supports moteurs. Positionnez-les bien centrés sur la hauteur des tubes (voir photo) et notez l’emplacement des vis à l’aide du marqueur. Le centrage et la verticale sont très importants, plus important que l’angle car vous pourrez orienter légèrement les tubes par la suite. Choisissez donc plutôt un angle dans lequel vous pouvez percer facilement.

Percez les trous à l’aide de la mèche de 2,5 mm. Mettez les vis dans les rondelles, puis à travers les trous des supports et vissez-les au châssis. Ne serrez pas trop car vous allez les démonter à nouveau pour y placer les moteurs et vous risquez d’abîmer le pas de vis dans le PVC.

Ajout du filet de charge utile

Positionnez maintenant le filet sous le châssis. Coupez les bords au besoin, mais laissez-le déborder un petit peu pour qu’il ne glisse pas.

Fixez-le ensuite au châssis à l’aide de 6-8 colliers de fixation rilsan. Utilisez une pince pour bien serrer les colliers puis coupez à ras les bouts qui dépassent.

La première partie est finie, nous allons maintenant monter la propulsion.

Manuel Complet en PDF : http://www.geckogeek.fr/static/files/SeaPerch_Manual_V1.1.pdf

Vous avez toujours rêvé de construire votre propre robot sous-marin, mais vous pensiez que c’était trop compliqué ? Ou bien que ça prenait trop de temps, de place ? C’est que vous êtes passé à côté du SeaPerch : un petit robot sous-marin (30x20x20 cm) qui se construit en une dizaine d’heures à base de tubes de PVC. Nous vous proposons un petit manuel de construction en cinq billets.

A propos du SeaPerch

Le SeaPerch est un petit sous-marin téléguidé que l’on appelle ROV (Remote Operated Vehicle – véhicule commandé à distance). Le programme SeaPerch a été mis en place par le MIT Sea Grant en 2003. Ils ont conçu un kit dans un but pédagogique en simplifiant la construction d’un modèle du célèbre « Livre Jaune » (« Build Your Own Under Water Robot and Other Wet Projects », Harry Bohm & Vickie Jensen).

L’idée était de pouvoir construire facilement et à moindre coût un petit robot sous-marin en une dizaine d’heures. Dans ce cadre attractif il est alors possible d’aborder des notions scientifiques très différentes pendant toutes les étapes de la conception. La construction du SeaPerch peut faire l’objet de projets ou de travaux pratiques. La réalisation n’est pas compliquée et elle peut être abordable dès le collège (avec encadrement).

Au delà de cet aspect pédagogique, le côté très intéressant du SeaPerch est que l’on obtient rapidement une base qui fonctionne. A partir de celle-ci, on peut l’améliorer, la modifier ou encore y rajouter différents capteurs et autre charges utiles. Il est en outre possible de passer de modifications d’un niveau très simple à des modifications d’un niveau beaucoup plus technique, au choix.

A propos du manuel

Ce manuel a été rédigé en français en s’inspirant du manuel anglais et s’appuie directement sur la construction d’un SeaPerch.

Manuel Complet en PDF : http://www.geckogeek.fr/static/files/SeaPerch_Manual_V1.1.pdf

Il est composé de trois grandes parties qui peuvent être réalisées indépendamment les unes des autres : Châssis, Propulsion et Boîtier de commande. Chacune de ces parties est séparée en plusieurs étapes. Il est préférable de lire chaque étape entièrement avant de procéder à la manipulation.
Le matériel et les outils nécessaires aux étapes sont présentés au début de chacune d’entre-elles.

Voici le test et la mise à l’eau du SeaPerch que nous avons construit, cela vous donne une petite idée du résultat :

Kit

Vous pouvez acheter la composition du kit en pièces détachées, mais vous pouvez aussi commander un kit tout préparé directement sur le site officiel (inscription gratuite) pour 70$.

Nous vous conseillons d’ailleurs d’en commander un pour votre premier. Après, libre à vous de commander d’autres kits ou d’acheter vous mêmes les pièces, ce qui risque d’arriver si vous modifier la structure du SeaPerch par la suite.

Amusez-vous bien !

La WWDC 2010 a commencé aujourd’hui et pour se mettre dans l’ambiance Steeve Jobs a débuté avec son “habituelle Keynote”. Au programme des chiffres, des remerciements, et surtout la présentation du nouvel iPhone “4″ ! Voyons un peu les entrailles de ce nouveau “bijou technologique” et estimons rapidement s’il apporte un réel plus à son prédécesseur le “3GS”.

Les 8 principales caractéristiques de l’iPhone 4

• Un nouveau design et 24% plus fin que l’iPhone 3GS. Une caméra en facade et un flash sur l’arrière pour les photos.
• Un écran avec 4 fois plus de pixels, appelé “écran Retina“. On arrive à environ 326 DPI. Cela donne du 960*640 pixels en définition.
• Un processeur A4 d’Apple, que l’on retrouve dans l’iPad. Par ailleurs grâce à une plus grosse batterie (malgré la plus petit taille de l’engin), on arrive à tenir 10h en vidéo et 40h en musique.
• La présence d’un Gyroscope avec une nouvelle API : “CoreMotion“. Ceci devrait donner encore plus d’intéractivité dans les applications.
• Une nouvelle caméra embarquant 5 millions de pixels et surtout une technologie améliorant de beaucoup la qualité des images, comme dans un milieu à faible luminosité. Avec ceci arrive de la vidéo 720p à 30FPS et iMovie version iPhone (4.99$ sur l’AppStore) pour modifier ses vidéos directement.
• L’OS de l’iPhone 4 est renommé “iOS 4“.
• L’application de livres “iBooks” sur iPhone : synchronisation sans frais des livres numériques (achetés sur iPad par exemple).
• Le système de rémunération iAds (disponible dès le 1er Juillet) qui devrait “aider les développeurs à créer des applications à bas prix…”. 70% des revenus sont reversés aux développeurs, ce qui est en fait très bon si on compare à ce qui se fait sur Internet. Déjà de “nombreux” clients récoltés par Apple qui fait la régie. Les quelques exemples présentés par Apple semblent plutôt convaincants.

Les Prix !

L’iPhone 4 devrait sortir le 24 Juin aux US (et dans 4 Pays … dont la France !!) pour la “modique” somme de :

• 199$ pour la Version 16 Go
• 299$ pour la Version 32 Go

L’iPhone 3GS devrait passer à 99$ et l’iPhone 3G est abandonné.
On peut s’attendre à des reprises d’anciens iPhone ou des contrats avec Orange, SFR etc.

En vracs des informations supplémentaires

• Bing arrive sur iPhone mais Google devrait rester comme moteur de recherche par défaut
• iMovie iPhone semble très complet malgré le manque de place sur le petit écran
• La meilleure définition d’écran permettra d’avoir moins de “grain” sur l’écran et d’afficher le texte (et médias) de manière bien plus nette.
• 95% des applications soumises pour l’AppStore sont mises en ligne.
• L’”iOS4″ est gratuit et sera disponible dès le 21 juin.

“One More Thing” : iChat Vidéo

Grâce à la caméra en facade ce nouvel iPhone apporte la discussion vidéo. Pour 2010 cela ne serait possible qu’en Wifi (faut pas pousser mémé dans la rupture des réseaux 3G non plus hein !).

Pour résumer : un iPhone plus compact, plus puissant, qui dure plus longtemps et qui apporte plus d’interactivité. De bonnes surprises comme le gyroscope, la caméra en facade ou bien l’écran retina qui devraient apporter une bonne valeur ajoutée. Attendons de voir comment vont réagir les concurrents !