helicontrol.c

Go to the documentation of this file.

/***************************************************************************
 *  helicontrol - c/c++ control api for silverlit helicopters/quadcopters  *
 *  Copyright (C) 2008 by                                                  *
 *  Joint Robotics Lab                                                     *
 *  Goethe-University Frankfurt, Germany                                   *
 *  http://www.jrl.cs.uni-frankfurt.de                                     *
 *                                                                         *
 *  This library is free software; you can redistribute it and/or          *
 *  modify it under the terms of the GNU General Public                    *
 *  License as published by the Free Software Foundation                   *
 *  version 2 of the License.                                              *
 *                                                                         *
 *  This program is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      *
 *  General Public License for more details.                               *
 *                                                                         *
 *  You should have received a copy of the GNU General Public              *
 *  License along with this library; if not, write to the Free Software    *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA02110-1301 USA*
 ***************************************************************************/

/* $Id: helicontrol.c 269 2008-12-17 22:25:11Z holgerf $ */

#include "../firmware/com_def.h"
#include "helicontrol.h"
#include "helicontrol_firmware.h"
#include "frame.h"
#include <string.h>
#include <stdio.h>

#define TIMEOUT_MS    2000

struct usb_dev_handle *HC_Init(void)
{
    struct usb_bus *bus;
    struct usb_device *dev;
    struct usb_dev_handle *handle;
    char myfirmware[] = "1.0";
    int res;
    char s[30];

    usb_init();
    usb_find_busses();
    usb_find_devices();

    for (bus = usb_get_busses(); bus; bus = bus->next)
    {
        for (dev = bus->devices; dev; dev = dev->next)
        {
            if ((dev->descriptor.idVendor == HC_VendorID)
                    && (dev->descriptor.idProduct == HC_ProductID))
            {
                if ((handle = usb_open(dev)) == NULL)
                {
                    fprintf(stderr, "usb device: busy, cannot open\n");
                }
                else
                {
                    if (usb_set_configuration(handle, 1) < 0)
                    {
                        /* error */
                        fprintf(stderr, "usb device: cannot set configuration\n");
                        usb_close(handle);
                        handle = 0;
                    }
                    else
                    {
                        /* needed for WIN32, ok for Linux, maybe bad idea on MacOS X. remove it if you get into trouble */
                        if (usb_claim_interface(handle, 0) < 0)
                        {
                            /* error */
                            fprintf(stderr, "usb device: cannot claim interface\n");
                            usb_close(handle);
                            handle = 0;
                        }
                        else
                        {
                            /* dev found, opened, maybe claimed. */
                            /* query firmware rev */


                            res = HC_Read_Firmware_Revision(handle, s, sizeof(s));
                            /* printf("res=%d, s=%s\n", res, s); */
                            if (res<=0)
                            {
                                fprintf(stderr, "usb device: cannot read firmware revision\n");
                            }
                            else
                            {
                                if (0!= strcmp(s, myfirmware))
                                {
                                    fprintf(stderr, "usb device: incompatible firmware (sw: \"%s\", hw: \"%s\").\nplease update firmware and/or software.\n",
                                            myfirmware, s);
                                    usb_close(handle);
                                    handle = 0;
                                }
                                /* else: ok, known device... */
                            }

                            return handle;
                        }
                    }
                }
            }
        }
    }
    return NULL;
}


int HC_Read_Firmware_Revision(usb_dev_handle *handle, char *fwstring, size_t maxlen)
{
    char s[30];
    int res;
    res = usb_get_string_simple(handle, USB_VendorFirmwareRevIndex, s, sizeof(s));
    s[29] = 0;
    if (fwstring)
    {
        if (res <= 0)
        {
            fwstring[0] = 0;
        }
        else
        {
            strncpy(fwstring, s, maxlen);
            if (maxlen>0) fwstring[maxlen-1] = 0;
        }
    }
    return res;
}

int HC_Read_Firmware_Build_Date(usb_dev_handle *handle, char *datestring, size_t maxlen)
{
    char s[30];
    int res;
    res = usb_get_string_simple(handle, USB_VendorFirmwareBuildDate, s, sizeof(s));
    s[29] = 0;
    if (datestring)
    {
        if (res <= 0)
        {
            datestring[0] = 0;
        }
        else
        {
            strncpy(datestring, s, maxlen);
            if (maxlen>0) datestring[maxlen-1] = 0;
        }
    }
    return res;
}

