first commit

autowp · autowp · commit 5b08605ee76c · 2016-03-13T13:12:33.000+03:00
diff --git a/CanHacker.cpp b/CanHacker.cpp
diff --git a/CanHacker.h b/CanHacker.h
@@ -0,0 +1,130 @@
+#include <can.h>
+#include <mcp_can.h>
+
+/*
+ * CanHacker.h
+ *
+ *  Created on: 17 ���. 2015 �.
+ *      Author: Dmitry
+ */
+
+#ifndef CANHACKER_H_
+#define CANHACKER_H_
+
+#include <can.h>
+
+#define CAN_MIN_DLEN 1
+#define HEX_PER_BYTE 2
+#define MIN_MESSAGE_DATA_HEX_LENGTH CAN_MIN_DLEN * HEX_PER_BYTE
+#define MAX_MESSAGE_DATA_HEX_LENGTH CAN_MAX_DLEN * HEX_PER_BYTE
+#define MIN_MESSAGE_LENGTH 5
+
+#define CANHACKER_CMD_MAX_LENGTH 26
+
+#define CANHACKER_SERIAL_RESPONSE     "N0001\r"
+#define CANHACKER_SW_VERSION_RESPONSE "v0107\r"
+#define CANHACKER_VERSION_RESPONSE    "V1010\r"
+
+class CanHacker {
+    public:
+        enum ERROR { 
+            ERROR_OK, 
+            ERROR_CONNECTED, 
+            ERROR_NOT_CONNECTED, 
+            ERROR_UNKNOWN_COMMAND,
+            ERROR_INVALID_COMMAND,
+            ERROR_ERROR_FRAME_NOT_SUPPORTED,
+            ERROR_BUFFER_OVERFLOW,
+            ERROR_SERIAL_TX_OVERRUN,
+            ERROR_LISTEN_ONLY,
+            ERROR_MCP2515_INIT,
+            ERROR_MCP2515_INIT_CONFIG,
+            ERROR_MCP2515_INIT_BITRATE,
+            ERROR_MCP2515_INIT_SET_MODE,
+            ERROR_MCP2515_SEND,
+            ERROR_MCP2515_READ,
+            ERROR_MCP2515_FILTER,
+            ERROR_MCP2515_ERRIF,
+            ERROR_MCP2515_MERRF
+        };
+
+        CanHacker(Stream *stream, Stream *debugStream, uint8_t cs);
+        ~CanHacker();
+        ERROR receiveCommand(const char *buffer, const int length);
+        ERROR receiveCanFrame(const struct can_frame *frame);
+        ERROR sendFrame(const struct can_frame *);
+        ERROR setLoopbackEnabled(const bool value);
+        ERROR pollReceiveCan();
+        ERROR receiveCan(const MCP_CAN::RXBn rxBuffer);
+        MCP_CAN *getMcp2515();
+        ERROR processInterrupt();
+        Stream *getInterfaceStream();
+
+    private:
+
+        static const char CR  = '\r';
+        static const char BEL = 7;
+        static const uint16_t TIMESTAMP_LIMIT = 0xEA60;
+
+        bool _timestampEnabled = false;
+        bool _listenOnly = false;
+        bool _loopback = false;
+        uint8_t _cs;
+        MCP_CAN *mcp2515;
+        CAN_SPEED bitrate;
+        bool _isConnected = false;
+        Stream *_stream;
+        Stream *_debugStream;
+    
+        enum /*class*/ COMMAND : char {
+            COMMAND_SET_BITRATE    = 'S', // set CAN bit rate
+            COMMAND_SET_BTR        = 's', // set CAN bit rate via
+            COMMAND_OPEN_CAN_CHAN  = 'O', // open CAN channel
+            COMMAND_CLOSE_CAN_CHAN = 'C', // close CAN channel
+            COMMAND_SEND_11BIT_ID  = 't', // send CAN message with 11bit ID
+            COMMAND_SEND_29BIT_ID  = 'T', // send CAN message with 29bit ID
+            COMMAND_SEND_R11BIT_ID = 'r', // send CAN remote message with 11bit ID
+            COMMAND_SEND_R29BIT_ID = 'R', // send CAN remote message with 29bit ID
+            COMMAND_READ_STATUS    = 'F', // read status flag byte
+            COMMAND_SET_ACR        = 'M', // set Acceptance Code Register
+            COMMAND_SET_AMR        = 'm', // set Acceptance Mask Register
+            COMMAND_GET_VERSION    = 'V', // get hardware and software version
+            COMMAND_GET_SW_VERSION = 'v', // get software version only
+            COMMAND_GET_SERIAL     = 'N', // get device serial number
+            COMMAND_TIME_STAMP     = 'Z', // toggle time stamp setting
+            COMMAND_READ_ECR       = 'E', // read Error Capture Register
+            COMMAND_READ_ALCR      = 'A', // read Arbritation Lost Capture Register
+            COMMAND_READ_REG       = 'G', // read register conten from SJA1000
+            COMMAND_WRITE_REG      = 'W', // write register content to SJA1000
+            COMMAND_LISTEN_ONLY    = 'L'  // switch to listen only mode
+        };
+    
+        ERROR parseTransmit(const char *buffer, int length, struct can_frame *frame);
+        ERROR createTransmit(const struct can_frame *frame, char *buffer, const int length);
+        
+        uint16_t getTimestamp();
+        ERROR setFilter(const uint32_t filter);
+        ERROR setFilterMask(const uint32_t mask);
+
+        ERROR connectCan();
+        ERROR disconnectCan();
+        bool isConnected();
+        ERROR writeCan(const struct can_frame *);
+        ERROR writeStream(const char character);
+        ERROR writeStream(const char *buffer);
+        ERROR writeDebugStream(const char character);
+        ERROR writeDebugStream(const char *buffer);
+        ERROR writeDebugStream(const int buffer);
+        ERROR writeDebugStream(const uint8_t *buffer, size_t size);
+        
+        ERROR receiveSetBitrateCommand(const char *buffer, const int length);
+        ERROR receiveTransmitCommand(const char *buffer, const int length);
+        ERROR receiveTimestampCommand(const char *buffer, const int length);
+        ERROR receiveCloseCommand(const char *buffer, const int length);
+        ERROR receiveOpenCommand(const char *buffer, const int length);
+        ERROR receiveListenOnlyCommand(const char *buffer, const int length);
+        ERROR receiveSetAcrCommand(const char *buffer, const int length);
+        ERROR receiveSetAmrCommand(const char *buffer, const int length);
+};
+
+#endif /* CANHACKER_H_ */
diff --git a/CanHackerLineReader.cpp b/CanHackerLineReader.cpp
@@ -0,0 +1,49 @@
+#include "CanHackerLineReader.h"
+
+CanHackerLineReader::CanHackerLineReader(CanHacker *vCanHacker) {
+    _canHacker = vCanHacker;
+    index = 0;
+    memset(buffer, 0, sizeof(buffer));
+}
+
+CanHacker::ERROR CanHackerLineReader::processChar(char rxChar) {
+    switch (rxChar) {
+        case '\r':
+        case '\n':
+            if (index > 0) {
+                buffer[index] = '\0';
+            
+                CanHacker::ERROR error = _canHacker->receiveCommand(buffer, index);
+                index = 0;
+                if (error != CanHacker::ERROR_OK) {
+                    return error;
+                }
+            }
+            break;
+  
+        case '\0':
+            break;
+  
+        default:
+            if (index < COMMAND_MAX_LENGTH) {
+                buffer[index++] = rxChar;
+            } else {
+                index = 0;
+                return CanHacker::ERROR_INVALID_COMMAND;
+            }
+            break;
+    }
+    return CanHacker::ERROR_OK;
+}
+
+CanHacker::ERROR CanHackerLineReader::process() {
+    Stream *stream = _canHacker->getInterfaceStream();
+    while (stream->available()) {
+        CanHacker::ERROR error = processChar(stream->read());
+        if (error != CanHacker::ERROR_OK) {
+            return error;
+        }
+    }
+    
+    return CanHacker::ERROR_OK;
+}
diff --git a/CanHackerLineReader.h b/CanHackerLineReader.h
@@ -0,0 +1,20 @@
+#ifndef CANHACKERLINEREADER_H_
+#define CANHACKERLINEREADER_H_
+
+#include "CanHacker.h"
+
+class CanHackerLineReader {
+    private:
+        static const int COMMAND_MAX_LENGTH = 30; // not including \r\0
+        
+        CanHacker *_canHacker;
+        char buffer[COMMAND_MAX_LENGTH + 2];
+        int index;
+        Stream *_stream;
+    public:
+        CanHackerLineReader(CanHacker *vCanHacker);
+        CanHacker::ERROR processChar(char rxChar);
+        CanHacker::ERROR process();
+};
+
+#endif /* CANHACKERLINEREADER_H_ */
diff --git a/LICENSE.md b/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Dmitry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
@@ -0,0 +1,6 @@
+# CanHacker (lawicel) CAN adapter on Arduino + MCP2515
+
+Use that [Library](https://github.com/autowp/CAN_BUS_Shield) to communicate with MCP2515
+
+Testes with Arduino Nano.
+On Arduino Uno have problem with too long boot period and losing first command
diff --git a/lib.cpp b/lib.cpp
@@ -0,0 +1,27 @@
+#include "lib.h"
+
+unsigned char hexCharToByte(char hex)
+{
+    unsigned char result = 0;
+    if (hex >= 0x30 && hex <= 0x39) {
+        result = hex - 0x30;
+    } else if (hex >= 0x41 && hex <= 0x46) {
+        result = hex - 0x41 + 0x0A;
+    } else if (hex >= 0x61 && hex <= 0x66) {
+        result = hex - 0x61 + 0x0A;
+    }
+    return result;
+}
+
+uint8_t ascii2byte (uint8_t *val) {
+    uint8_t temp = *val;
+    if (temp > 0x60) temp -= 0x27;                // convert chars a-f
+    else if (temp > 0x40) temp -= 0x07;           // convert chars A-F
+    temp -= 0x30;                                 // convert chars 0-9
+    return temp & 0x0F;
+}
+
+uint8_t nibble2ascii(uint8_t nibble) {
+    uint8_t tmp = nibble & 0x0f;
+    return tmp < 10 ? tmp + 48 : tmp + 55;
+}
diff --git a/lib.h b/lib.h
@@ -0,0 +1,12 @@
+#ifndef LIB_H_
+#define LIB_H_
+
+#include <stdint.h>
+
+unsigned char hexCharToByte(char hex);
+
+uint8_t ascii2byte (uint8_t * val);
+
+uint8_t nibble2ascii(uint8_t nibble);
+
+#endif /* LIB_H_ */
