Initial commit

.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+*.o
+protocol/proto

README.md

@@ -0,0 +1,24 @@
+# Mac OS X Gamepad Driver for Flysky compatible transmitters
+
+
+
+## Protocol Test Utility
+
+In the `protocol` subdirectory you can find a simple command-line app to test the proper decoding of the transmitters serial protocol.
+
+## Other Resources
+
+ * [Serial protocol analysis](http://www.rcgroups.com/forums/showpost.php?p=11384029&postcount=79)
+ * [T6config program informations](http://www.mycoolheli.com/t6config.html)
+ * [T6config alternatives](http://www.mycoolheli.com/t6Alternate.html)
+ * [Mac OS X version](http://www.zenoshrdlu.com/turborix/)
+
+## Licensing
+
+    ----------------------------------------------------------------------------
+    "THE BEER-WARE LICENSE" (Revision 42):
+    <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+    you can do whatever you want with this stuff. If we meet some day, and you
+    think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+    ----------------------------------------------------------------------------
+

protocol/Makefile

@@ -0,0 +1,10 @@
+# Copyright 2015 Thomas Buck <xythobuz@xythobuz.de>
+
+all: proto
+
+proto: serial.o main.o
+	$(CC) -o proto serial.o main.o
+
+clean:
+	rm -rf proto main.o serial.o
+

protocol/main.c

@@ -0,0 +1,142 @@
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+
+#include "serial.h"
+
+#define BAUDRATE 115200
+#define PACKETSIZE 18
+#define HEADERBYTES 2
+#define HEADERBYTE_A 85
+#define HEADERBYTE_B 252
+#define CHECKSUMBYTES 2
+#define PAYLOADBYTES (PACKETSIZE - HEADERBYTES - CHECKSUMBYTES)
+#define CHANNELS 6
+
+/*
+#define TESTCHANNEL 2
+#define TESTCHANNELVALUE 2044
+*/
+
+static int running = 1;
+static int firstPrint = 0;
+static int extraLine = 0;
+
+static void signalHandler(int signo) {
+    running = 0;
+}
+
+int main(int argc, char* argv[]) {
+    if (argc != 2) {
+        printf("Usage:\n\t%s /dev/serial_port\n", argv[0]);
+        return 1;
+    }
+
+    if (signal(SIGINT, signalHandler) == SIG_ERR) {
+        perror("Couldn't register signal handler");
+        return 1;
+    }
+
+    int fd = serialOpen(argv[1], BAUDRATE);
+    if (fd == -1) {
+        return 1;
+    }
+
+    while (running != 0) {
+        if (serialHasChar(fd)) {
+            unsigned char c1;
+            serialReadChar(fd, (char*)&c1);
+            if (c1 == HEADERBYTE_A) {
+                // Found first byte of protocol start
+                while (!serialHasChar(fd)) {
+                    if (running == 0) {
+                        serialClose(fd);
+                        return 0;
+                    }
+                }
+
+                unsigned char c2;
+                serialReadChar(fd, (char*)&c2);
+                if (c2 == HEADERBYTE_B) {
+                    // Protocol start has been found, read payload
+                    unsigned char data[PAYLOADBYTES];
+                    int read = 0;
+                    while ((read < PAYLOADBYTES) && (running != 0)) {
+                        read += serialReadRaw(fd, (char*)data + read, PAYLOADBYTES - read);
+                    }
+
+                    // Read 16bit checksum
+                    unsigned char checksumData[CHECKSUMBYTES];
+                    read = 0;
+                    while ((read < CHECKSUMBYTES) && (running != 0)) {
+                        read += serialReadRaw(fd, (char*)checksumData + read,
+                                              CHECKSUMBYTES - read);
+                    }
+
+                    // Check if checksum matches
+                    uint16_t checksum = 0;
+                    for (int i = 0; i < PAYLOADBYTES; i++) {
+                        checksum += data[i];
+                    }
+
+                    if (checksum != ((checksumData[0] << 8) | checksumData[1])) {
+                        printf("Wrong checksum: %d != %d                    \n",
+                               checksum, ((checksumData[0] << 8) | checksumData[1]));
+                        extraLine++;
+                        if (extraLine > 1) {
+                            extraLine--;
+                            printf("\r\033[1A");
+                        }
+                    } else {
+                        // Decode channel values
+                        uint16_t buff[CHANNELS + 1];
+                        for (int i = 0; i < (CHANNELS + 1); i++) {
+                            buff[i] = data[2 * i] << 8;
+                            buff[i] |= data[(2 * i) + 1];
+                        }
+
+                        /*
+                        // Check Test Channel Value (?)
+                        if (buff[CHANNELS] != (TESTCHANNELVALUE - buff[TESTCHANNEL])) {
+                            printf("Wrong test channel value: %d != %d (%d - %d)\n",
+                                   buff[CHANNELS], TESTCHANNELVALUE - buff[TESTCHANNEL],
+                                   TESTCHANNELVALUE, buff[TESTCHANNEL]);
+
+                            printf("Correct would be: %d\n",
+                                   buff[TESTCHANNEL] + buff[CHANNELS]);
+                        }
+                        */
+
+                        if (firstPrint == 0) {
+                            firstPrint = 1;
+                        } else {
+                            int num = CHANNELS + extraLine;
+                            extraLine = 0;
+                            for (int i = 0; i < num; i++) {
+                                printf("\r\033[1A");
+                            }
+                        }
+
+                        for (int i = 0; i < CHANNELS; i++) {
+                            printf("CH%d: %d                    \n", i + 1, buff[i] - 1000);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    serialClose(fd);
+
+    return 0;
+}
+

protocol/serial.c

@@ -0,0 +1,245 @@
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <dirent.h>
+#include <errno.h>
+#include <time.h>
+#include <poll.h>
+
+#include "serial.h"
+
+#ifndef XON
+#define XON 0x11
+#endif
+
+#ifndef XOFF
+#define XOFF 0x13
+#endif
+
+#ifndef TIMEOUT
+#define TIMEOUT 2
+#endif
+
+int serialOpen(const char *port, unsigned int baud) {
+    struct termios options;
+
+    int fd = open(port, O_RDWR | O_NOCTTY | O_NDELAY);
+    if (fd == -1) {
+        fprintf(stderr, "Couldn't open port \"%s\": %s\n", port, strerror(errno));
+        return -1;
+    }
+
+    tcgetattr(fd, &options);
+
+    options.c_lflag = 0;
+    options.c_oflag = 0;
+    options.c_iflag = 0;
+
+    // Set Baudrate
+    switch (baud) {
+        case 9600:
+            cfsetispeed(&options, B9600);
+            cfsetospeed(&options, B9600);
+            break;
+        case 19200:
+            cfsetispeed(&options, B19200);
+            cfsetospeed(&options, B19200);
+            break;
+        case 38400:
+            cfsetispeed(&options, B38400);
+            cfsetospeed(&options, B38400);
+            break;
+        case 76800:
+            cfsetispeed(&options, B76800);
+            cfsetospeed(&options, B76800);
+            break;
+        case 115200:
+            cfsetispeed(&options, B115200);
+            cfsetospeed(&options, B115200);
+            break;
+        default:
+            fprintf(stderr, "Warning: Baudrate not supported!\n");
+            serialClose(fd);
+            return -1;
+    }
+
+    // Input Modes
+    options.c_iflag |= IGNCR; // Ignore CR
+#ifdef XONXOFF
+    options.c_iflag |= IXON; // XON-XOFF Flow Control
+#endif
+
+    // Output Modes
+    options.c_oflag |= OPOST; // Post-process output
+
+    // Control Modes
+    options.c_cflag |= CS8; // 8 data bits
+    options.c_cflag |= CREAD; // Enable Receiver
+    options.c_cflag |= CLOCAL; // Ignore modem status lines
+
+    // Local Modes
+    options.c_lflag |= IEXTEN; // Extended input character processing
+
+    // Special characters
+    options.c_cc[VMIN] = 0; // Always return...
+    options.c_cc[VTIME] = 0; // ..immediately from read()
+#ifdef XONXOFF
+    options.c_cc[VSTOP] = XOFF;
+    options.c_cc[VSTART] = XON;
+#endif
+
+    tcsetattr(fd, TCSANOW, &options);
+
+    tcflush(fd, TCIOFLUSH);
+
+    return fd;
+}
+
+void serialClose(int fd) {
+    tcflush(fd, TCIOFLUSH);
+    close(fd);
+}
+
+int serialHasChar(int fd) {
+    struct pollfd fds;
+    fds.fd = fd;
+    fds.events = (POLLIN | POLLPRI); // Data may be read
+    if (poll(&fds, 1, 0) > 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+void serialWaitUntilSent(int fd) {
+    while (tcdrain(fd) == -1) {
+        fprintf(stderr, "Could not drain data: %s\n", strerror(errno));
+    }
+}
+
+unsigned int serialWriteRaw(int fd, const char *d, int len) {
+    unsigned int processed = 0;
+    time_t start = time(NULL);
+
+    while ((processed < len) && (difftime(time(NULL), start) < TIMEOUT)) {
+        int t = write(fd, (d + processed), (len - processed));
+        if (t == -1) {
+            fprintf(stderr, "Error while writing: %s\n", strerror(errno));
+            return processed;
+        } else {
+            processed += t;
+        }
+    }
+
+    return processed;
+}
+
+unsigned int serialReadRaw(int fd, char *d, int len) {
+    unsigned int processed = 0;
+    time_t start = time(NULL);
+
+    while ((processed < len) && (difftime(time(NULL), start) < TIMEOUT)) {
+        int t = read(fd, (d + processed), (len - processed));
+        if (t == -1) {
+            fprintf(stderr, "Error while reading: %s\n", strerror(errno));
+            return processed;
+        } else {
+            processed += t;
+        }
+    }
+
+    return processed;
+}
+
+void serialWriteChar(int fd, char c) {
+    while (serialWriteRaw(fd, &c, 1) != 1);
+}
+
+void serialReadChar(int fd, char *c) {
+    while (serialReadRaw(fd, c, 1) != 1);
+#ifdef XONXOFF
+    if (*c == XON) {
+        if (tcflow(fd, TCOON) == -1) {
+            fprintf(stderr, "Could not restart flow: %s\n", strerror(errno));
+        }
+        serialReadChar(fd, c);
+    } else if (*c == XOFF) {
+        if (tcflow(fd, TCOOFF) == -1) {
+            fprintf(stderr, "Could not stop flow: %s\n", strerror(errno));
+        }
+        serialReadChar(fd, c);
+    }
+#endif
+}
+
+void serialWriteString(int fd, const char *s) {
+    while (*s)
+        serialWriteChar(fd, *(s++));
+}
+
+char** getSerialPorts(void) {
+    DIR *dir;
+    struct dirent *ent;
+
+    int size = 0;
+    dir = opendir("/dev/");
+    while ((ent = readdir(dir)) != NULL) {
+#ifdef SEARCH
+        if (strstr(ent->d_name, SEARCH) != NULL)
+#endif
+        size++;
+    }
+    closedir(dir);
+
+    char **files = (char **)malloc((size + 1) * sizeof(char *));
+
+    int i = 0;
+    dir = opendir("/dev/");
+    while (((ent = readdir(dir)) != NULL) && (i < size)) {
+
+#ifdef SEARCH
+        if (strstr(ent->d_name, SEARCH) != NULL) {
+#endif
+
+            int tmp = strlen(ent->d_name) + 6;
+            files[i] = (char *)malloc(tmp * sizeof(char));
+            strcpy(files[i], "/dev/");
+            strcpy(files[i] + 5, ent->d_name);
+            files[i][tmp - 1] = '\0';
+
+#ifdef TRY_TO_OPEN_PORTS
+            int fdtmp = serialOpen(files[i], 9600);
+            if (fdtmp != -1) {
+                serialClose(fdtmp);
+#endif
+
+                i++;
+
+#ifdef TRY_TO_OPEN_PORTS
+            } else {
+                free(files[i]);
+            }
+#endif
+
+#ifdef SEARCH
+        }
+#endif
+
+    }
+    closedir(dir);
+    files[i] = NULL;
+    return files;
+}
+

protocol/serial.h

@@ -0,0 +1,144 @@
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+ * you can do whatever you want with this stuff. If we meet some day, and you
+ * think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+ * ----------------------------------------------------------------------------
+ */
+
+#ifndef _SERIAL_H_
+#define _SERIAL_H_
+
+/*
+ * Configuration
+ */
+
+/*!
+ * \brief Enable XON/XOFF flow control.
+ *
+ * If you uncomment this definition, the serial port code will
+ * stop sending when a XOFF was received, and start again upon
+ * receiving XON. However, you need to use the blocking
+ * read/write functions!
+ */
+//#define XONXOFF
+#define XON 0x11  //!< XON flow control character
+#define XOFF 0x13 //!< XOFF flow control character
+
+/*!
+ * \brief Search term to filter the list of available ports.
+ *
+ * If you define SEARCH, instead of simply returning a list of
+ * files in /dev/, getSerialPorts() will only return items that
+ * contain the string defined to SEARCH.
+ */
+#define SEARCH "tty"
+
+/*!
+ * \brief Only list real serial ports.
+ *
+ * If you uncomment this definition, getSerialPorts() will try to
+ * open every port, only returning the name if it is a real serial
+ * port. This could cause a big delay, if eg. your system tries to
+ * open non-existing bluetooth devices, waiting for their timeout.
+ * Also, if your console tty is probed, it might change it's settings.
+ */
+//#define TRY_TO_OPEN_PORTS
+
+/*!
+ * \brief The timeout in seconds for raw reading/writing.
+ *
+ * If this amount of time passes without being able to write/read
+ * a character, the raw I/O functions will return 0.
+ */
+#define TIMEOUT 2
+
+/*
+ * Setup
+ */
+
+/*!
+ * \brief open a serial port
+ * \param port name of port
+ * \param baud baudrate
+ * \returns file handle or -1 on error
+ */
+int serialOpen(const char *port, unsigned int baud);
+
+/*!
+ * \brief close an open serial port
+ * \param fd file handle of port to close
+ */
+void serialClose(int fd);
+
+/*!
+ * \brief query available serial ports
+ * \returns string array with serial port names.
+ * Last element is NULL. Don't forget to free()
+ * after using it!
+ */
+char **getSerialPorts(void);
+
+/*
+ * Raw, non-blocking I/O
+ */
+
+/*!
+ * \brief read from an open serial port
+ * \param fd file handle of port to read from
+ * \param data buffer big enough to fit all read data
+ * \param length maximum number of bytes to read
+ * \returns number of bytes really read
+ */
+unsigned int serialReadRaw(int fd, char *data, int length);
+
+/*!
+ * \brief write to an open serial port
+ * \param fd file handle of port to write to
+ * \param data buffer containing data to write
+ * \param length number of bytes to write
+ * \returns number of bytes really written
+ */
+unsigned int serialWriteRaw(int fd, const char *data, int length);
+
+/*!
+ * \brief wait until data is sent
+ * \param fd file handle of port to wait for
+ */
+void serialWaitUntilSent(int fd);
+
+/*
+ * Blocking I/O
+ */
+
+/*!
+ * \brief check if a character has arrived and can be read
+ * \param fd file handle of port to check
+ * \returns 1 if a character is available, 0 if not
+ */
+int serialHasChar(int fd);
+
+/*!
+ * \brief read a single character
+ * \param fd file handle of port to read from
+ * \param c where read character will be stored
+ */
+void serialReadChar(int fd, char *c);
+
+/*!
+ * \brief write a single character
+ * \param fd file handle to write to
+ * \param c character to write
+ */
+void serialWriteChar(int fd, char c);
+
+/*!
+ * \brief write a string
+ * \param fd file handle to write to
+ * \param s C string to be written
+ */
+void serialWriteString(int fd, const char *s);
+
+#endif
+