void HC_Read_Lib_Build_Date(char *datestring, size_t maxlen)
{
    char *buildstring = __DATE__ " " __TIME__;
    strncpy(datestring, buildstring, maxlen);
    if (maxlen>0) datestring[maxlen-1] = 0;
}

int HC_CMD_Repeat(usb_dev_handle *handle, char repeat)
{
    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, CMD_AUTOREPEAT, repeat, 0, NULL, 0, TIMEOUT_MS);
}


int HC_CMD_Interval(usb_dev_handle *handle, int interval_ms)
{
    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, CMD_REPEAT_INTERVAL, interval_ms, 0, NULL, 0, TIMEOUT_MS);
}


int HC_CMD_Stop(usb_dev_handle *handle)
{
    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, CMD_STOP, 0, 0, NULL, 0, TIMEOUT_MS);
}


int HC_Send_Picooz(usb_dev_handle *handle, char channel, char throttle, char yaw, char trim)
{
    frame.raw = 0;
    frame.picooz.channel = channel;
    frame.picooz.throttle = throttle;
    frame.picooz.trim = trim;
    frame.picooz.yaw = yaw;

    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, PROTO_PICOOZ, frame.usb.value, frame.usb.index, NULL, 0, TIMEOUT_MS);
}


int HC_Send_Challenger(usb_dev_handle *handle, char channel, char throttle, char yaw, char trim, char fire)
{
    frame.raw = 0;
    frame.challenger.channel = channel;
    frame.challenger.throttle = throttle;
    frame.challenger.trim = trim;
    frame.challenger.yaw = yaw;
    frame.challenger.fire = 3*!!fire;

    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, PROTO_CHALLENGER, frame.usb.value, frame.usb.index, NULL, 0, TIMEOUT_MS);
}


int HC_Send_Uranus(usb_dev_handle *handle, char channel, char throttle, char yaw, char pitch, char trim, char light)
{
    frame.raw = 0;
    frame.uranus.channel = channel;
    frame.uranus.throttle = throttle;
    frame.uranus.trim = trim;
    frame.uranus.yaw = yaw;
    frame.uranus.pitch = pitch;
    frame.uranus.light = !!light;

    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, PROTO_URANUS, frame.usb.value, frame.usb.index, NULL, 0, TIMEOUT_MS);
}


int HC_Send_Tandemz(usb_dev_handle *handle, char channel, char throttle, char yaw, char pitch, char pitch_trim, char light)
{
    frame.raw = 0;
    frame.tandemz.channel = channel;
    frame.tandemz.light = !!light;
    frame.tandemz.throttle = throttle;
    frame.tandemz.pitch = pitch;
    frame.tandemz.ptrim = pitch_trim;
    frame.tandemz.yaw = yaw;

    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, PROTO_TANDEMZ, frame.usb.value, frame.usb.index, NULL, 0, TIMEOUT_MS);
}


/* FIXME: protocol not fully analysed yet (esp. no checksum calculated by AVR firmware) */
int HC_Send_Ibird(usb_dev_handle *handle, char channel, char throttle, char yaw, char unknown, char checksum)
{
    frame.raw = 0;
    frame.ibird.channel = channel;
    frame.ibird.throttle = throttle;
    frame.ibird.yaw = yaw;
    frame.ibird.unknown = unknown;
    frame.ibird.checksum = checksum;

    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, PROTO_IBIRD, frame.usb.value, frame.usb.index, NULL, 0, TIMEOUT_MS);
}


int HC_Send_Saucer(usb_dev_handle *handle, char throttle, char yaw, char pitch, char roll)
{
    frame.raw = 0;
    frame.saucer.roll = roll;
    frame.saucer.pitch = pitch;
    frame.saucer.throttle = throttle;
    frame.saucer.yaw = yaw;

    return usb_control_msg(handle, USB_VendorRequestCode | USB_ENDPOINT_OUT, PROTO_SAUCER, frame.usb.value, frame.usb.index, NULL, 0, TIMEOUT_MS);
}


void HC_Close(usb_dev_handle *handle)
{
    usb_release_interface(handle, 0);
    usb_close(handle);
}

---