Logboek van Kapitein Emiliano Bruni

Het belooft een zeer interessante 2010 voor iemand als ik, is dol op afstand bestuurbare helikopters.

Feit dat we geconfronteerd met een radicale verandering. Vergeet de helikopters moeilijk te controleren en sloeg op de grond voortdurend. E "in arrivo AR.Drone, een fantastisch product van een Franse producent die belooft verbazingwekkende dingen.

Een voorbeeld? Dankzij een reeks van sensoren, AR.Drone handhaaft automatisch een vaste positie tijdens de vlucht, zonder dat continu aaggiustamenti dit dankzij de indrukwekkende aanwezigheid van sensoren. De AR. Drone heeft, binnen twee ultrasone sensoren om de controle van de verticale stabiliteit, een accelleromento drie-assige gyroscoop met twee assen voor horizontale stabiliteit.

AR.Drone onthoudt het punt van waaruit zij partij is en heeft een automatische functie terug te keren naar basis die zonder gek, dan kunt u hem vertellen om automatisch het land vanaf het punt waar het vertrokken.

Niet genoeg? Hier dan twee bommen. Eerste. AR.Drone heeft twee webcams met 60, zeg zestig frames per seconde. Ik zal zeggen, en waar zie ik de films van de twee webcams? Ok, tweede bom. De AR. Drone kan worden gecontroleerd met behulp van de iPhone. Ja, met behulp van de accelerometer van de iPhone lijkt triviaal schijf van de AR. Drone. Wat de webcams, films zijn geschoten in live streaming op de iPhone dus wordt het theoretisch mogelijk om de Drone rijden zonder te zien dat fysiek met alleen de gegevens die de camera's.

Maar er is meer. De AR. Drone ook spelmodi single player en multiplayer met behulp van augmented reality.

Single player is, op beelden uitgezonden op de iPhone, inclusief bijkomende elementen zoals robots en andere vijanden drones met wapens te vernietigen, van natuurlijk, virtueel. Indien op het speelveld, er zijn andere AR.Drone vrienden vervolgens de strijd wordt het echte leven en je kunt vechten tegen andere helikopters.

De helikopter is aangesloten op de iPhone via WiFi netwerk en vervolgens worden gecontroleerd tot 50 meter. En als de helikopter komt van WiFi-bereik? Nou, tot dusver, met de producten die momenteel op de markt, als een helikopter komt uit het dekkingsgebied van zijn controller, crasht het op de grond. Maar aviluppatore van AR.Drone lijken te hebben aan alles gedacht. In het geval van RA. Drone, blijft dit in de lucht een minuut wachten voor de iPhone terug naar de banden met de helikopter, en zo niet, een zachte landing procedure te starten. Heel slim deze Frans.

U bent gegeten door nieuwsgierigheid, hè? Toen begon kijken naar deze video presentatie van het product op CES 2010

ook kijken naar de video-presentatie van het product

en deze, die zijn vermogen toont aan augmented reality bij de identificatie van de vijand darren

Het product zal ook een SDK voor de ontwikkeling van hun eigen toepassingen die verschijnt, op papier goed gedaan. De AR. Drone wordt gecontroleerd door middel van commando AT als een modem, en vanaf dit extract van de code lijkt erop dat dingen relatief eenvoudig zijn, althans voor ons professionals

 # Include <stdio.h>
 # Include stdlib.h
 # Include <unistd.h>
 # Include <string.h>
 # Include <errno.h>
 # Include <sys/types.h>
 # Include <sys/socket.h>
 # Include <netinet/in.h>
 # Include <netdb.h>
 # Include <fcntl.h>
 # Include <sys/ioctl.h>
 # Include <net/if.h>
 # Include <arpa/inet.h>
 # Define AT_PORT 5556
 # Define WIFI_MYKONOS_IP "192.168.1.xxx"
 struct sockaddr_in aan;
 int32_t vlaggen;
 if (at_udp_socket <0)
 (
   / / / Open UDP socket commando's uit te zenden ten Ardron
   struct sockaddr_in at_udp_addr;
   memset ((char *) & at_udp_addr, 0, sizeof (at_udp_addr));
   at_udp_addr.sin_family = AF_INET;
   at_udp_addr.sin_addr.s_addr = INADDR_ANY;
   at_udp_addr.sin_port = htons (AT_PORT +100);
   at_udp_socket = socket (AF_INET, SOCK_DGRAM, 0);
   een int = 1;
   if (at_udp_socket> 0)
   (
     flags = fcntl (at_udp_socket, F_GETFL, 0);
     if (flags> = 0)
     (
       flags | = O_NONBLOCK;
       flags = fcntl (at_udp_socket, F_SETFL, vlaggen);
     ) Else (
       printf ( "Get socket options mislukt \ n");
     )
     bind (at_udp_socket, (struct sockaddr *) & at_udp_addr, sizeof (struct sockaddr));
   )
 )
 if (at_udp_socket> 0)
 (
   int res;
   memset ((char *) & te, 0, sizeof (aan));
   to.sin_family = AF_INET;
   to.sin_addr.s_addr = inet_addr (WIFI_MYKONOS_IP), / / Broadcast adres
   voor subnet 192.168.1.xxx
   to.sin_port = htons (AT_PORT);
   # Ifdef DEBUG
     printf ( "% d bytes uitzending op poort% d [% s] \ n", * len, at_udp_socket, buffer);
   # Endif
   res = SendTo (at_udp_socket, (char *) buffer, * len, 0, (struct sockaddr *) & aan, sizeof (te));
   if (res <0)
   (
     printf ( "Fout sendto% s \ n", strerror (errno));
   ) Else (
     # Ifdef DEBUG
       printf ( "[Client]: Stuur car% d \ n", res);
     # Endif
   )
 )

Ja, ik weet, lijkt het Arabisch, maar ik verzeker u, voor ons professionals is een manier om plannen zeer helder en schoon. Wij zijn allen, en ik denk dat op dit punt, ook u, nieuwe ontwikkelingen.

Voor alle overige informatie verwijzen wij u naar de hoofdsite van het product.