Added GEA2 Communications

.vscode/launch.json

@@ -10,10 +10,10 @@
       "request": "launch",
       "preLaunchTask": "Build",
       "program": "${workspaceFolder}/build/arduino-gea3-api_tests",
-      "args": [ ],
+      "args": [],
       "stopAtEntry": true,
       "cwd": "${workspaceFolder}",
-      "environment": [ ],
+      "environment": [],
       "externalConsole": false,
       "linux": {
         "MIMode": "gdb"

CMakeLists.txt

@@ -3,6 +3,7 @@ add_library(tiny_gea3 INTERFACE)
 target_sources(tiny_gea3 INTERFACE
   ${CMAKE_CURRENT_LIST_DIR}/src/tiny_erd_client.c
   ${CMAKE_CURRENT_LIST_DIR}/src/tiny_gea3_interface.c
+  ${CMAKE_CURRENT_LIST_DIR}/src/tiny_gea2_interface.c
 )
 
 target_include_directories(tiny_gea3 INTERFACE ${CMAKE_CURRENT_LIST_DIR}/include)

README.md

@@ -1,12 +1,15 @@
 # tiny-gea3-api
 [![Tests](https://github.com/geappliances/tiny-gea3-api/actions/workflows/test.yml/badge.svg)](https://github.com/geappliances/tiny-gea3-api/actions/workflows/test.yml)
 
-PlatformIO library for interacting with GE Appliances products supporting the full-duplex GEA3 serial protocol using the [`tiny`](https://github.com/ryanplusplus/tiny) HAL. Note that this does not support older GE Appliances products using the single-wire GEA2 interface.
+PlatformIO library for interacting with GE Appliances products supporting the half-duplex GEA2 serial protocol and the full-duplex GEA3 serial protocol using the [`tiny`](https://github.com/ryanplusplus/tiny) HAL.
 
 ## Components
 ### `tiny_gea3_interface`
 Provides a simple interface for sending and receiving GEA3 serial packets.
 
+## `tiny_gea2_interface`
+Provides a simple interface for sending and receiving GEA2 serial packets on a half duplex setup.
+
 ### `tiny_erd_client`
 Provides a simple interface for reading and writing addressable data (ERDs) over a GEA3 serial interface.
 

include/i_tiny_gea_interface.h

@@ -0,0 +1,84 @@
+/*!
+ * @file
+ * @brief Simplified GEA interface that only supports sending and receiving packets.
+ *
+ * @note that this interface does not support queueing so if a new message is sent before
+ * the last send has been completed then the last send will be interrupted.
+ */
+
+#ifndef i_tiny_gea_interface_h
+#define i_tiny_gea_interface_h
+
+#include <stdbool.h>
+#include "i_tiny_event.h"
+#include "tiny_gea_packet.h"
+
+typedef struct {
+  const tiny_gea_packet_t* packet;
+} tiny_gea_interface_on_receive_args_t;
+
+typedef void (*tiny_gea_interface_send_callback_t)(void* context, tiny_gea_packet_t* packet);
+
+struct i_tiny_gea_interface_api_t;
+
+typedef struct {
+  const struct i_tiny_gea_interface_api_t* api;
+} i_tiny_gea_interface_t;
+
+typedef struct i_tiny_gea_interface_api_t {
+  bool (*send)(
+    i_tiny_gea_interface_t* self,
+    uint8_t destination,
+    uint8_t payload_length,
+    void* context,
+    tiny_gea_interface_send_callback_t callback);
+
+  bool (*forward)(
+    i_tiny_gea_interface_t* self,
+    uint8_t destination,
+    uint8_t payload_length,
+    void* context,
+    tiny_gea_interface_send_callback_t callback);
+
+  i_tiny_event_t* (*on_receive)(i_tiny_gea_interface_t* self);
+} i_tiny_gea_interface_api_t;
+
+/*!
+ * Send a packet by getting direct access to the internal send buffer (given to
+ * the client via the provided callback). Sets the source and destination addresses
+ * of the packet automatically. If the requested payload size is too large then the
+ * callback will not be invoked. Returns false if packet is dropped due to size
+ * or activity.
+ */
+static inline bool tiny_gea_interface_send(
+  i_tiny_gea_interface_t* self,
+  uint8_t destination,
+  uint8_t payload_length,
+  void* context,
+  tiny_gea_interface_send_callback_t callback)
+{
+  return self->api->send(self, destination, payload_length, context, callback);
+}
+
+/*!
+ * Send a packet without setting source address.
+ */
+static inline bool tiny_gea_interface_forward(
+  i_tiny_gea_interface_t* self,
+  uint8_t destination,
+  uint8_t payload_length,
+  void* context,
+  tiny_gea_interface_send_callback_t callback)
+{
+  return self->api->forward(self, destination, payload_length, context, callback);
+}
+
+/*!
+ * Event raised when a packet is received.
+ */
+static inline i_tiny_event_t* tiny_gea_interface_on_receive(i_tiny_gea_interface_t* self)
+{
+  return self->api->on_receive(self);
+}
+
+#endif

include/tiny_erd_client.h

@@ -7,7 +7,7 @@
 #define tiny_erd_client_h
 
 #include "i_tiny_erd_client.h"
-#include "i_tiny_gea3_interface.h"
+#include "i_tiny_gea_interface.h"
 #include "tiny_event.h"
 #include "tiny_queue.h"
 #include "tiny_ring_buffer.h"
@@ -23,7 +23,7 @@ typedef struct {
 
   tiny_event_subscription_t packet_received;
   tiny_queue_t request_queue;
-  i_tiny_gea3_interface_t* gea3_interface;
+  i_tiny_gea_interface_t* gea3_interface;
   tiny_timer_group_t* timer_group;
   tiny_timer_t request_retry_timer;
   tiny_event_t on_activity;
@@ -40,7 +40,7 @@ typedef struct {
 void tiny_erd_client_init(
   tiny_erd_client_t* self,
   tiny_timer_group_t* timer_group,
-  i_tiny_gea3_interface_t* gea3_interface,
+  i_tiny_gea_interface_t* gea3_interface,
   uint8_t* queue_buffer,
   size_t queue_buffer_size,
   const tiny_erd_client_configuration_t* configuration);

include/tiny_gea2_interface.h

@@ -0,0 +1,98 @@
+/*!
+ * @file
+ * @brief
+ *
+ * This component is interrupt-aware and handles byte transmit/receive in the
+ * interrupt context. Publication of messages is done via a background task in
+ * tiny_gea2_interface_run() so the application does not have to do
+ * anything special.
+ *
+ * Additionally, this component does not do any queueing of packets. If a send
+ * is in progress and another message is sent, then the currently sending message
+ * is discarded. In order to prevent this, clients can check whether the interface
+ * is currently sending and wait before attempting to send a packet.
+ *
+ * If a message is received, all messages received after will be dropped until
+ * tiny_gea2_interface_run() is called.
+ *
+ * Note: This module requires an interrupt event. This "interrupt" is an event
+ * that needs to happen in the same context as the `on_receive`.
+ */
+
+#ifndef tiny_gea2_interface_h
+#define tiny_gea2_interface_h
+
+#include "hal/i_tiny_uart.h"
+#include "i_tiny_gea_interface.h"
+#include "i_tiny_time_source.h"
+#include "tiny_crc16.h"
+#include "tiny_event.h"
+#include "tiny_fsm.h"
+#include "tiny_timer.h"
+
+typedef struct
+{
+  i_tiny_gea_interface_t interface;
+
+  struct
+  {
+    tiny_fsm_t fsm;
+    tiny_event_t on_receive;
+    tiny_event_t on_diagnostics_event;
+    tiny_event_subscription_t msec_interrupt_subscription;
+    tiny_event_subscription_t byte_received_subscription;
+    i_tiny_uart_t* uart;
+    tiny_timer_t timer;
+    uint8_t address;
+    bool ignore_destination_address;
+    uint8_t retries;
+    tiny_timer_group_t timer_group;
+
+    struct
+    {
+      uint8_t* buffer;
+      uint8_t buffer_size;
+      uint8_t state;
+      uint8_t offset;
+      uint16_t crc;
+      bool escaped;
+      volatile bool active;
+      volatile bool packet_queued_in_background;
+      uint8_t expected_reflection;
+      uint8_t retries;
+    } send;
+
+    struct
+    {
+      uint8_t* buffer;
+      uint16_t crc;
+      uint8_t buffer_size;
+      uint8_t count;
+      bool escaped;
+      volatile bool packet_ready;
+    } receive;
+  } _private;
+} tiny_gea2_interface_t;
+
+/*!
+ * Initialize a GEA2 interface.
+ */
+void tiny_gea2_interface_init(
+  tiny_gea2_interface_t* instance,
+  i_tiny_uart_t* uart,
+  i_tiny_time_source_t* time_source,
+  i_tiny_event_t* msec_interrupt,
+  uint8_t* receive_buffer,
+  uint8_t receive_buffer_size,
+  uint8_t* send_buffer,
+  uint8_t send_buffer_size,
+  uint8_t address,
+  bool ignore_destination_address,
+  uint8_t retries);
+
+/*!
+ * Run the interface and publish received packets.
+ */
+void tiny_gea2_interface_run(tiny_gea2_interface_t* instance);
+
+#endif

include/tiny_gea3_interface.h

@@ -17,12 +17,12 @@
 
 #include <stdint.h>
 #include "hal/i_tiny_uart.h"
-#include "i_tiny_gea3_interface.h"
+#include "i_tiny_gea_interface.h"
 #include "tiny_event.h"
 #include "tiny_queue.h"
 
 typedef struct {
-  i_tiny_gea3_interface_t interface;
+  i_tiny_gea_interface_t interface;
 
   tiny_event_t on_receive;
   tiny_event_subscription_t byte_received_subscription;