src: can-lin: initial source import

This patch adds the sources needed for the HVAC and iDrive applications.

Change-Id: I53148a5d11c34787dd11295939bbaf8702c64dcb
Signed-off-by: Christian Gromm <christian.gromm@microchip.com>

1 files changed, 506 insertions, 0 deletions

diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..1f0a0cd
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,506 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <linux/can.h>
+#include <linux/can/raw.h>
+#include <vector>
+
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <pthread.h>
+
+#include <linux/input.h>
+#include <linux/uinput.h>
+
+#include "abi-ipc.h"
+#include "ABICommands.h"
+
+#define DEFAULT_ABI_RX_DEVICE 	"/dev/mocca0"
+#define DEFAULT_ABI_TX_DEVICE 	"/dev/mocca0"
+#define UINPUT_DEVICE	 	"/dev/uinput"
+
+using namespace K2L::Automotive::ABI_IPC;
+using namespace K2L::Automotive::ABI;
+
+#include "HVAC_Bin_jitter10.c"
+
+class AbiMainHandler : public CABIListener
+{
+private:
+    AbiUsbIpc *abiIpc;
+    IABI *abi;
+    bool isConnected;
+    unsigned int connectionLabel;
+    Bus canBuses[6] = { CAN1, CAN2, CAN3, CAN4, CAN5, CAN6};
+    Bus xcanBuses[6] = { XCAN1, XCAN2, XCAN3, XCAN4, XCAN5, XCAN6};
+    Bus linBuses[6] = { LIN1, LIN2, LIN3, LIN4, LIN5, LIN6};
+    int busCount = 6;
+    int socketId = -1;
+    struct can_frame txCanFrame;
+    struct sockaddr_can addr;
+    struct ifreq ifr;
+
+    pthread_t receivingThread;
+    pthread_t sendingThread;
+    BYTE busToSend = 0xFF;
+
+    pthread_mutex_t mutex;
+    BYTE currentState[8];
+    BYTE nextState[8];
+    bool sendNextState = false;
+
+	int uinputFileDescriptor = -1;
+    
+    virtual void OnCanRxMessage(IABI* pAbi, void* pContext, unsigned long long timeStamp, Bus bus, unsigned int messageId, bool extended, BYTE* payload, int payloadLength)
+    {
+        if (messageId == 0x25B && payloadLength >= 8)
+        {
+            if (payload[6] & 0x01)
+            {
+                printf("MEDIA\n");
+                SendKey(KEY_MEDIA);
+            }
+            if (payload[7] & 0x01)
+            {
+                printf("MAP\n");
+                SendKey(KEY_FN_F11);
+            }
+            if (payload[5] & 0x08)
+            {
+                printf("COM\n");
+                SendKey(KEY_PHONE);
+            }
+            if (payload[6] & 0x08)
+            {
+                printf("NAV\n");
+                SendKey(KEY_FN_F12);
+            }
+            if (payload[4] & 0x20)
+            {
+                printf("BACK\n");
+                SendKey(KEY_BACK);
+            }
+            if (payload[5] & 0x01)
+            {
+                printf("OPTION\n");
+                SendKey(KEY_OPTION);
+            }
+            if (payload[3] & 0x01)
+            {
+                printf("iDRIVE (ENTER)\n");
+                SendKey(KEY_ENTER);
+            }
+            uint8_t code = (payload[3] >> 4);
+            if (code == 1)
+            {
+                printf("iDRIVE (UP)\n");
+                SendKey(KEY_UP);
+            }
+            if (code == 7)
+            {
+                printf("iDRIVE (DOWN)\n");
+                SendKey(KEY_DOWN);
+            }
+            if (code == 0xA)
+            {
+                printf("iDRIVE (LEFT)\n");
+                SendKey(KEY_LEFT);
+            }
+            if (code == 0x4)
+            {
+                printf("iDRIVE (RIGHT)\n");
+                SendKey(KEY_RIGHT);
+            }
+        }
+        else
+        {
+            if (CAN1 <= bus && bus <= CAN6)
+            {
+                printf("CAN%i: RX %04X Std", bus - CAN1 + 1, messageId, payloadLength);
+            }
+            if (XCAN1 <= bus && bus <= XCAN6)
+            {
+                printf("CAN%i: RX %04X Ext", bus - XCAN1 + 1, messageId, payloadLength);
+            }
+            printf(":");
+            for(int i = 0; i < payloadLength; i++)
+            {
+                printf(" %2X", payload[i]);
+            }
+            printf("\n");
+        }
+    }
+
+    void SendKey(unsigned int code)
+    {
+        if(this->uinputFileDescriptor < 0)
+        {
+            return;
+        }
+
+        struct input_event ev;
+
+        memset(&ev, 0, sizeof(ev));
+
+        ev.type = EV_KEY;
+        ev.code = code;
+        ev.value = 1;
+
+        if (write(this->uinputFileDescriptor, &ev, sizeof(ev)) >= 0)
+        {
+            printf("Key: %X\n", code);
+        }
+    }
+
+    virtual void OnLinRxMessage(IABI* pAbi, void* pContext, unsigned long long timeStamp, Bus bus, unsigned int sourceAddress,
+                                unsigned int messageId, BYTE* payload, int payloadLength)
+    {
+        if (LIN1 <= bus && bus <= LIN6)
+        {
+            printf("LIN%i: RX %02X ", bus - LIN1 + 1, messageId, payloadLength);
+        }
+        printf(":");
+        for(int i = 0; i < payloadLength; i++)
+        {
+            printf(" %2X", payload[i]);
+        }
+        printf("\n");
+        if (this->busToSend == 0xFF)
+        {
+            this->busToSend = bus - LIN1 + 1;
+            printf("Selected bus LIN%i\n", this->busToSend);
+        }
+
+        if (messageId == 0x2D)
+        {
+            // StatusAfterCalibration
+            CheckResult("Identify", CABICommands::Identify(abi));
+            unsigned long long result;
+            CheckResult("Relay", CABICommands::SetRelay( abi, false, result));
+        }
+        if (messageId == 0x31 && payloadLength >= 8)
+        {
+            // Status
+            if (pthread_mutex_lock(&mutex) == 0)
+            {
+                printf("Save state");
+                for(int i = 0; i < payloadLength; i++)
+                {
+                    printf(" %2X", payload[i]);
+                }
+                printf("...\n");
+                memcpy(currentState, payload, 8);
+                if (memcmp(currentState, nextState, 8) == 0)
+                {
+                    sendNextState = false;
+                }
+                else if (sendNextState)
+                {
+                    printf("Next state is ready to send...\n" );
+                    struct can_frame frame;
+                    frame.can_id = 0x01;
+                    frame.can_dlc = 8;
+                    memcpy(&frame.data, this->nextState, 8);
+                    sendto(socketId, &frame, sizeof(struct can_frame), 0, (struct sockaddr*)&addr, sizeof(addr));
+                }
+                pthread_mutex_unlock(&mutex);
+            }
+        }
+    }
+
+    static void *ReceiveThread( void *param )
+    {
+        if( NULL == param )
+        {
+            printf("ERROR: Virtual CAN receiving thread could not be started\n" );
+            pthread_exit( 0 );
+        }
+        AbiMainHandler *that = ( AbiMainHandler * )param;
+
+        printf("Virtual CAN receiving thread started...\n" );
+        int nbytes = 0;
+        struct can_frame frame;
+        while( that->isConnected )
+        {
+            nbytes = read(that->socketId, &frame, sizeof(struct can_frame));
+            if (nbytes < 0)
+            {
+                printf("ERROR: could not read CAN frame");
+            }
+
+            if (frame.can_id == 0x01 && frame.can_dlc >= 8)
+            {
+                printf("");
+                printf("Send next state LIN%i: ", that->busToSend);
+                for(int i = 0; i < 8; i++)
+                {
+                    printf(" %2X", that->nextState[i]);
+                }
+                printf("...\n");
+                CheckResult("Send", CABICommands::SendLINMessage(that->abi, 150, that->busToSend, 0x30, frame.can_dlc, frame.data));
+                if (pthread_mutex_lock(&(that->mutex)) == 0)
+                {
+                    memcpy(that->nextState, frame.data, 8);
+                    that->sendNextState = true;
+                    pthread_mutex_unlock(&(that->mutex));
+                }
+                continue;
+            }
+
+            printf("Virtual CAN: message received %x: ", frame.can_id );
+            for(int i = 0; i < frame.can_dlc; i++)
+            {
+                printf(" %2X", frame.data[i]);
+            }
+            printf("\n");
+
+            bool send = false;
+            if (frame.can_dlc >= 8 && pthread_mutex_lock(&(that->mutex)) == 0)
+            {
+                if (that->sendNextState)
+                {
+                    printf("Save next state...\n");
+                    memcpy(that->nextState, frame.data, 8);
+                }
+                else
+                {
+                    send = true;
+                    memcpy(that->nextState, frame.data, 8);
+                    that->sendNextState = true;
+                }
+                pthread_mutex_unlock(&(that->mutex));
+            }
+
+            if (send)
+            {
+                printf("Send new state...\n");
+                CheckResult("Send", CABICommands::SendLINMessage(that->abi, 151, that->busToSend, frame.can_id, frame.can_dlc, frame.data));
+            }
+        }
+        pthread_exit( 0 );
+    }
+
+    virtual void OnLinTxMessage(IABI* pAbi, void* pContext, unsigned long long timeStamp, unsigned short handle, Bus bus, unsigned int targetAddress,
+                                unsigned int messageId, BYTE* payload, int payloadLength)
+    {
+        if (LIN1 <= bus && bus <= LIN6)
+        {
+            printf("LIN%i: TX %02X ", bus - LIN1 + 1, messageId, payloadLength);
+        }
+        printf(":");
+        for(int i = 0; i < payloadLength; i++)
+        {
+            printf(" %2X", payload[i]);
+        }
+        printf("\n");
+
+        if (pthread_mutex_lock(&mutex) == 0)
+        {
+            memcpy(currentState, payload, 8);
+            pthread_mutex_unlock(&mutex);
+        }
+    }
+
+    static void CheckResult( const char *command, int result )
+    {
+        if( 0 == result )
+            printf( "Command '%s' succeeded\n", command );
+        else
+            printf( "Command '%s' failed, with error code: %d\n", command, result );
+    }
+
+    bool SetupAbiDevice()
+    {
+        //Lets the Active LED twinkle fast
+        CheckResult( "Identify", CABICommands::Identify( abi ) );
+        
+        CheckResult( "Delete all receivers", CABICommands::Delete( abi, 0 ) );
+        unsigned long long result;
+        CheckResult("Relay", CABICommands::SetRelay( abi, true, result));
+
+        for(int i = 0; i < busCount; i++)
+        {
+            CheckResult( "Start CAN", CABICommands::StartCan( abi, canBuses[i], canTransceiverFast, canSpeed500) );
+            
+            CheckResult( "Add CAN receiver", CABICommands::AddReceiver( abi, 100 + i, canBuses[i], 0x0, 0x7FF ) );
+            CheckResult( "Start CAN receiver", CABICommands::Start( abi, 100 + i ) );
+            
+            CheckResult( "Add extended CAN receiver", CABICommands::AddReceiver( abi, 110 + i, xcanBuses[i], 0x0, 0x1FFFFFFF ) );
+            CheckResult( "Start extended CAN receiver", CABICommands::Start( abi, 110 + i ) );
+        }
+        
+        for(int i = 0; i < busCount; i++)
+        {
+            CheckResult( "Start LIN", CABICommands::StartLin(abi, linBuses[i], sizeof(bin_data), (BYTE*)bin_data));
+
+            CheckResult( "Add LIN receiver", CABICommands::AddReceiver( abi, 120 + i, linBuses[i], 0xFF, 0 ) );
+            CheckResult( "Start LIN receiver", CABICommands::Start( abi, 120 + i ) );
+        }
+        
+        this->socketId = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+        if (this->socketId < 0)
+        {
+            printf("ERROR: socket could not be created\n");
+            return false;
+        }
+        
+        strcpy(ifr.ifr_name, "vcan0" );
+        if(ioctl(this->socketId, SIOCGIFINDEX, &ifr))
+        {
+            printf("ERROR: ioctl failed\n");
+            return false;
+        }
+        
+        addr.can_family = AF_CAN;
+        addr.can_ifindex = ifr.ifr_ifindex;
+
+        if (bind(this->socketId, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+        {
+            printf("ERROR: bind failed\n");
+            return false;
+        }
+
+        int recv_own_msgs = 1; /* 0 = disabled (default), 1 = enabled */
+        setsockopt(this->socketId, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS,
+                       &recv_own_msgs, sizeof(recv_own_msgs));
+        
+        return true;
+    }
+
+public:
+    AbiMainHandler() : isConnected( false ), connectionLabel( 0xFFFFFFFF )
+    {
+        abiIpc = new AbiUsbIpc();
+        abi = CABIFactory::CreateAbi();
+        pthread_mutex_init(&mutex, NULL);
+		this->uinputFileDescriptor = open(UINPUT_DEVICE, O_WRONLY | O_NONBLOCK);
+		if(this->uinputFileDescriptor < 0)
+		{
+            printf("ERROR: Cannot open UInput!\n");
+		}
+        else if(ioctl(this->uinputFileDescriptor, UI_SET_EVBIT, EV_KEY) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_MEDIA) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_PHONE) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_MENU) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_BACK) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_OPTION) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_FN_F11) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_FN_F12) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_SCROLLDOWN) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_SCROLLUP) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_UP) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_LEFT) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_RIGHT) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_DOWN) >= 0
+                && ioctl(this->uinputFileDescriptor, UI_SET_KEYBIT, KEY_ENTER) >= 0)
+		{
+            struct uinput_user_dev uidev;
+
+            memset(&uidev, 0, sizeof(uidev));
+
+            snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
+            uidev.id.bustype = BUS_USB;
+            uidev.id.vendor  = 0x1234;
+            uidev.id.product = 0xfedc;
+            uidev.id.version = 1;
+
+            if (write(this->uinputFileDescriptor, &uidev, sizeof(uidev)) >= 0
+                    && ioctl(this->uinputFileDescriptor, UI_DEV_CREATE) >= 0)
+            {
+                printf("UInput ready...\n");
+            }
+            else
+            {
+                printf("ERROR: cannot create UInput device...\n");
+            }
+		}
+        else
+        {
+            printf("ERROR: UInput failed!\n");
+        }
+    }
+
+    ~AbiMainHandler()
+    {
+        CheckResult( "Delete all receivers", CABICommands::Delete( abi, 0 ) );
+
+        for(int i = 0; i < busCount; i++)
+        {
+            CheckResult( "Stop LIN", CABICommands::StopLin(abi, linBuses[i]));
+        }
+        
+        if(this->socketId != -1)
+        {
+            close(this->socketId);
+            printf("Socket closed\n");
+        }
+
+		if(this->uinputFileDescriptor >= 0)
+		{
+            if (ioctl(this->uinputFileDescriptor, UI_DEV_DESTROY) >= 0)
+            {
+                printf("UInput device destroyed\n");
+            }
+			close(this->uinputFileDescriptor);
+            printf("UInput closed\n");
+		}
+    }
+
+    bool Connect( const char *cdevRx, const char *cdevTx )
+    {
+        if( isConnected )
+        {
+            isConnected = false;
+            abiIpc->Disconnect();
+        }
+        bool isSingleDevice = ( 0 == strcmp( cdevRx, cdevTx ) );
+        bool success = isSingleDevice ? abiIpc->Connect( cdevRx ) : abiIpc->Connect( cdevRx, cdevTx );
+        if( success )
+        {
+            int err = abi->Init( abiIpc );
+            if( 0 == err )
+            {
+                abi->Start( this );
+                isConnected = SetupAbiDevice();
+                if(  pthread_create( &this->receivingThread, NULL, ReceiveThread, this ) )
+                {
+                    printf( "Failed to create receive thread\n" );
+                    return false;
+                }
+            }
+        }
+
+        return isConnected;
+    }    
+};
+
+int main( int argc, char *argv[] )
+{
+    AbiMainHandler mainHandler;
+    bool success = mainHandler.Connect( DEFAULT_ABI_RX_DEVICE, DEFAULT_ABI_TX_DEVICE );
+    
+    if(success)
+    {
+        printf( "OptoLyzer MOCCA compact connected...\n");
+        printf("Press any key to finish...\n");
+        getchar();
+    }
+    else
+    {
+        printf( "ERROR: ABI could not started...\n", success );
+    }
+    
+    return 0;
+}
+
+