Separation Generator to a dedicated repo

Change-Id: Id94831651c3266861435272a6e36c7884bef2c45
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>

19 files changed, 0 insertions, 1397 deletions

diff --git a/CAN-binder/libs/isotp-c/.gitignore b/CAN-binder/libs/isotp-c/.gitignore
deleted file mode 100644
index 96a3694f..00000000
--- a/CAN-binder/libs/isotp-c/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-*.o
-.DS_Store
-*~
-*.bin
-*.gcno
-build
diff --git a/CAN-binder/libs/isotp-c/.travis.yml b/CAN-binder/libs/isotp-c/.travis.yml
deleted file mode 100644
index 31bfdeb3..00000000
--- a/CAN-binder/libs/isotp-c/.travis.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-language: c
-compiler:
-  - gcc
-script: make test
-before_install:
-    - git submodule update --init
-    - sudo apt-get update -qq
-    - sudo apt-get install check
diff --git a/CAN-binder/libs/isotp-c/CHANGELOG.mkd b/CAN-binder/libs/isotp-c/CHANGELOG.mkd
deleted file mode 100644
index e6fd5cc0..00000000
--- a/CAN-binder/libs/isotp-c/CHANGELOG.mkd
+++ /dev/null
@@ -1,10 +0,0 @@
-# ISO 15765-2 Support Library in C
-
-## v0.2
-
-* Add multi-frame support for diagnostic responses. An IsoTpMessage payload is
-  currently limited to 256 bytes.
-
-## v0.1
-
-* Initial release
diff --git a/CAN-binder/libs/isotp-c/CMakeLists.txt b/CAN-binder/libs/isotp-c/CMakeLists.txt
deleted file mode 100644
index fbb5161f..00000000
--- a/CAN-binder/libs/isotp-c/CMakeLists.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-###########################################################################
-# Copyright 2015, 2016, 2017 IoT.bzh
-#
-# author: Fulup Ar Foll <fulup@iot.bzh>
-# contrib: Romain Forlot <romain.forlot@iot.bzh>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-###########################################################################
-
-# Add target to project dependency list
-PROJECT_TARGET_ADD(isotp-c)
-
-	# Define project Target
-	add_library(${TARGET_NAME} STATIC 
-		src/isotp/isotp.c
-		src/isotp/receive.c
-		src/isotp/send.c)
-
-	# Binder exposes a unique public entry point
-	SET_TARGET_PROPERTIES(${TARGET_NAME} PROPERTIES
-		OUTPUT_NAME ${TARGET_NAME}
-	)
-
-	# Define target includes
-	TARGET_INCLUDE_DIRECTORIES(${TARGET_NAME}
-		PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src
-	)
-
-	# Library dependencies (include updates automatically)
-	TARGET_LINK_LIBRARIES(${TARGET_NAME}
-		bitfield-c
-		${link_libraries})
diff --git a/CAN-binder/libs/isotp-c/LICENSE b/CAN-binder/libs/isotp-c/LICENSE
deleted file mode 100644
index 330d61f4..00000000
--- a/CAN-binder/libs/isotp-c/LICENSE
+++ /dev/null
@@ -1,24 +0,0 @@
-Copyright (c) 2013 Ford Motor Company
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the <organization> nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/CAN-binder/libs/isotp-c/Makefile b/CAN-binder/libs/isotp-c/Makefile
deleted file mode 100644
index 90165ba6..00000000
--- a/CAN-binder/libs/isotp-c/Makefile
+++ /dev/null
@@ -1,56 +0,0 @@
-CC = gcc
-INCLUDES = -Isrc -Ideps/bitfield-c/src
-CFLAGS = $(INCLUDES) -c -Wall -Werror -g -ggdb -std=gnu99 -coverage
-LDFLAGS = -coverage
-LDLIBS = -lcheck -lm -lrt -lpthread
-
-TEST_DIR = tests
-TEST_OBJDIR = build
-
-# Guard against \r\n line endings only in Cygwin
-OSTYPE := $(shell uname)
-ifneq ($(OSTYPE),Darwin)
-	OSTYPE := $(shell uname -o)
-	ifeq ($(OSTYPE),Cygwin)
-		TEST_SET_OPTS = igncr
-	endif
-endif
-
-LIBS_PATH = deps
-SRC = $(wildcard src/**/*.c)
-SRC += $(wildcard deps/bitfield-c/src/**/*.c)
-OBJS = $(patsubst %,$(TEST_OBJDIR)/%,$(SRC:.c=.o))
-TEST_SRC = $(wildcard $(TEST_DIR)/test_*.c)
-TESTS=$(patsubst %.c,$(TEST_OBJDIR)/%.bin,$(TEST_SRC))
-TEST_SUPPORT_SRC = $(TEST_DIR)/common.c
-TEST_SUPPORT_OBJS = $(patsubst %,$(TEST_OBJDIR)/%,$(TEST_SUPPORT_SRC:.c=.o))
-
-all: $(OBJS)
-
-test: $(TESTS)
-	@set -o $(TEST_SET_OPTS) >/dev/null 2>&1
-	@export SHELLOPTS
-	@sh runtests.sh $(TEST_OBJDIR)/$(TEST_DIR)
-
-COVERAGE_INFO_FILENAME = coverage.info
-COVERAGE_INFO_PATH = $(TEST_OBJDIR)/$(COVERAGE_INFO_FILENAME)
-coverage:
-	@lcov --base-directory . --directory src --zerocounters -q
-	@make clean
-	@make test
-	@lcov --base-directory . --directory $(TEST_OBJDIR) -c -o $(TEST_OBJDIR)/coverage.info
-	@lcov --remove $(COVERAGE_INFO_PATH) "$(LIBS_PATH)/bitfield-c/*" -o $(COVERAGE_INFO_PATH)
-	@genhtml -o $(TEST_OBJDIR)/coverage -t "isotp-c test coverage" --num-spaces 4 $(COVERAGE_INFO_PATH)
-	@$(BROWSER) $(TEST_OBJDIR)/coverage/index.html
-	@echo "$(GREEN)Coverage information generated in $(TEST_OBJDIR)/coverage/index.html.$(COLOR_RESET)"
-
-$(TEST_OBJDIR)/%.o: %.c
-	@mkdir -p $(dir $@)
-	$(CC) $(CFLAGS) $(CC_SYMBOLS) $(INCLUDES) -o $@ $<
-
-$(TEST_OBJDIR)/%.bin: $(TEST_OBJDIR)/%.o $(OBJS) $(TEST_SUPPORT_OBJS)
-	@mkdir -p $(dir $@)
-	$(CC) $(LDFLAGS) $(CC_SYMBOLS) $(INCLUDES) -o $@ $^ $(LDLIBS)
-
-clean:
-	rm -rf $(TEST_OBJDIR)
diff --git a/CAN-binder/libs/isotp-c/README.mkd b/CAN-binder/libs/isotp-c/README.mkd
deleted file mode 100644
index 98030483..00000000
--- a/CAN-binder/libs/isotp-c/README.mkd
+++ /dev/null
@@ -1,142 +0,0 @@
-ISO-TP (ISO 15765-2) Support Library in C
-================================
-
-This is a platform agnostic C library that implements the ISO 15765-2 (also
-known as ISO-TP) protocol, which runs over a CAN bus. Quoting Wikipedia:
-
->ISO 15765-2, or ISO-TP, is an international standard for sending data packets
->over a CAN-Bus. The protocol allows for the transport of messages that exceed
->the eight byte maximum payload of CAN frames. ISO-TP segments longer messages
->into multiple frames, adding metadata that allows the interpretation of
->individual frames and reassembly into a complete message packet by the
->recipient. It can carry up to 4095 bytes of payload per message packet.
-
-This library doesn't assume anything about the source of the ISO-TP messages or
-the underlying interface to CAN. It uses dependency injection to give you
-complete control.
-
-The current version supports *only single frame ISO-TP messages*. This is fine
-for OBD-II diagnostic messages, for example, but this library needs some
-additional work before it can support sending larger messages.
-
-## Usage
-
-First, create some shim functions to let this library use your lower level
-system:
-
-    // required, this must send a single CAN message with the given arbitration
-    // ID (i.e. the CAN message ID) and data. The size will never be more than 8
-    // bytes.
-    void send_can(const uint16_t arbitration_id, const uint8_t* data,
-            const uint8_t size) {
-        ...
-    }
-
-    // optional, provide to receive debugging log messages
-    void debug(const char* format, ...) {
-        ...
-    }
-
-
-    // not used in the current version
-    void set_timer(uint16_t time_ms, void (*callback)) {
-        ...
-    }
-
-With your shims in place, create an IsoTpShims object to pass them around:
-
-    IsoTpShims shims = isotp_init_shims(debug, send_can, set_timer);
-
-### API
-
-With your shims in hand, send an ISO-TP message:
-
-    // Optional: This is your callback that will be called when the message is
-    // completely sent. If it was single frame (the only type supported right
-    // now), this will be called immediately.
-    void message_sent(const IsoTpMessage* message, const bool success) {
-        // You received the message! Do something with it.
-    }
-
-    IsoTpSendHandle handle = isotp_send(&shims, 0x100, NULL, 0, message_sent);
-
-    if(handle.completed) {
-        if(!handle.success) {
-            // something happened and it already failed - possibly we aren't able to
-            // send CAN messages
-            return;
-        } else {
-            // If the message fit in a single frame, it's already been sent
-            // and you're done
-        }
-    } else {
-        while(true) {
-            // Continue to read from CAN, passing off each message to the handle
-            // this will return true when the message is completely sent (which
-            // may take more than one call if it was multi frame and we're waiting
-            // on flow control responses from the receiver)
-            bool complete = isotp_continue_send(&shims, &handle, 0x100, data, size);
-
-            if(complete && handle.completed) {
-                if(handle.success) {
-                    // All frames of the message have now been sent, following
-                    // whatever flow control feedback it got from the receiver
-                } else {
-                    // the message was unable to be sent and we bailed - fatal
-                    // error!
-                }
-            }
-        }
-    }
-
-Finally, receive an ISO-TP message:
-
-    // Optional: This is your callback for when a complete ISO-TP message is
-    // received at the arbitration ID you specify. The completed message is
-    // also returned by isotp_continue_receive, which can sometimes be more
-    // useful since you have more context.
-    void message_received(const IsoTpMessage* message) {
-    }
-
-    IsoTpReceiveHandle handle = isotp_receive(&shims, 0x100, message_received);
-    if(!handle.success) {
-        // something happened and it already failed - possibly we aren't able to
-        // send CAN messages
-    } else {
-        while(true) {
-            // Continue to read from CAN, passing off each message to the handle
-            IsoTpMessage message = isotp_continue_receive(&shims, &handle, 0x100, data, size);
-
-            if(message.completed && handle.completed) {
-                if(handle.success) {
-                    // A message has been received successfully
-                } else {
-                    // Fatal error - we weren't able to receive a message and
-                    // gave up trying. A message using flow control may have
-                    // timed out.
-                }
-            }
-        }
-    }
-
-## Testing
-
-The library includes a test suite that uses the `check` C unit test library.
-
-    $ make test
-
-You can also see the test coverage if you have `lcov` installed and the
-`BROWSER` environment variable set to your choice of web browsers:
-
-    $ BROWSER=google-chrome-stable make coverage
-
-## Authors
-
-* Chris Peplin cpeplin@ford.com
-* David Boll dboll2@ford.com (the inspiration for the library's API is from David)
-
-## License
-
-Copyright (c) 2013 Ford Motor Company
-
-Licensed under the BSD license.
diff --git a/CAN-binder/libs/isotp-c/runtests.sh b/CAN-binder/libs/isotp-c/runtests.sh
deleted file mode 100644
index 4781636b..00000000
--- a/CAN-binder/libs/isotp-c/runtests.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-echo "Running unit tests:"
-
-for i in $1/*.bin
-do
-    if test -f $i
-    then
-        if ./$i
-        then
-            echo $i PASS
-        else
-            echo "ERROR in test $i:"
-            exit 1
-        fi
-    fi
-done
-
-echo "${txtbld}$(tput setaf 2)All unit tests passed.$(tput sgr0)"
diff --git a/CAN-binder/libs/isotp-c/src/isotp/isotp.c b/CAN-binder/libs/isotp-c/src/isotp/isotp.c
deleted file mode 100644
index ce87f1bd..00000000
--- a/CAN-binder/libs/isotp-c/src/isotp/isotp.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <isotp/isotp.h>
-#include <bitfield/bitfield.h>
-#include <inttypes.h>
-
-/* void isotp_set_timeout(IsoTpHandler* handler, uint16_t timeout_ms) { */
-    /* handler->timeout_ms = timeout_ms; */
-/* } */
-
-IsoTpShims isotp_init_shims(LogShim log, SendCanMessageShim send_can_message,
-        SetTimerShim set_timer) {
-    IsoTpShims shims = {
-        log: log,
-        send_can_message: send_can_message,
-        set_timer: set_timer,
-        frame_padding: ISO_TP_DEFAULT_FRAME_PADDING_STATUS
-    };
-    return shims;
-}
-
-void isotp_message_to_string(const IsoTpMessage* message, char* destination,
-        size_t destination_length) {
-    snprintf(destination, destination_length, "ID: 0x%" SCNd32 ", Payload: 0x%02x%02x%02x%02x%02x%02x%02x%02x",
-            message->arbitration_id,
-            message->payload[0],
-            message->payload[1],
-            message->payload[2],
-            message->payload[3],
-            message->payload[4],
-            message->payload[5],
-            message->payload[6],
-            message->payload[7]);
-}
diff --git a/CAN-binder/libs/isotp-c/src/isotp/isotp.h b/CAN-binder/libs/isotp-c/src/isotp/isotp.h
deleted file mode 100644
index 3a3658c7..00000000
--- a/CAN-binder/libs/isotp-c/src/isotp/isotp.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef __ISOTP_H__
-#define __ISOTP_H__
-
-#include <isotp/isotp_types.h>
-#include <isotp/send.h>
-#include <isotp/receive.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Public: Initialize an IsoTpShims with the given callback functions.
- *
- * If any callbacks are not to be used, set them to NULL. For documentation of
- * the function type signatures, see isotp_types.h. This struct is a handy
- * encapsulation used to pass the shims around to the various isotp_* functions.
- *
- * Returns a struct with the fields initailized to the callbacks.
- */
-IsoTpShims isotp_init_shims(LogShim log,
-        SendCanMessageShim send_can_message,
-        SetTimerShim set_timer);
-
-/* Public: Render an IsoTpMessage as a string into the given buffer.
- *
- * message - the message to convert to a string, for debug logging.
- * destination - the target string buffer.
- * destination_length - the size of the destination buffer, i.e. the max size
- *      for the rendered string.
- */
-void isotp_message_to_string(const IsoTpMessage* message, char* destination,
-        size_t destination_length);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __ISOTP_H__
diff --git a/CAN-binder/libs/isotp-c/src/isotp/isotp_types.h b/CAN-binder/libs/isotp-c/src/isotp/isotp_types.h
deleted file mode 100644
index 3b7fd26d..00000000
--- a/CAN-binder/libs/isotp-c/src/isotp/isotp_types.h
+++ /dev/null
@@ -1,144 +0,0 @@
-#ifndef __ISOTP_TYPES__
-#define __ISOTP_TYPES__
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-#define CAN_MESSAGE_BYTE_SIZE 8
-#define MAX_ISO_TP_MESSAGE_SIZE 4096
-// TODO we want to avoid malloc, and we can't be allocated 4K on the stack for
-// each IsoTpMessage, so for now we're setting an artificial max message size
-// here - for most multi-frame use cases, 256 bytes is plenty.
-#define OUR_MAX_ISO_TP_MESSAGE_SIZE 127
-
-/* Private: IsoTp nibble specifics for PCI and Payload.
- */
-#define PCI_NIBBLE_INDEX 0
-#define PAYLOAD_LENGTH_NIBBLE_INDEX 1
-#define PAYLOAD_BYTE_INDEX 1
-
-/* Private: The default timeout to use when waiting for a response during a
- * multi-frame send or receive.
- */
-#define ISO_TP_DEFAULT_RESPONSE_TIMEOUT 100
-
-/* Private: Determines if by default, padding is added to ISO-TP message frames.
- */
-#define ISO_TP_DEFAULT_FRAME_PADDING_STATUS true
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Public: A container for a sent or received ISO-TP message.
- *
- * completed - An IsoTpMessage is the return value from a few functions - this
- *      attribute will be true if the message is actually completely received.
- *      If the function returns but is only partially through receiving the
- *      message, this will be false, the multi_frame attribute will be true,
- *      and you should not consider the other data to be valid.
- * multi_frame - Designates the message is being built with multi-frame.
- * arbitration_id - The arbitration ID of the message.
- * payload - The optional payload of the message - don't forget to check the
- *      size!
- * size -  The size of the payload. The size will be 0 if there is no payload.
- */
-typedef struct {
-    const uint32_t arbitration_id;
-    uint8_t payload[OUR_MAX_ISO_TP_MESSAGE_SIZE];
-    uint16_t size;
-    bool completed;
-    bool multi_frame;
-} IsoTpMessage;
-
-/* Public: The type signature for an optional logging function, if the user
- * wishes to provide one. It should print, store or otherwise display the
- * message.
- *
- * message - A format string to log using the given parameters.
- * ... (vargs) - the parameters for the format string.
- */
-typedef void (*LogShim)(const char* message, ...);
-/* Public: The type signature for a function to send a single CAN message.
- *
- * arbitration_id - The arbitration ID of the message.
- * data - The data payload for the message. NULL is valid if size is also 0.
- * size - The size of the data payload, in bytes.
- *
- * Returns true if the CAN message was sent successfully.
- */
-typedef bool (*SendCanMessageShim)(const uint32_t arbitration_id,
-        const uint8_t* data, const uint8_t size);
-
-/* Public: The type signature for a... TODO, not used yet.
- */
-typedef bool (*SetTimerShim)(uint16_t time_ms, void (*callback));
-
-/* Public: The signature for a function to be called when an ISO-TP message has
- * been completely received.
- *
- * message - The received message.
- */
-typedef void (*IsoTpMessageReceivedHandler)(const IsoTpMessage* message);
-
-/* Public: the signature for a function to be called when an ISO-TP message has
- * been completely sent, or had a fatal error during sending.
- *
- * message - The sent message.
- * success - True if the message was sent successfully.
- */
-typedef void (*IsoTpMessageSentHandler)(const IsoTpMessage* message,
-        const bool success);
-
-/* Public: The signature for a function to be called when a CAN frame has been
- * sent as as part of sending or receive an ISO-TP message.
- *
- * This is really only useful for debugging the library itself.
- *
- * message - The ISO-TP message that generated this CAN frame.
- */
-typedef void (*IsoTpCanFrameSentHandler)(const IsoTpMessage* message);
-
-/* Public: A container for the 3 shim functions used by the library to interact
- * with the wider system.
- *
- * Use the isotp_init_shims(...) function to create an instance of this struct.
- *
- * By default, all CAN frames sent from this device in the process of an ISO-TP
- * message are padded out to a complete 8 byte frame. This is often required by
- * ECUs. To disable this feature, change the 'frame_padding' field to false on
- * the IsoTpShims object returned from isotp_init_shims(...).
- *
- * frame_padding - true if outgoing CAN frames should be padded to a full 8
- *      bytes.
- */
-typedef struct {
-    LogShim log;
-    SendCanMessageShim send_can_message;
-    SetTimerShim set_timer;
-    bool frame_padding;
-} IsoTpShims;
-
-/* Private: PCI types, for identifying each frame of an ISO-TP message.
- */
-typedef enum {
-    PCI_SINGLE = 0x0,
-    PCI_FIRST_FRAME = 0x1,
-    PCI_CONSECUTIVE_FRAME = 0x2,
-    PCI_FLOW_CONTROL_FRAME = 0x3
-} IsoTpProtocolControlInformation;
-
-/* Private: PCI flow control identifiers.
- */
-typedef enum {
-    PCI_FLOW_STATUS_CONTINUE = 0x0,
-    PCI_FLOW_STATUS_WAIT = 0x1,
-    PCI_FLOW_STATUS_OVERFLOW = 0x2
-} IsoTpFlowStatus;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __ISOTP_TYPES__
diff --git a/CAN-binder/libs/isotp-c/src/isotp/receive.c b/CAN-binder/libs/isotp-c/src/isotp/receive.c
deleted file mode 100644
index 35b7a2a6..00000000
--- a/CAN-binder/libs/isotp-c/src/isotp/receive.c
+++ /dev/null
@@ -1,166 +0,0 @@
-#include <isotp/receive.h>
-#include <isotp/send.h>
-#include <bitfield/bitfield.h>
-#include <string.h>
-#include <stdlib.h>
-
-#define ARBITRATION_ID_OFFSET 0x8
-
-static void isotp_complete_receive(IsoTpReceiveHandle* handle, IsoTpMessage* message) {
-    if(handle->message_received_callback != NULL) {
-        handle->message_received_callback(message);
-    }
-}
-
-bool isotp_handle_single_frame(IsoTpReceiveHandle* handle, IsoTpMessage* message) {
-    isotp_complete_receive(handle, message);
-    return true;
-}
-
-bool isotp_handle_multi_frame(IsoTpReceiveHandle* handle, IsoTpMessage* message) {
-    // call this once all consecutive frames have been received
-    isotp_complete_receive(handle, message);
-    return true;
-}
-
-bool isotp_send_flow_control_frame(IsoTpShims* shims, IsoTpMessage* message) {
-    uint8_t can_data[CAN_MESSAGE_BYTE_SIZE] = {0};
-
-    if(!set_nibble(PCI_NIBBLE_INDEX, PCI_FLOW_CONTROL_FRAME, can_data, sizeof(can_data))) {
-        shims->log("Unable to set PCI in CAN data");
-        return false;
-    }
-
-    shims->send_can_message(message->arbitration_id - ARBITRATION_ID_OFFSET, can_data,
-            shims->frame_padding ? 8 : 1 + message->size);
-    return true;
-}
-
-
-IsoTpReceiveHandle isotp_receive(IsoTpShims* shims,
-        const uint32_t arbitration_id, IsoTpMessageReceivedHandler callback) {
-    IsoTpReceiveHandle handle = {
-        success: false,
-        completed: false,
-        arbitration_id: arbitration_id,
-        message_received_callback: callback
-    };
-
-    return handle;
-}
-
-IsoTpMessage isotp_continue_receive(IsoTpShims* shims,
-        IsoTpReceiveHandle* handle, const uint32_t arbitration_id,
-        const uint8_t data[], const uint8_t size) {
-    IsoTpMessage message = {
-        arbitration_id: arbitration_id,
-        completed: false,
-        multi_frame: false,
-        payload: {0},
-        size: 0
-    };
-
-    if(size < 1) {
-        return message;
-    }
-
-    if(handle->arbitration_id != arbitration_id) {
-        if(shims->log != NULL)  {
-            // You may turn this on for debugging, but in normal operation it's
-            // very noisy if you are passing all received CAN messages to this
-            // handler.
-            /* shims->log("The arb ID 0x%x doesn't match the expected rx ID 0x%x", */
-                    /* arbitration_id, handle->arbitration_id); */
-        }
-        return message;
-    }
-
-    IsoTpProtocolControlInformation pci = (IsoTpProtocolControlInformation)
-            get_nibble(data, size, 0);
-
-    // TODO this is set up to handle rx a response with a payload, but not to
-    // handle flow control responses for multi frame messages that we're in the
-    // process of sending
-
-    switch(pci) {
-        case PCI_SINGLE: {
-            uint8_t payload_length = get_nibble(data, size, 1);
-            
-            if(payload_length > 0) {
-                memcpy(message.payload, &data[1], payload_length);
-            }
-            
-            message.size = payload_length;
-            message.completed = true;
-            handle->success = true;
-            handle->completed = true;
-            isotp_handle_single_frame(handle, &message);
-            break;
-        }
-        //If multi-frame, then the payload length is contained in the 12
-        //bits following the first nibble of Byte 0. 
-        case PCI_FIRST_FRAME: {
-            uint16_t payload_length = (get_nibble(data, size, 1) << 8) + get_byte(data, size, 1);
-
-            if(payload_length > OUR_MAX_ISO_TP_MESSAGE_SIZE) {
-                shims->log("Multi-frame response too large for receive buffer.");
-                break;
-            }
-
-            //Need to allocate memory for the combination of multi-frame
-            //messages. That way we don't have to allocate 4k of memory 
-            //for each multi-frame response.
-            uint8_t* combined_payload = NULL;
-            combined_payload = (uint8_t*)malloc(sizeof(uint8_t)*payload_length);
-
-            if(combined_payload == NULL) {
-                shims->log("Unable to allocate memory for multi-frame response.");
-                break;
-            }
-
-            memcpy(combined_payload, &data[2], CAN_MESSAGE_BYTE_SIZE - 2);
-            handle->receive_buffer = combined_payload;
-            handle->received_buffer_size = CAN_MESSAGE_BYTE_SIZE - 2;
-            handle->incoming_message_size = payload_length;
-
-            message.multi_frame = true;
-            handle->success = false;
-            handle->completed = false;
-            isotp_send_flow_control_frame(shims, &message);
-            break;
-        }
-        case PCI_CONSECUTIVE_FRAME: {
-            uint8_t start_index = handle->received_buffer_size;
-            uint8_t remaining_bytes = handle->incoming_message_size - start_index;
-            message.multi_frame = true;
-
-            if(remaining_bytes > 7) {
-                memcpy(&handle->receive_buffer[start_index], &data[1], CAN_MESSAGE_BYTE_SIZE - 1);
-                handle->received_buffer_size = start_index + 7;
-            } else {
-                memcpy(&handle->receive_buffer[start_index], &data[1], remaining_bytes);
-                handle->received_buffer_size = start_index + remaining_bytes;
-
-                if(handle->received_buffer_size != handle->incoming_message_size){
-                    free(handle->receive_buffer);
-                    handle->success = false;
-                    shims->log("Error capturing all bytes of multi-frame. Freeing memory.");
-                } else {
-                    memcpy(message.payload,&handle->receive_buffer[0],handle->incoming_message_size);
-                    free(handle->receive_buffer);
-                    message.size = handle->incoming_message_size;
-                    message.completed = true;
-                    shims->log("Successfully captured all of multi-frame. Freeing memory.");
-
-                    handle->success = true;
-                    handle->completed = true;
-                    isotp_handle_multi_frame(handle, &message);
-                }
-            }
-            break;
-        }
-        default:
-            break;
-    }
-    return message;
-}
diff --git a/CAN-binder/libs/isotp-c/src/isotp/receive.h b/CAN-binder/libs/isotp-c/src/isotp/receive.h
deleted file mode 100644
index 6788914a..00000000
--- a/CAN-binder/libs/isotp-c/src/isotp/receive.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef __ISOTP_RECEIVE_H__
-#define __ISOTP_RECEIVE_H__
-
-#include <isotp/isotp.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Public: A handle for beginning and continuing receiving a single ISO-TP
- * message - both single and multi-frame.
- *
- * Since an ISO-TP message may contain multiple frames, we need to keep a handle
- * around while waiting for subsequent CAN messages to complete the message.
- * This struct encapsulates the local state required.
- *
- * completed - True if the received message request is completely finished.
- * success - True if the message request was successful. The value if this field
- *      isn't valid if 'completed' isn't true.
- */
-typedef struct {
-    bool completed;
-    bool success;
-
-    // Private
-    uint32_t arbitration_id;
-    IsoTpMessageReceivedHandler message_received_callback;
-    uint16_t timeout_ms;
-    // timeout_ms: ISO_TP_DEFAULT_RESPONSE_TIMEOUT,
-    uint8_t* receive_buffer;
-    uint16_t received_buffer_size;
-    uint16_t incoming_message_size;
-    // TODO timer callback for multi frame
-} IsoTpReceiveHandle;
-
-/* Public: Initiate receiving a single ISO-TP message on a particular
- * arbitration ID.
- *
- * Note that no actual CAN data has been received at this point - this just sets
- * up a handle to be used when new CAN messages to arrive, so they can be parsed
- * as potential single or multi-frame ISO-TP messages.
- *
- * shims -  Low-level shims required to send and receive CAN messages, etc.
- * arbitration_id - The arbitration ID to receive the message on.
- * callback - an optional function to be called when the message is completely
- *      received (use NULL if no callback required).
- *
- * Returns a handle to be used with isotp_continue_receive when a new CAN frame
- * arrives. The 'completed' field in the returned IsoTpReceiveHandle will be true
- * when the message is completely sent.
- */
-IsoTpReceiveHandle isotp_receive(IsoTpShims* shims,
-        const uint32_t arbitration_id, IsoTpMessageReceivedHandler callback);
-
-/* Public: Continue to receive a an ISO-TP message, based on a freshly
- * received CAN message.
- *
- * For a multi-frame ISO-TP message, this function must be called
- * repeatedly whenever a new CAN message is received in order to complete
- * receipt.
- *
- * TODO does this API work for if we wanted to receive an ISO-TP message and
- * send our own flow control messages back?
- *
- * shims -  Low-level shims required to send and receive CAN messages, etc.
- * handle - An IsoTpReceiveHandle previously returned by isotp_receive(...).
- * arbitration_id - The arbitration_id of the received CAN message.
- * data - The data of the received CAN message.
- * size - The size of the data in the received CAN message.
- *
- * Returns an IsoTpMessage with the 'completed' field set to true if a message
- * was completely received. If 'completed' is false, more CAN frames are
- * required to complete the messages, or the arbitration ID didn't match this
- * handle. Keep passing the same handle to this function when CAN frames arrive.
- */
-IsoTpMessage isotp_continue_receive(IsoTpShims* shims,
-        IsoTpReceiveHandle* handle, const uint32_t arbitration_id,
-        const uint8_t data[], const uint8_t size);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __ISOTP_RECEIVE_H__
diff --git a/CAN-binder/libs/isotp-c/src/isotp/send.c b/CAN-binder/libs/isotp-c/src/isotp/send.c
deleted file mode 100644
index e849bb2c..00000000
--- a/CAN-binder/libs/isotp-c/src/isotp/send.c
+++ /dev/null
@@ -1,89 +0,0 @@
-#include <isotp/send.h>
-#include <bitfield/bitfield.h>
-#include <string.h>
-
-#define PCI_NIBBLE_INDEX 0
-#define PAYLOAD_LENGTH_NIBBLE_INDEX 1
-#define PAYLOAD_BYTE_INDEX 1
-
-void isotp_complete_send(IsoTpShims* shims, IsoTpMessage* message,
-        bool status, IsoTpMessageSentHandler callback) {
-    if(callback != NULL) {
-        callback(message, status);
-    }
-}
-
-IsoTpSendHandle isotp_send_single_frame(IsoTpShims* shims, IsoTpMessage* message,
-        IsoTpMessageSentHandler callback) {
-    IsoTpSendHandle handle = {
-        success: false,
-        completed: true
-    };
-
-    uint8_t can_data[CAN_MESSAGE_BYTE_SIZE] = {0};
-    if(!set_nibble(PCI_NIBBLE_INDEX, PCI_SINGLE, can_data, sizeof(can_data))) {
-        shims->log("Unable to set PCI in CAN data");
-        return handle;
-    }
-
-    if(!set_nibble(PAYLOAD_LENGTH_NIBBLE_INDEX, message->size, can_data,
-                sizeof(can_data))) {
-        shims->log("Unable to set payload length in CAN data");
-        return handle;
-    }
-
-    if(message->size > 0) {
-        memcpy(&can_data[1], message->payload, message->size);
-    }
-
-    shims->send_can_message(message->arbitration_id, can_data,
-            shims->frame_padding ? 8 : 1 + message->size);
-    handle.success = true;
-    isotp_complete_send(shims, message, true, callback);
-    return handle;
-}
-
-IsoTpSendHandle isotp_send_multi_frame(IsoTpShims* shims, IsoTpMessage* message,
-        IsoTpMessageSentHandler callback) {
-    // TODO make sure to copy message into a local buffer
-    shims->log("Only single frame messages are supported");
-    IsoTpSendHandle handle = {
-        success: false,
-        completed: true
-    };
-    // TODO need to set sending and receiving arbitration IDs separately if we
-    // can't always just add 0x8 (and I think we can't)
-    return handle;
-}
-
-IsoTpSendHandle isotp_send(IsoTpShims* shims, const uint16_t arbitration_id,
-        const uint8_t payload[], uint16_t size,
-        IsoTpMessageSentHandler callback) {
-    IsoTpMessage message = {
-        arbitration_id: arbitration_id,
-        size: size
-    };
-
-    memcpy(message.payload, payload, size);
-    if(size < 8) {
-        return isotp_send_single_frame(shims, &message, callback);
-    } else {
-        return isotp_send_multi_frame(shims, &message, callback);
-    }
-}
-
-bool isotp_continue_send(IsoTpShims* shims, IsoTpSendHandle* handle,
-        const uint16_t arbitration_id, const uint8_t data[],
-        const uint8_t size) {
-    // TODO this will need to be tested when we add multi-frame support,
-    // which is when it'll be necessary to pass in CAN messages to SENDING
-    // handles.
-    if(handle->receiving_arbitration_id != arbitration_id) {
-        if(shims->log != NULL) {
-            shims->log("The arb ID 0x%x doesn't match the expected tx continuation ID 0x%x",
-                    arbitration_id, handle->receiving_arbitration_id);
-        }
-        return false;
-    }
-    return false;
-}
diff --git a/CAN-binder/libs/isotp-c/src/isotp/send.h b/CAN-binder/libs/isotp-c/src/isotp/send.h
deleted file mode 100644
index 1af32668..00000000
--- a/CAN-binder/libs/isotp-c/src/isotp/send.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef __ISOTP_SEND_H__
-#define __ISOTP_SEND_H__
-
-#include <isotp/isotp.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Public: A handle for beginning and continuing sending a single ISO-TP
- * message - both single and multi-frame.
- *
- * Since an ISO-TP message may contain multiple frames, we need to keep a handle
- * around while waiting for flow control messages from the receiver.
- * This struct encapsulates the local state required.
- *
- * completed - True if the message was completely sent, or the send was
- *      otherwise cancelled.
- * success - True if the message send request was successful. The value if this
- *      field isn't valid if 'completed' isn't true.
- */
-typedef struct {
-    bool completed;
-    bool success;
-
-    // Private
-    uint16_t sending_arbitration_id;
-    uint16_t receiving_arbitration_id;
-    IsoTpMessageSentHandler message_sent_callback;
-    IsoTpCanFrameSentHandler can_frame_sent_callback;
-    // TODO going to need some state here for multi frame messages
-} IsoTpSendHandle;
-
-/* Public: Initiate sending a single ISO-TP message.
- *
- * If the message fits in a single ISO-TP frame (i.e. the payload isn't more
- * than 7 bytes) it will be sent immediately and the returned IsoTpSendHandle's
- * 'completed' flag will be true.
- *
- * For multi-frame messages, see isotp_continue_send(...).
- *
- * shims -  Low-level shims required to send CAN messages, etc.
- * arbitration_id - The arbitration ID to send the message on.
- * payload - The payload for the message. If no payload, NULL is valid is size
- *      is also 0.
- * size - The size of the payload, or 0 if no payload.
- * callback - an optional function to be called when the message is completely
- *      sent (use NULL if no callback required).
- *
- * Returns a handle to be used with isotp_continue_send to continue sending
- * multi-frame messages. The 'completed' field in the returned IsoTpSendHandle
- * will be true when the message is completely sent.
- */
-IsoTpSendHandle isotp_send(IsoTpShims* shims, const uint16_t arbitration_id,
-        const uint8_t payload[], uint16_t size,
-        IsoTpMessageSentHandler callback);
-
-/* Public: Continue to send a multi-frame ISO-TP message, based on a freshly
- * received CAN message (potentially from the receiver about flow control).
- *
- * For a multi-frame ISO-TP message, this function must be called
- * repeatedly whenever a new CAN message is received in order to complete the
- * send. The sender can't just blast everything onto the bus at once - it must
- * wait for some response from the receiver to know how much to send at once.
- *
- * shims -  Low-level shims required to send CAN messages, etc.
- * handle - An IsoTpSendHandle previously returned by isotp_send(...).
- * arbitration_id - The arbitration_id of the received CAN message.
- * data - The data of the received CAN message.
- * size - The size of the data in the received CAN message.
- *
- * Returns true if the message was completely sent, or the send was
- *      otherwise cancelled. Check the 'success' field of the handle to see if
- *      it was successful.
- */
-bool isotp_continue_send(IsoTpShims* shims, IsoTpSendHandle* handle,
-        const uint16_t arbitration_id, const uint8_t data[],
-        const uint8_t size);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __ISOTP_SEND_H__
diff --git a/CAN-binder/libs/isotp-c/tests/common.c b/CAN-binder/libs/isotp-c/tests/common.c
deleted file mode 100644
index a9eed39e..00000000
--- a/CAN-binder/libs/isotp-c/tests/common.c
+++ /dev/null
@@ -1,91 +0,0 @@
-#include <isotp/isotp.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-
-IsoTpShims SHIMS;
-IsoTpReceiveHandle RECEIVE_HANDLE;
-
-uint32_t last_can_frame_sent_arb_id;
-uint8_t last_can_payload_sent[8];
-uint8_t last_can_payload_size;
-bool can_frame_was_sent;
-
-bool message_was_received;
-uint32_t last_message_received_arb_id;
-uint8_t last_message_received_payload[OUR_MAX_ISO_TP_MESSAGE_SIZE];
-uint8_t last_message_received_payload_size;
-
-uint32_t last_message_sent_arb_id;
-bool last_message_sent_status;
-uint8_t last_message_sent_payload[OUR_MAX_ISO_TP_MESSAGE_SIZE];
-uint8_t last_message_sent_payload_size;
-
-void debug(const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    vprintf(format, args);
-    printf("\r\n");
-    va_end(args);
-}
-
-bool mock_send_can(const uint32_t arbitration_id, const uint8_t* data,
-        const uint8_t size) {
-    can_frame_was_sent = true;
-    last_can_frame_sent_arb_id = arbitration_id;
-    last_can_payload_size = size;
-    if(size > 0) {
-        memcpy(last_can_payload_sent, data, size);
-    }
-    return true;
-}
-
-void message_received(const IsoTpMessage* message) {
-    debug("Received ISO-TP message:");
-    message_was_received = true;
-    char str_message[48] = {0};
-    isotp_message_to_string(message, str_message, sizeof(str_message));
-    debug("%s", str_message);
-    last_message_received_arb_id = message->arbitration_id;
-    last_message_received_payload_size = message->size;
-    if(message->size > 0) {
-        memcpy(last_message_received_payload, message->payload, message->size);
-    }
-}
-
-void message_sent(const IsoTpMessage* message, const bool success) {
-    if(success) {
-        debug("Sent ISO-TP message:");
-    } else {
-        debug("Unable to send ISO-TP message:");
-    }
-    char str_message[48] = {0};
-    isotp_message_to_string(message, str_message, sizeof(str_message));
-    debug("%s", str_message);
-
-    last_message_sent_arb_id = message->arbitration_id;
-    last_message_sent_payload_size = message->size;
-    last_message_sent_status = success;
-    if(message->size > 0) {
-        memcpy(last_message_sent_payload, message->payload, message->size);
-    }
-}
-
-void can_frame_sent(const uint32_t arbitration_id, const uint8_t* payload,
-        const uint8_t size) {
-    debug("Sent CAN Frame with arb ID 0x%x and %d bytes", arbitration_id, size);
-}
-
-void setup() {
-    SHIMS = isotp_init_shims(debug, mock_send_can, NULL);
-    RECEIVE_HANDLE = isotp_receive(&SHIMS, 0x2a, message_received);
-    memset(last_message_sent_payload, 0, OUR_MAX_ISO_TP_MESSAGE_SIZE);
-    memset(last_message_received_payload, 0, OUR_MAX_ISO_TP_MESSAGE_SIZE);
-    memset(last_can_payload_sent, 0, sizeof(last_can_payload_sent));
-    last_message_sent_status = false;
-    message_was_received = false;
-    can_frame_was_sent = false;
-}
-
diff --git a/CAN-binder/libs/isotp-c/tests/test_core.c b/CAN-binder/libs/isotp-c/tests/test_core.c
deleted file mode 100644
index 73b47af0..00000000
--- a/CAN-binder/libs/isotp-c/tests/test_core.c
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <isotp/receive.h>
-#include <check.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-
-extern IsoTpShims SHIMS;
-
-extern void message_sent(const IsoTpMessage* message, const bool success);
-
-extern uint16_t last_can_frame_sent_arb_id;
-extern uint8_t last_can_payload_sent[8];
-extern uint8_t last_can_payload_size;
-extern bool can_frame_was_sent;
-
-extern bool message_was_received;
-extern uint16_t last_message_received_arb_id;
-extern uint8_t last_message_received_payload[];
-extern uint8_t last_message_received_payload_size;
-
-extern uint16_t last_message_sent_arb_id;
-extern bool last_message_sent_status;
-extern uint8_t last_message_sent_payload[];
-extern uint8_t last_message_sent_payload_size;
-
-extern void setup();
-
-START_TEST (test_default_frame_padding_on)
-{
-    ck_assert(SHIMS.frame_padding);
-    const uint8_t payload[] = {0x12, 0x34};
-    uint32_t arbitration_id = 0x2a;
-    isotp_send(&SHIMS, arbitration_id, payload, sizeof(payload), message_sent);
-    ck_assert_int_eq(last_message_sent_arb_id, arbitration_id);
-    fail_unless(last_message_sent_status);
-    ck_assert_int_eq(last_message_sent_payload_size, 2);
-    ck_assert_int_eq(last_can_payload_size, 8);
-
-}
-END_TEST
-
-START_TEST (test_disabled_frame_padding)
-{
-    SHIMS.frame_padding = false;
-    const uint8_t payload[] = {0x12, 0x34};
-    uint32_t arbitration_id = 0x2a;
-    isotp_send(&SHIMS, arbitration_id, payload, sizeof(payload), message_sent);
-    ck_assert_int_eq(last_message_sent_arb_id, arbitration_id);
-    fail_unless(last_message_sent_status);
-    ck_assert_int_eq(last_message_sent_payload_size, 2);
-    ck_assert_int_eq(last_can_payload_size, 3);
-
-}
-END_TEST
-
-Suite* testSuite(void) {
-    Suite* s = suite_create("iso15765");
-    TCase *tc_core = tcase_create("core");
-    tcase_add_checked_fixture(tc_core, setup, NULL);
-    tcase_add_test(tc_core, test_default_frame_padding_on);
-    tcase_add_test(tc_core, test_disabled_frame_padding);
-    suite_add_tcase(s, tc_core);
-
-    return s;
-}
-
-int main(void) {
-    int numberFailed;
-    Suite* s = testSuite();
-    SRunner *sr = srunner_create(s);
-    // Don't fork so we can actually use gdb
-    srunner_set_fork_status(sr, CK_NOFORK);
-    srunner_run_all(sr, CK_NORMAL);
-    numberFailed = srunner_ntests_failed(sr);
-    srunner_free(sr);
-    return (numberFailed == 0) ? 0 : 1;
-}
diff --git a/CAN-binder/libs/isotp-c/tests/test_receive.c b/CAN-binder/libs/isotp-c/tests/test_receive.c
deleted file mode 100644
index 607f9061..00000000
--- a/CAN-binder/libs/isotp-c/tests/test_receive.c
+++ /dev/null
@@ -1,176 +0,0 @@
-#include <isotp/isotp.h>
-#include <check.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-
-extern IsoTpShims SHIMS;
-extern IsoTpReceiveHandle RECEIVE_HANDLE;
-
-extern void message_sent(const IsoTpMessage* message, const bool success);
-
-extern uint16_t last_can_frame_sent_arb_id;
-extern uint8_t last_can_payload_sent;
-extern uint8_t last_can_payload_size;
-extern bool can_frame_was_sent;
-
-extern bool message_was_received;
-extern uint16_t last_message_received_arb_id;
-extern uint8_t last_message_received_payload[];
-extern uint8_t last_message_received_payload_size;
-
-extern uint16_t last_message_sent_arb_id;
-extern bool last_message_sent_status;
-extern uint8_t last_message_sent_payload[];
-extern uint8_t last_message_sent_payload_size;
-
-extern void setup();
-
-START_TEST (test_receive_empty_can_message)
-{
-    const uint8_t data[CAN_MESSAGE_BYTE_SIZE] = {0};
-    fail_if(RECEIVE_HANDLE.completed);
-    IsoTpMessage message = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x100, data, 0);
-    fail_if(message.completed);
-    fail_if(message_was_received);
-}
-END_TEST
-
-START_TEST (test_receive_wrong_id)
-{
-    const uint8_t data[CAN_MESSAGE_BYTE_SIZE] = {0};
-    fail_if(RECEIVE_HANDLE.completed);
-    IsoTpMessage message = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x100, data, 1);
-    fail_if(message.completed);
-    fail_if(message_was_received);
-}
-END_TEST
-
-START_TEST (test_receive_bad_pci)
-{
-    // 4 is a reserved number for the PCI field - only 0-3 are allowed
-    const uint8_t data[CAN_MESSAGE_BYTE_SIZE] = {0x40};
-    IsoTpMessage message = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x2a, data, 1);
-    fail_if(message.completed);
-    fail_if(message_was_received);
-}
-END_TEST
-
-START_TEST (test_receive_single_frame_empty_payload)
-{
-    const uint8_t data[CAN_MESSAGE_BYTE_SIZE] = {0x00, 0x12, 0x34};
-    fail_if(RECEIVE_HANDLE.completed);
-    IsoTpMessage message = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x2a, data, 3);
-    fail_unless(RECEIVE_HANDLE.completed);
-    fail_unless(message.completed);
-    fail_unless(message_was_received);
-    ck_assert_int_eq(last_message_received_arb_id, 0x2a);
-    ck_assert_int_eq(last_message_received_payload_size, 0);
-}
-END_TEST
-
-START_TEST (test_receive_single_frame)
-{
-    const uint8_t data[CAN_MESSAGE_BYTE_SIZE] = {0x02, 0x12, 0x34};
-    IsoTpMessage message = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x2a, data, 3);
-    fail_unless(message.completed);
-    fail_unless(message_was_received);
-    ck_assert_int_eq(last_message_received_arb_id, 0x2a);
-    ck_assert_int_eq(last_message_received_payload_size, 2);
-    ck_assert_int_eq(last_message_received_payload[0], 0x12);
-    ck_assert_int_eq(last_message_received_payload[1], 0x34);
-}
-END_TEST
-
-START_TEST (test_receive_multi_frame)
-{
-    const uint8_t data0[CAN_MESSAGE_BYTE_SIZE] = {0x10, 0x14, 0x49, 0x02, 0x01, 0x31, 0x46, 0x4d};
-    IsoTpMessage message0 = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x2a, data0, 8);
-    fail_unless(!RECEIVE_HANDLE.completed);
-    fail_unless(!message0.completed);
-    fail_unless(!message_was_received);
-    fail_unless(message0.multi_frame);
-    //make sure flow control message has been sent.
-    ck_assert_int_eq(last_can_frame_sent_arb_id, 0x2a - 8);
-    ck_assert_int_eq(last_can_payload_sent, 0x30);
-
-    const uint8_t data1[CAN_MESSAGE_BYTE_SIZE] = {0x21, 0x43, 0x55, 0x39, 0x4a, 0x39, 0x34, 0x48};
-    IsoTpMessage message1 = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x2a, data1, 8);
-    fail_unless(!RECEIVE_HANDLE.completed);
-    fail_unless(!message1.completed);
-    fail_unless(!message_was_received);
-    fail_unless(message1.multi_frame);
-
-    const uint8_t data2[CAN_MESSAGE_BYTE_SIZE] = {0x22, 0x55, 0x41, 0x30, 0x34, 0x35, 0x32, 0x34};
-    IsoTpMessage message2 = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x2a, data2, 8);
-    fail_unless(RECEIVE_HANDLE.completed);
-    fail_unless(message2.completed);
-    fail_unless(message_was_received);
-    fail_unless(message2.multi_frame);
-
-    ck_assert_int_eq(last_message_received_arb_id, 0x2a);
-    ck_assert_int_eq(last_message_received_payload_size, 0x14);
-    ck_assert_int_eq(last_message_received_payload[0], 0x49);
-    ck_assert_int_eq(last_message_received_payload[1], 0x02);
-    ck_assert_int_eq(last_message_received_payload[2], 0x01);
-    ck_assert_int_eq(last_message_received_payload[3], 0x31);
-    ck_assert_int_eq(last_message_received_payload[4], 0x46);
-    ck_assert_int_eq(last_message_received_payload[5], 0x4d);
-    ck_assert_int_eq(last_message_received_payload[6], 0x43);
-    ck_assert_int_eq(last_message_received_payload[7], 0x55);
-    ck_assert_int_eq(last_message_received_payload[8], 0x39);
-    ck_assert_int_eq(last_message_received_payload[9], 0x4a);
-    ck_assert_int_eq(last_message_received_payload[10], 0x39);
-    ck_assert_int_eq(last_message_received_payload[11], 0x34);
-    ck_assert_int_eq(last_message_received_payload[12], 0x48);
-    ck_assert_int_eq(last_message_received_payload[13], 0x55);
-    ck_assert_int_eq(last_message_received_payload[14], 0x41);
-    ck_assert_int_eq(last_message_received_payload[15], 0x30);
-    ck_assert_int_eq(last_message_received_payload[16], 0x34);
-    ck_assert_int_eq(last_message_received_payload[17], 0x35);
-    ck_assert_int_eq(last_message_received_payload[18], 0x32);
-    ck_assert_int_eq(last_message_received_payload[19], 0x34);
-}
-END_TEST
-
-START_TEST (test_receive_large_multi_frame)
-{
-    const uint8_t data0[CAN_MESSAGE_BYTE_SIZE] = {0x10, 0x80, 0x49, 0x02, 0x01, 0x31, 0x46, 0x4d};
-    IsoTpMessage message = isotp_continue_receive(&SHIMS, &RECEIVE_HANDLE, 0x2a, data0, 8);
-    //Make sure we don't try to receive messages that are too large and don't send flow control.
-    fail_unless(!can_frame_was_sent);
-    fail_unless(!RECEIVE_HANDLE.completed);
-    fail_unless(!message.completed);
-    fail_unless(!message_was_received);
-    fail_unless(!message.multi_frame);
-}
-END_TEST
-
-Suite* testSuite(void) {
-    Suite* s = suite_create("iso15765");
-    TCase *tc_core = tcase_create("receive");
-    tcase_add_checked_fixture(tc_core, setup, NULL);
-    tcase_add_test(tc_core, test_receive_wrong_id);
-    tcase_add_test(tc_core, test_receive_bad_pci);
-    tcase_add_test(tc_core, test_receive_single_frame);
-    tcase_add_test(tc_core, test_receive_single_frame_empty_payload);
-    tcase_add_test(tc_core, test_receive_empty_can_message);
-    tcase_add_test(tc_core, test_receive_multi_frame);
-    tcase_add_test(tc_core, test_receive_large_multi_frame);
-    suite_add_tcase(s, tc_core);
-
-    return s;
-}
-
-int main(void) {
-    int numberFailed;
-    Suite* s = testSuite();
-    SRunner *sr = srunner_create(s);
-    // Don't fork so we can actually use gdb
-    srunner_set_fork_status(sr, CK_NOFORK);
-    srunner_run_all(sr, CK_NORMAL);
-    numberFailed = srunner_ntests_failed(sr);
-    srunner_free(sr);
-    return (numberFailed == 0) ? 0 : 1;
-}
diff --git a/CAN-binder/libs/isotp-c/tests/test_send.c b/CAN-binder/libs/isotp-c/tests/test_send.c
deleted file mode 100644
index 29cf5dec..00000000
--- a/CAN-binder/libs/isotp-c/tests/test_send.c
+++ /dev/null
@@ -1,103 +0,0 @@
-#include <isotp/receive.h>
-#include <check.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-
-extern IsoTpShims SHIMS;
-
-extern void message_sent(const IsoTpMessage* message, const bool success);
-
-extern uint16_t last_can_frame_sent_arb_id;
-extern uint8_t last_can_payload_sent[8];
-extern uint8_t last_can_payload_size;
-extern bool can_frame_was_sent;
-
-extern bool message_was_received;
-extern uint16_t last_message_received_arb_id;
-extern uint8_t last_message_received_payload[];
-extern uint8_t last_message_received_payload_size;
-
-extern uint16_t last_message_sent_arb_id;
-extern bool last_message_sent_status;
-extern uint8_t last_message_sent_payload[];
-extern uint8_t last_message_sent_payload_size;
-
-extern void setup();
-
-START_TEST (test_send_empty_payload)
-{
-    SHIMS.frame_padding = false;
-    uint16_t arbitration_id = 0x2a;
-    IsoTpSendHandle handle = isotp_send(&SHIMS, arbitration_id, NULL, 0, message_sent);
-    fail_unless(handle.success);
-    fail_unless(handle.completed);
-    ck_assert_int_eq(last_message_sent_arb_id, arbitration_id);
-    fail_unless(last_message_sent_status);
-    ck_assert_int_eq(last_message_sent_payload[0], '\0');
-    ck_assert_int_eq(last_message_sent_payload_size, 0);
-
-    ck_assert_int_eq(last_can_frame_sent_arb_id, arbitration_id);
-    fail_unless(can_frame_was_sent);
-    ck_assert_int_eq(last_can_payload_sent[0], 0x0);
-    ck_assert_int_eq(last_can_payload_size, 1);
-}
-END_TEST
-
-START_TEST (test_send_single_frame)
-{
-    SHIMS.frame_padding = false;
-    const uint8_t payload[] = {0x12, 0x34};
-    uint16_t arbitration_id = 0x2a;
-    isotp_send(&SHIMS, arbitration_id, payload, sizeof(payload), message_sent);
-    ck_assert_int_eq(last_message_sent_arb_id, arbitration_id);
-    fail_unless(last_message_sent_status);
-    ck_assert_int_eq(last_message_sent_payload[0], 0x12);
-    ck_assert_int_eq(last_message_sent_payload[1], 0x34);
-    ck_assert_int_eq(last_message_sent_payload_size, 2);
-
-    ck_assert_int_eq(last_can_frame_sent_arb_id, arbitration_id);
-    fail_unless(can_frame_was_sent);
-    ck_assert_int_eq(last_can_payload_sent[0], 0x2);
-    ck_assert_int_eq(last_can_payload_sent[1], 0x12);
-    ck_assert_int_eq(last_can_payload_sent[2], 0x34);
-    ck_assert_int_eq(last_can_payload_size, 3);
-}
-END_TEST
-
-START_TEST (test_send_multi_frame)
-{
-    const uint8_t payload[] = {0x12, 0x34, 0x56, 0x78, 0x90, 0x01, 0x23,
-            0x45, 0x67, 0x89};
-    uint16_t arbitration_id = 0x2a;
-    IsoTpSendHandle handle = isotp_send(&SHIMS, arbitration_id, payload, sizeof(payload),
-            message_sent);
-    fail_unless(handle.completed);
-    fail_if(handle.success);
-}
-END_TEST
-
-Suite* testSuite(void) {
-    Suite* s = suite_create("iso15765");
-    TCase *tc_core = tcase_create("send");
-    tcase_add_checked_fixture(tc_core, setup, NULL);
-    tcase_add_test(tc_core, test_send_empty_payload);
-    tcase_add_test(tc_core, test_send_single_frame);
-    tcase_add_test(tc_core, test_send_multi_frame);
-    suite_add_tcase(s, tc_core);
-
-    return s;
-}
-
-int main(void) {
-    int numberFailed;
-    Suite* s = testSuite();
-    SRunner *sr = srunner_create(s);
-    // Don't fork so we can actually use gdb
-    srunner_set_fork_status(sr, CK_NOFORK);
-    srunner_run_all(sr, CK_NORMAL);
-    numberFailed = srunner_ntests_failed(sr);
-    srunner_free(sr);
-    return (numberFailed == 0) ? 0 : 1;
-}