Reset some encodings

workspace/TS100/Core/Drivers/FUSB302/policy_engine.h

@@ -34,166 +34,165 @@
 #define PDB_EVT_PE_MSG_RX_PEND EVENT_MASK(7) /* Never SEND THIS DIRECTLY*/
 
 class PolicyEngine {
-  public:
-    //Sets up internal state and registers the thread
-    static void init();
-    //Push an incoming message to the Policy Engine
-    static void handleMessage(union pd_msg *msg);
-    //Send a notification
-    static void notify(uint32_t notification);
-    //Returns true if headers indicate PD3.0 compliant
-    static bool isPD3_0();
-    static bool setupCompleteOrTimedOut() {
-        if (pdNegotiationComplete)
-            return true;
-        if (state == policy_engine_state::PESinkSourceUnresponsive)
-            return true;
-        if (state == policy_engine_state::PESinkReady)
-            return true;
-        return false;
-    }
-    //Has pd negotiation completed
-    static bool pdHasNegotiated() {
-        return pdNegotiationComplete;
-    }
-
-  private:
-    static bool pdNegotiationComplete;
-    static int current_voltage_mv;    //The current voltage PD is expecting
-    static int _requested_voltage;    //The voltage the unit wanted to requests
-    static bool _unconstrained_power; // If the source is unconstrained
-    //Current message being handled
-    static union pd_msg currentMessage;
-    /* PD message header template */
-    static uint16_t hdr_template;
-    /* Whether or not we have an explicit contract */
-    static bool _explicit_contract;
-    /* The number of hard resets we've sent */
-    static int8_t _hard_reset_counter;
-    /* The result of the last Type-C Current match comparison */
-    static int8_t _old_tcc_match;
-    /* The index of the first PPS APDO */
-    static uint8_t _pps_index;
-    /* The index of the just-requested PPS APDO */
-    static uint8_t _last_pps;
-    static void pe_task(const void *arg);
-    enum policy_engine_state {
-        PESinkStartup,
-        PESinkDiscovery,
-        PESinkWaitCap,
-        PESinkEvalCap,
-        PESinkSelectCap,
-        PESinkTransitionSink,
-        PESinkReady,
-        PESinkGetSourceCap,
-        PESinkGiveSinkCap,
-        PESinkHardReset,
-        PESinkTransitionDefault,
-        PESinkSoftReset,
-        PESinkSendSoftReset,
-        PESinkSendNotSupported,
-        PESinkChunkReceived,
-        PESinkNotSupportedReceived,
-        PESinkSourceUnresponsive
-    };
-    static enum policy_engine_state pe_sink_startup();
-    static enum policy_engine_state pe_sink_discovery();
-    static enum policy_engine_state pe_sink_wait_cap();
-    static enum policy_engine_state pe_sink_eval_cap();
-    static enum policy_engine_state pe_sink_select_cap();
-    static enum policy_engine_state pe_sink_transition_sink();
-    static enum policy_engine_state pe_sink_ready();
-    static enum policy_engine_state pe_sink_get_source_cap();
-    static enum policy_engine_state pe_sink_give_sink_cap();
-    static enum policy_engine_state pe_sink_hard_reset();
-    static enum policy_engine_state pe_sink_transition_default();
-    static enum policy_engine_state pe_sink_soft_reset();
-    static enum policy_engine_state pe_sink_send_soft_reset();
-    static enum policy_engine_state pe_sink_send_not_supported();
-    static enum policy_engine_state pe_sink_chunk_received();
-    static enum policy_engine_state pe_sink_not_supported_received();
-    static enum policy_engine_state pe_sink_source_unresponsive();
-    static EventGroupHandle_t xEventGroupHandle;
-    static StaticEventGroup_t xCreatedEventGroup;
-    static uint32_t waitForEvent(uint32_t mask, TickType_t ticksToWait =
-                                                    portMAX_DELAY);
-    //Task resources
-    static osThreadId TaskHandle;
-    static const size_t TaskStackSize = 2048 / 4;
-    static uint32_t TaskBuffer[TaskStackSize];
-    static osStaticThreadDef_t TaskControlBlock;
-    static union pd_msg tempMessage;
-    static union pd_msg _last_dpm_request;
-    static policy_engine_state state;
-    //queue of up to PDB_MSG_POOL_SIZE messages to send
-    static StaticQueue_t xStaticQueue;
-    /* The array to use as the queue's storage area.  This must be at least
+public:
+	//Sets up internal state and registers the thread
+	static void init();
+	//Push an incoming message to the Policy Engine
+	static void handleMessage(union pd_msg *msg);
+	//Send a notification
+	static void notify(uint32_t notification);
+	//Returns true if headers indicate PD3.0 compliant
+	static bool isPD3_0();
+	static bool setupCompleteOrTimedOut() {
+		if (pdNegotiationComplete)
+			return true;
+		if (state == policy_engine_state::PESinkSourceUnresponsive)
+			return true;
+		if (state == policy_engine_state::PESinkReady)
+			return true;
+		return false;
+	}
+	//Has pd negotiation completed
+	static bool pdHasNegotiated() {
+		return pdNegotiationComplete;
+	}
+private:
+	static bool pdNegotiationComplete;
+	static int current_voltage_mv; //The current voltage PD is expecting
+	static int _requested_voltage; //The voltage the unit wanted to requests
+	static bool _unconstrained_power; // If the source is unconstrained
+	//Current message being handled
+	static union pd_msg currentMessage;
+	/* PD message header template */
+	static uint16_t hdr_template;
+	/* Whether or not we have an explicit contract */
+	static bool _explicit_contract;
+	/* The number of hard resets we've sent */
+	static int8_t _hard_reset_counter;
+	/* The result of the last Type-C Current match comparison */
+	static int8_t _old_tcc_match;
+	/* The index of the first PPS APDO */
+	static uint8_t _pps_index;
+	/* The index of the just-requested PPS APDO */
+	static uint8_t _last_pps;
+	static void pe_task(const void *arg);
+	enum policy_engine_state {
+		PESinkStartup,
+		PESinkDiscovery,
+		PESinkWaitCap,
+		PESinkEvalCap,
+		PESinkSelectCap,
+		PESinkTransitionSink,
+		PESinkReady,
+		PESinkGetSourceCap,
+		PESinkGiveSinkCap,
+		PESinkHardReset,
+		PESinkTransitionDefault,
+		PESinkSoftReset,
+		PESinkSendSoftReset,
+		PESinkSendNotSupported,
+		PESinkChunkReceived,
+		PESinkNotSupportedReceived,
+		PESinkSourceUnresponsive
+	};
+	static enum policy_engine_state pe_sink_startup();
+	static enum policy_engine_state pe_sink_discovery();
+	static enum policy_engine_state pe_sink_wait_cap();
+	static enum policy_engine_state pe_sink_eval_cap();
+	static enum policy_engine_state pe_sink_select_cap();
+	static enum policy_engine_state pe_sink_transition_sink();
+	static enum policy_engine_state pe_sink_ready();
+	static enum policy_engine_state pe_sink_get_source_cap();
+	static enum policy_engine_state pe_sink_give_sink_cap();
+	static enum policy_engine_state pe_sink_hard_reset();
+	static enum policy_engine_state pe_sink_transition_default();
+	static enum policy_engine_state pe_sink_soft_reset();
+	static enum policy_engine_state pe_sink_send_soft_reset();
+	static enum policy_engine_state pe_sink_send_not_supported();
+	static enum policy_engine_state pe_sink_chunk_received();
+	static enum policy_engine_state pe_sink_not_supported_received();
+	static enum policy_engine_state pe_sink_source_unresponsive();
+	static EventGroupHandle_t xEventGroupHandle;
+	static StaticEventGroup_t xCreatedEventGroup;
+	static uint32_t waitForEvent(uint32_t mask, TickType_t ticksToWait =
+	portMAX_DELAY);
+	//Task resources
+	static osThreadId TaskHandle;
+	static const size_t TaskStackSize = 2048 / 4;
+	static uint32_t TaskBuffer[TaskStackSize];
+	static osStaticThreadDef_t TaskControlBlock;
+	static union pd_msg tempMessage;
+	static union pd_msg _last_dpm_request;
+	static policy_engine_state state;
+	//queue of up to PDB_MSG_POOL_SIZE messages to send
+	static StaticQueue_t xStaticQueue;
+	/* The array to use as the queue's storage area.  This must be at least
 	 uxQueueLength * uxItemSize bytes. */
-    static uint8_t ucQueueStorageArea[PDB_MSG_POOL_SIZE * sizeof(union pd_msg)];
-    static QueueHandle_t messagesWaiting;
-    static bool messageWaiting();
-    //Read a pending message into the temp message
-    static bool readMessage();
+	static uint8_t ucQueueStorageArea[PDB_MSG_POOL_SIZE * sizeof(union pd_msg)];
+	static QueueHandle_t messagesWaiting;
+	static bool messageWaiting();
+//Read a pending message into the temp message
+	static bool readMessage();
 
-    // These callbacks are called to implement the logic for the iron to select the desired voltage
+	// These callbacks are called to implement the logic for the iron to select the desired voltage
 
-    /*
+	/*
 	 * Create a Request message based on the given Source_Capabilities message.  If
 	 * capabilities is NULL, the last non-null Source_Capabilities message passes
 	 * is used.  If none has been provided, the behavior is undefined.
 	 *
 	 * Returns true if sufficient power is available, false otherwise.
 	 */
-    static bool pdbs_dpm_evaluate_capability(const union pd_msg *capabilities,
-                                             union pd_msg *request);
+	static bool pdbs_dpm_evaluate_capability(const union pd_msg *capabilities,
+			union pd_msg *request);
 
-    /*
+	/*
 	 * Create a Sink_Capabilities message for our current capabilities.
 	 */
-    static void pdbs_dpm_get_sink_capability(union pd_msg *cap);
+	static void pdbs_dpm_get_sink_capability(union pd_msg *cap);
 
-    /*
+	/*
 	 * Return whether or not GiveBack support is enabled.
 	 */
-    static bool pdbs_dpm_giveback_enabled();
+	static bool pdbs_dpm_giveback_enabled();
 
-    /*
+	/*
 	 * Evaluate whether or not the currently offered Type-C Current can fulfill our
 	 * power needs.
 	 *
 	 * Returns true if sufficient power is available, false otherwise.
 	 */
-    static bool pdbs_dpm_evaluate_typec_current(enum fusb_typec_current tcc);
+	static bool pdbs_dpm_evaluate_typec_current(enum fusb_typec_current tcc);
 
-    /*
+	/*
 	 * Indicate that power negotiations are starting.
 	 */
-    static void pdbs_dpm_pd_start();
+	static void pdbs_dpm_pd_start();
 
-    /*
+	/*
 	 * Transition the sink to default power.
 	 */
-    static void pdbs_dpm_transition_default();
+	static void pdbs_dpm_transition_default();
 
-    /*
+	/*
 	 * Transition to the requested minimum current.
 	 */
-    static void pdbs_dpm_transition_min();
+	static void pdbs_dpm_transition_min();
 
-    /*
+	/*
 	 * Transition to Sink Standby if necessary.
 	 */
-    static void pdbs_dpm_transition_standby();
+	static void pdbs_dpm_transition_standby();
 
-    /*
+	/*
 	 * Transition to the requested power level
 	 */
-    static void pdbs_dpm_transition_requested();
+	static void pdbs_dpm_transition_requested();
 
-    /*
+	/*
 	 * Transition to the Type-C Current power level
 	 */
-    static void pdbs_dpm_transition_typec();
+	static void pdbs_dpm_transition_typec();
 };
 
 #endif /* PDB_POLICY_ENGINE_H */

workspace/TS100/Core/Drivers/FUSB302/protocol_rx.cpp

@@ -17,12 +17,12 @@
 
 #include "protocol_rx.h"
 
-#include "fusb302b.h"
-#include "policy_engine.h"
-#include "protocol_tx.h"
+#include <stdlib.h>
 #include "string.h"
 #include <pd.h>
-#include <stdlib.h>
+#include "policy_engine.h"
+#include "protocol_tx.h"
+#include "fusb302b.h"
 osThreadId ProtocolReceive::TaskHandle = NULL;
 EventGroupHandle_t ProtocolReceive::xEventGroupHandle = NULL;
 StaticEventGroup_t ProtocolReceive::xCreatedEventGroup;
@@ -35,154 +35,155 @@ uint8_t ProtocolReceive::_tx_messageidcounter;
  * PRL_Rx_Wait_for_PHY_Message state
  */
 ProtocolReceive::protocol_rx_state ProtocolReceive::protocol_rx_wait_phy() {
-    /* Wait for an event */
-    _rx_messageid = 0;
-    eventmask_t evt = waitForEvent(
-        PDB_EVT_PRLRX_RESET | PDB_EVT_PRLRX_I_GCRCSENT | PDB_EVT_PRLRX_I_RXPEND);
+	/* Wait for an event */
+	_rx_messageid = 0;
+	eventmask_t evt = waitForEvent(
+	PDB_EVT_PRLRX_RESET | PDB_EVT_PRLRX_I_GCRCSENT | PDB_EVT_PRLRX_I_RXPEND);
 
-    /* If we got a reset event, reset */
-    if (evt & PDB_EVT_PRLRX_RESET) {
-        waitForEvent(PDB_EVT_PRLRX_RESET, 0);
-        return PRLRxWaitPHY;
-    }
-    /* If we got an I_GCRCSENT event, read the message and decide what to do */
-    if (evt & PDB_EVT_PRLRX_I_GCRCSENT) {
-        /* Get a buffer to read the message into.  Guaranteed to not fail
+	/* If we got a reset event, reset */
+	if (evt & PDB_EVT_PRLRX_RESET) {
+		waitForEvent(PDB_EVT_PRLRX_RESET, 0);
+		return PRLRxWaitPHY;
+	}
+	/* If we got an I_GCRCSENT event, read the message and decide what to do */
+	if (evt & PDB_EVT_PRLRX_I_GCRCSENT) {
+		/* Get a buffer to read the message into.  Guaranteed to not fail
 		 * because we have a big enough pool and are careful. */
-        union pd_msg *_rx_message = &tempMessage;
-        memset(&tempMessage, 0, sizeof(tempMessage));
-        /* Read the message */
-        fusb_read_message(_rx_message);
-        /* If it's a Soft_Reset, go to the soft reset state */
-        if (PD_MSGTYPE_GET(_rx_message) == PD_MSGTYPE_SOFT_RESET && PD_NUMOBJ_GET(_rx_message) == 0) {
-            return PRLRxReset;
-        } else {
-            /* Otherwise, check the message ID */
-            return PRLRxCheckMessageID;
-        }
-    } else if (evt & PDB_EVT_PRLRX_I_RXPEND) {
-        //There is an RX message pending that is not a Good CRC
-        union pd_msg *_rx_message = &tempMessage;
-        /* Read the message */
-        fusb_read_message(_rx_message);
-        return PRLRxWaitPHY;
-    }
+		union pd_msg *_rx_message = &tempMessage;
+		memset(&tempMessage, 0, sizeof(tempMessage));
+		/* Read the message */
+		fusb_read_message(_rx_message);
+		/* If it's a Soft_Reset, go to the soft reset state */
+		if (PD_MSGTYPE_GET(_rx_message) == PD_MSGTYPE_SOFT_RESET
+				&& PD_NUMOBJ_GET(_rx_message) == 0) {
+			return PRLRxReset;
+		} else {
+			/* Otherwise, check the message ID */
+			return PRLRxCheckMessageID;
+		}
+	} else if (evt & PDB_EVT_PRLRX_I_RXPEND) {
+		//There is an RX message pending that is not a Good CRC
+		union pd_msg *_rx_message = &tempMessage;
+		/* Read the message */
+		fusb_read_message(_rx_message);
+		return PRLRxWaitPHY;
+	}
 
-    return PRLRxWaitPHY;
+	return PRLRxWaitPHY;
 }
 
 /*
  * PRL_Rx_Layer_Reset_for_Receive state
  */
 ProtocolReceive::protocol_rx_state ProtocolReceive::protocol_rx_reset() {
-    /* Reset MessageIDCounter */
-    _tx_messageidcounter = 0;
+	/* Reset MessageIDCounter */
+	_tx_messageidcounter = 0;
 
-    /* Clear stored MessageID */
-    _rx_messageid = -1;
+	/* Clear stored MessageID */
+	_rx_messageid = -1;
 
-    /* TX transitions to its reset state */
-    ProtocolTransmit::notify(
-        ProtocolTransmit::Notifications::PDB_EVT_PRLTX_RESET);
-    taskYIELD();
+	/* TX transitions to its reset state */
+	ProtocolTransmit::notify(
+			ProtocolTransmit::Notifications::PDB_EVT_PRLTX_RESET);
+	taskYIELD();
 
-    /* If we got a RESET signal, reset the machine */
-    if (waitForEvent(PDB_EVT_PRLRX_RESET, 0) != 0) {
-        return PRLRxWaitPHY;
-    }
+	/* If we got a RESET signal, reset the machine */
+	if (waitForEvent(PDB_EVT_PRLRX_RESET, 0) != 0) {
+		return PRLRxWaitPHY;
+	}
 
-    /* Go to the Check_MessageID state */
-    return PRLRxCheckMessageID;
+	/* Go to the Check_MessageID state */
+	return PRLRxCheckMessageID;
 }
 volatile uint32_t rxCounter = 0;
 /*
  * PRL_Rx_Check_MessageID state
  */
 ProtocolReceive::protocol_rx_state ProtocolReceive::protocol_rx_check_messageid() {
-    /* If we got a RESET signal, reset the machine */
-    //	if (waitForEvent(PDB_EVT_PRLRX_RESET, 0) == PDB_EVT_PRLRX_RESET) {
-    //		return PRLRxWaitPHY;
-    //	}
-    /* If the message has the stored ID, we've seen this message before.  Free
+	/* If we got a RESET signal, reset the machine */
+//	if (waitForEvent(PDB_EVT_PRLRX_RESET, 0) == PDB_EVT_PRLRX_RESET) {
+//		return PRLRxWaitPHY;
+//	}
+	/* If the message has the stored ID, we've seen this message before.  Free
 	 * it and don't pass it to the policy engine. */
 
-    /* Otherwise, there's either no stored ID or this message has an ID we
+	/* Otherwise, there's either no stored ID or this message has an ID we
 	 * haven't just seen.  Transition to the Store_MessageID state. */
-    //	if (PD_MESSAGEID_GET(&tempMessage) == _rx_messageid) {
-    //		return PRLRxWaitPHY;
-    //	} else
-    {
-        rxCounter++;
-        return PRLRxStoreMessageID;
-    }
+//	if (PD_MESSAGEID_GET(&tempMessage) == _rx_messageid) {
+//		return PRLRxWaitPHY;
+//	} else
+	{
+		rxCounter++;
+		return PRLRxStoreMessageID;
+	}
 }
 
 /*
  * PRL_Rx_Store_MessageID state
  */
 ProtocolReceive::protocol_rx_state ProtocolReceive::protocol_rx_store_messageid() {
-    /* Tell ProtocolTX to discard the message being transmitted */
+	/* Tell ProtocolTX to discard the message being transmitted */
 
-    ProtocolTransmit::notify(
-        ProtocolTransmit::Notifications::PDB_EVT_PRLTX_DISCARD);
+	ProtocolTransmit::notify(
+			ProtocolTransmit::Notifications::PDB_EVT_PRLTX_DISCARD);
 
-    /* Update the stored MessageID */
-    _rx_messageid = PD_MESSAGEID_GET(&tempMessage);
+	/* Update the stored MessageID */
+	_rx_messageid = PD_MESSAGEID_GET(&tempMessage);
 
-    /* Pass the message to the policy engine. */
+	/* Pass the message to the policy engine. */
 
-    PolicyEngine::handleMessage(&tempMessage);
-    PolicyEngine::notify(PDB_EVT_PE_MSG_RX);
-    taskYIELD();
-    /* Don't check if we got a RESET because we'd do nothing different. */
+	PolicyEngine::handleMessage(&tempMessage);
+	PolicyEngine::notify(PDB_EVT_PE_MSG_RX);
+	taskYIELD();
+	/* Don't check if we got a RESET because we'd do nothing different. */
 
-    return PRLRxWaitPHY;
+	return PRLRxWaitPHY;
 }
 
 void ProtocolReceive::init() {
-    osThreadStaticDef(protRX, thread, PDB_PRIO_PRL, 0, TaskStackSize,
-                      TaskBuffer, &TaskControlBlock);
-    xEventGroupHandle = xEventGroupCreateStatic(&xCreatedEventGroup);
-    TaskHandle = osThreadCreate(osThread(protRX), NULL);
+	osThreadStaticDef(protRX, thread, PDB_PRIO_PRL, 0, TaskStackSize,
+			TaskBuffer, &TaskControlBlock);
+	xEventGroupHandle = xEventGroupCreateStatic(&xCreatedEventGroup);
+	TaskHandle = osThreadCreate(osThread(protRX), NULL);
 }
 
 void ProtocolReceive::thread(const void *args) {
-    (void)args;
-    ProtocolReceive::protocol_rx_state state = PRLRxWaitPHY;
+	(void) args;
+	ProtocolReceive::protocol_rx_state state = PRLRxWaitPHY;
 
-    while (true) {
-        switch (state) {
-        case PRLRxWaitPHY:
-            state = protocol_rx_wait_phy();
-            break;
-        case PRLRxReset:
-            state = protocol_rx_reset();
-            break;
-        case PRLRxCheckMessageID:
-            state = protocol_rx_check_messageid();
-            break;
-        case PRLRxStoreMessageID:
-            state = protocol_rx_store_messageid();
-            break;
-        default:
-            /* This is an error.  It really shouldn't happen.  We might
+	while (true) {
+		switch (state) {
+		case PRLRxWaitPHY:
+			state = protocol_rx_wait_phy();
+			break;
+		case PRLRxReset:
+			state = protocol_rx_reset();
+			break;
+		case PRLRxCheckMessageID:
+			state = protocol_rx_check_messageid();
+			break;
+		case PRLRxStoreMessageID:
+			state = protocol_rx_store_messageid();
+			break;
+		default:
+			/* This is an error.  It really shouldn't happen.  We might
 			 * want to handle it anyway, though. */
-            state = PRLRxWaitPHY;
-            break;
-        }
-    }
+			state = PRLRxWaitPHY;
+			break;
+		}
+	}
 }
 
 void ProtocolReceive::notify(uint32_t notification) {
-    if (xEventGroupHandle != NULL) {
-        xEventGroupSetBits(xEventGroupHandle, notification);
-    }
+	if (xEventGroupHandle != NULL) {
+		xEventGroupSetBits(xEventGroupHandle, notification);
+	}
 }
 
 uint32_t ProtocolReceive::waitForEvent(uint32_t mask, TickType_t ticksToWait) {
-    if (xEventGroupHandle != NULL) {
-        return xEventGroupWaitBits(xEventGroupHandle, mask, mask,
-                                   pdFALSE, ticksToWait);
-    }
-    return 0;
+	if (xEventGroupHandle != NULL) {
+		return xEventGroupWaitBits(xEventGroupHandle, mask, mask,
+		pdFALSE, ticksToWait);
+	}
+	return 0;
 }

workspace/TS100/Core/Drivers/FUSB302/protocol_rx.h

@@ -28,40 +28,37 @@
 #define PDB_EVT_PRLRX_I_RXPEND EVENT_MASK(2)
 
 class ProtocolReceive {
-  public:
-    static void init();
-    static void notify(uint32_t notification);
+public:
+	static void init();
+	static void notify(uint32_t notification);
+private:
+	static void thread(const void *args);
 
-  private:
-    static void thread(const void *args);
-
-    static EventGroupHandle_t xEventGroupHandle;
-    static StaticEventGroup_t xCreatedEventGroup;
-    static osThreadId TaskHandle;
-    static const size_t TaskStackSize = 1024 / 4;
-    static uint32_t TaskBuffer[TaskStackSize];
-    static osStaticThreadDef_t TaskControlBlock;
-    /*
+	static EventGroupHandle_t xEventGroupHandle;
+	static StaticEventGroup_t xCreatedEventGroup;
+	static osThreadId TaskHandle;
+	static const size_t TaskStackSize = 1024 / 4;
+	static uint32_t TaskBuffer[TaskStackSize];
+	static osStaticThreadDef_t TaskControlBlock;
+	/*
 	 * Protocol RX machine states
 	 *
 	 * There is no Send_GoodCRC state because the PHY sends the GoodCRC for us.
 	 * All transitions that would go to that state instead go to Check_MessageID.
 	 */
-    enum protocol_rx_state {
-        PRLRxWaitPHY,
-        PRLRxReset,
-        PRLRxCheckMessageID,
-        PRLRxStoreMessageID
-    };
-    static protocol_rx_state protocol_rx_store_messageid();
-    static protocol_rx_state protocol_rx_check_messageid();
-    static protocol_rx_state protocol_rx_reset();
-    static protocol_rx_state protocol_rx_wait_phy();
-    static union pd_msg tempMessage;
-    static uint8_t _rx_messageid;
-    static uint8_t _tx_messageidcounter;
-    static uint32_t waitForEvent(uint32_t mask, TickType_t ticksToWait =
-                                                    portMAX_DELAY);
+	enum protocol_rx_state {
+		PRLRxWaitPHY, PRLRxReset, PRLRxCheckMessageID, PRLRxStoreMessageID
+	};
+	static protocol_rx_state protocol_rx_store_messageid();
+	static protocol_rx_state protocol_rx_check_messageid();
+	static protocol_rx_state protocol_rx_reset();
+	static protocol_rx_state protocol_rx_wait_phy();
+	static union pd_msg tempMessage;
+	static uint8_t _rx_messageid;
+	static uint8_t _tx_messageidcounter;
+	static uint32_t waitForEvent(uint32_t mask, TickType_t ticksToWait =
+	portMAX_DELAY);
+
 };
 
 #endif /* PDB_PROTOCOL_RX_H */

workspace/TS100/Core/Drivers/FUSB302/protocol_tx.cpp

@@ -16,18 +16,19 @@
  */
 
 #include "protocol_tx.h"
-#include "fusb302b.h"
-#include "fusbpd.h"
+#include <pd.h>
 #include "policy_engine.h"
 #include "protocol_rx.h"
-#include <pd.h>
+#include "fusb302b.h"
+#include "fusbpd.h"
 
 osThreadId ProtocolTransmit::TaskHandle = NULL;
 uint32_t ProtocolTransmit::TaskBuffer[ProtocolTransmit::TaskStackSize];
 osStaticThreadDef_t ProtocolTransmit::TaskControlBlock;
 StaticQueue_t ProtocolTransmit::xStaticQueue;
 bool ProtocolTransmit::messageSending = false;
-uint8_t ProtocolTransmit::ucQueueStorageArea[PDB_MSG_POOL_SIZE * sizeof(union pd_msg)];
+uint8_t ProtocolTransmit::ucQueueStorageArea[PDB_MSG_POOL_SIZE
+		* sizeof(union pd_msg)];
 QueueHandle_t ProtocolTransmit::messagesWaiting = NULL;
 uint8_t ProtocolTransmit::_tx_messageidcounter;
 union pd_msg ProtocolTransmit::temp_msg;
@@ -37,253 +38,261 @@ StaticEventGroup_t ProtocolTransmit::xCreatedEventGroup;
  * PRL_Tx_PHY_Layer_Reset state
  */
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_phy_reset() {
-    /* Reset the PHY */
-    fusb_reset();
+	/* Reset the PHY */
+	fusb_reset();
 
-    /* If a message was pending when we got here, tell the policy engine that
+	/* If a message was pending when we got here, tell the policy engine that
 	 * we failed to send it */
-    if (messagePending()) {
-        /* Tell the policy engine that we failed */
-        PolicyEngine::notify(PDB_EVT_PE_TX_ERR);
-        /* Finish failing to send the message */
-        while (messagePending()) {
-            getMessage(); //Discard
-        }
-    }
+	if (messagePending()) {
+		/* Tell the policy engine that we failed */
+		PolicyEngine::notify( PDB_EVT_PE_TX_ERR);
+		/* Finish failing to send the message */
+		while (messagePending()) {
+			getMessage(); //Discard
+		}
+	}
 
-    /* Wait for a message request */
-    return PRLTxWaitMessage;
+	/* Wait for a message request */
+	return PRLTxWaitMessage;
 }
 
 /*
  * PRL_Tx_Wait_for_Message_Request state
  */
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_wait_message() {
-    /* Wait for an event */
-    ProtocolTransmit::Notifications evt = waitForEvent(
-        (uint32_t)Notifications::PDB_EVT_PRLTX_RESET | (uint32_t)Notifications::PDB_EVT_PRLTX_DISCARD | (uint32_t)Notifications::PDB_EVT_PRLTX_MSG_TX);
+	/* Wait for an event */
+	ProtocolTransmit::Notifications evt = waitForEvent(
+			(uint32_t) Notifications::PDB_EVT_PRLTX_RESET
+					| (uint32_t) Notifications::PDB_EVT_PRLTX_DISCARD
+					| (uint32_t) Notifications::PDB_EVT_PRLTX_MSG_TX);
 
-    if ((uint32_t)evt & (uint32_t)Notifications::PDB_EVT_PRLTX_RESET) {
-        return PRLTxPHYReset;
-    }
+	if ((uint32_t) evt & (uint32_t) Notifications::PDB_EVT_PRLTX_RESET) {
+		return PRLTxPHYReset;
+	}
 
-    /* If the policy engine is trying to send a message */
-    if ((uint32_t)evt & (uint32_t)Notifications::PDB_EVT_PRLTX_MSG_TX) {
-        /* Get the message */
-        getMessage();
+	/* If the policy engine is trying to send a message */
+	if ((uint32_t) evt & (uint32_t) Notifications::PDB_EVT_PRLTX_MSG_TX) {
+		/* Get the message */
+		getMessage();
 
-        /* If it's a Soft_Reset, reset the TX layer first */
-        if (PD_MSGTYPE_GET(&temp_msg) == PD_MSGTYPE_SOFT_RESET && PD_NUMOBJ_GET(&(temp_msg)) == 0) {
-            return PRLTxReset;
-            /* Otherwise, just send the message */
-        } else {
-            return PRLTxConstructMessage;
-        }
-    }
+		/* If it's a Soft_Reset, reset the TX layer first */
+		if (PD_MSGTYPE_GET(&temp_msg) == PD_MSGTYPE_SOFT_RESET
+				&& PD_NUMOBJ_GET(&(temp_msg)) == 0) {
+			return PRLTxReset;
+			/* Otherwise, just send the message */
+		} else {
+			return PRLTxConstructMessage;
+		}
+	}
 
-    /* Silence the compiler warning */
-    return PRLTxWaitMessage;
+	/* Silence the compiler warning */
+	return PRLTxWaitMessage;
 }
 
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_reset() {
-    /* Clear MessageIDCounter */
-    _tx_messageidcounter = 0;
+	/* Clear MessageIDCounter */
+	_tx_messageidcounter = 0;
 
-    /* Tell the Protocol RX thread to reset */
-    ProtocolReceive::notify(PDB_EVT_PRLRX_RESET);
-    taskYIELD();
+	/* Tell the Protocol RX thread to reset */
+	ProtocolReceive::notify( PDB_EVT_PRLRX_RESET);
+	taskYIELD();
 
-    return PRLTxConstructMessage;
+	return PRLTxConstructMessage;
 }
 
 /*
  * PRL_Tx_Construct_Message state
  */
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_construct_message() {
-    /* Set the correct MessageID in the message */
-    temp_msg.hdr &= ~PD_HDR_MESSAGEID;
-    temp_msg.hdr |= (_tx_messageidcounter % 8) << PD_HDR_MESSAGEID_SHIFT;
+	/* Set the correct MessageID in the message */
+	temp_msg.hdr &= ~PD_HDR_MESSAGEID;
+	temp_msg.hdr |= (_tx_messageidcounter % 8) << PD_HDR_MESSAGEID_SHIFT;
 
-    /* PD 3.0 collision avoidance */
-    //	if (PolicyEngine::isPD3_0()) {
-    //		/* If we're starting an AMS, wait for permission to transmit */
-    //		evt = waitForEvent((uint32_t) Notifications::PDB_EVT_PRLTX_START_AMS,
-    //				0);
-    //		if ((uint32_t) evt
-    //				& (uint32_t) Notifications::PDB_EVT_PRLTX_START_AMS) {
-    //			while (fusb_get_typec_current() != fusb_sink_tx_ok) {
-    //				osDelay(1);
-    //			}
-    //		}
-    //	}
-    messageSending = true;
-    /* Send the message to the PHY */
-    fusb_send_message(&temp_msg);
+	/* PD 3.0 collision avoidance */
+//	if (PolicyEngine::isPD3_0()) {
+//		/* If we're starting an AMS, wait for permission to transmit */
+//		evt = waitForEvent((uint32_t) Notifications::PDB_EVT_PRLTX_START_AMS,
+//				0);
+//		if ((uint32_t) evt
+//				& (uint32_t) Notifications::PDB_EVT_PRLTX_START_AMS) {
+//			while (fusb_get_typec_current() != fusb_sink_tx_ok) {
+//				osDelay(1);
+//			}
+//		}
+//	}
+	messageSending = true;
+	/* Send the message to the PHY */
+	fusb_send_message(&temp_msg);
 
-    return PRLTxWaitResponse;
+	return PRLTxWaitResponse;
 }
 
 /*
  * PRL_Tx_Wait_for_PHY_Response state
  */
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_wait_response() {
-    /* Wait for an event.  There is no need to run CRCReceiveTimer, since the
+	/* Wait for an event.  There is no need to run CRCReceiveTimer, since the
 	 * FUSB302B handles that as part of its retry mechanism. */
-    ProtocolTransmit::Notifications evt = waitForEvent(
-        (uint32_t)Notifications::PDB_EVT_PRLTX_RESET | (uint32_t)Notifications::PDB_EVT_PRLTX_DISCARD | (uint32_t)Notifications::PDB_EVT_PRLTX_I_TXSENT | (uint32_t)Notifications::PDB_EVT_PRLTX_I_RETRYFAIL);
+	ProtocolTransmit::Notifications evt = waitForEvent(
+			(uint32_t) Notifications::PDB_EVT_PRLTX_RESET
+					| (uint32_t) Notifications::PDB_EVT_PRLTX_DISCARD
+					| (uint32_t) Notifications::PDB_EVT_PRLTX_I_TXSENT
+					| (uint32_t) Notifications::PDB_EVT_PRLTX_I_RETRYFAIL);
 
-    if ((uint32_t)evt & (uint32_t)Notifications::PDB_EVT_PRLTX_RESET) {
-        return PRLTxPHYReset;
-    }
-    if ((uint32_t)evt & (uint32_t)Notifications::PDB_EVT_PRLTX_DISCARD) {
-        return PRLTxDiscardMessage;
-    }
+	if ((uint32_t) evt & (uint32_t) Notifications::PDB_EVT_PRLTX_RESET) {
+		return PRLTxPHYReset;
+	}
+	if ((uint32_t) evt & (uint32_t) Notifications::PDB_EVT_PRLTX_DISCARD) {
+		return PRLTxDiscardMessage;
+	}
 
-    /* If the message was sent successfully */
-    if ((uint32_t)evt & (uint32_t)Notifications::PDB_EVT_PRLTX_I_TXSENT) {
-        return PRLTxMatchMessageID;
-    }
-    /* If the message failed to be sent */
-    if ((uint32_t)evt & (uint32_t)Notifications::PDB_EVT_PRLTX_I_RETRYFAIL) {
-        return PRLTxTransmissionError;
-    }
+	/* If the message was sent successfully */
+	if ((uint32_t) evt & (uint32_t) Notifications::PDB_EVT_PRLTX_I_TXSENT) {
+		return PRLTxMatchMessageID;
+	}
+	/* If the message failed to be sent */
+	if ((uint32_t) evt & (uint32_t) Notifications::PDB_EVT_PRLTX_I_RETRYFAIL) {
+		return PRLTxTransmissionError;
+	}
 
-    /* Silence the compiler warning */
-    return PRLTxDiscardMessage;
+	/* Silence the compiler warning */
+	return PRLTxDiscardMessage;
 }
 
 /*
  * PRL_Tx_Match_MessageID state
  */
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_match_messageid() {
-    union pd_msg goodcrc;
+	union pd_msg goodcrc;
 
-    /* Read the GoodCRC */
-    fusb_read_message(&goodcrc);
+	/* Read the GoodCRC */
+	fusb_read_message(&goodcrc);
 
-    /* Check that the message is correct */
-    if (PD_MSGTYPE_GET(&goodcrc) == PD_MSGTYPE_GOODCRC && PD_NUMOBJ_GET(&goodcrc) == 0 && PD_MESSAGEID_GET(&goodcrc) == _tx_messageidcounter) {
-        return PRLTxMessageSent;
-    } else {
-        return PRLTxTransmissionError;
-    }
+	/* Check that the message is correct */
+	if (PD_MSGTYPE_GET(&goodcrc) == PD_MSGTYPE_GOODCRC
+			&& PD_NUMOBJ_GET(&goodcrc) == 0
+			&& PD_MESSAGEID_GET(&goodcrc) == _tx_messageidcounter) {
+		return PRLTxMessageSent;
+	} else {
+		return PRLTxTransmissionError;
+	}
 }
 
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_transmission_error() {
-    /* Increment MessageIDCounter */
-    _tx_messageidcounter = (_tx_messageidcounter + 1) % 8;
+	/* Increment MessageIDCounter */
+	_tx_messageidcounter = (_tx_messageidcounter + 1) % 8;
 
-    /* Tell the policy engine that we failed */
-    PolicyEngine::notify(PDB_EVT_PE_TX_ERR);
+	/* Tell the policy engine that we failed */
+	PolicyEngine::notify( PDB_EVT_PE_TX_ERR);
 
-    return PRLTxWaitMessage;
+	return PRLTxWaitMessage;
 }
 
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_message_sent() {
-    messageSending = false;
-    /* Increment MessageIDCounter */
-    _tx_messageidcounter = (_tx_messageidcounter + 1) % 8;
+	messageSending = false;
+	/* Increment MessageIDCounter */
+	_tx_messageidcounter = (_tx_messageidcounter + 1) % 8;
 
-    /* Tell the policy engine that we succeeded */
-    PolicyEngine::notify(PDB_EVT_PE_TX_DONE);
+	/* Tell the policy engine that we succeeded */
+	PolicyEngine::notify( PDB_EVT_PE_TX_DONE);
 
-    return PRLTxWaitMessage;
+	return PRLTxWaitMessage;
 }
 
 ProtocolTransmit::protocol_tx_state ProtocolTransmit::protocol_tx_discard_message() {
-    /* If we were working on sending a message, increment MessageIDCounter */
-    if (messageSending) {
-        _tx_messageidcounter = (_tx_messageidcounter + 1) % 8;
+	/* If we were working on sending a message, increment MessageIDCounter */
+	if (messageSending) {
+		_tx_messageidcounter = (_tx_messageidcounter + 1) % 8;
 
-        return PRLTxPHYReset;
-    } else {
-        return PRLTxWaitMessage;
-    }
+		return PRLTxPHYReset;
+	} else {
+		return PRLTxWaitMessage;
+	}
 }
 void ProtocolTransmit::thread(const void *args) {
-    (void)args;
-    ProtocolTransmit::protocol_tx_state state = PRLTxPHYReset;
+	(void) args;
+	ProtocolTransmit::protocol_tx_state state = PRLTxPHYReset;
 
-    //Init the incoming message queue
+	//Init the incoming message queue
 
-    while (true) {
-        switch (state) {
-        case PRLTxPHYReset:
-            state = protocol_tx_phy_reset();
-            break;
-        case PRLTxWaitMessage:
-            state = protocol_tx_wait_message();
-            break;
-        case PRLTxReset:
-            state = protocol_tx_reset();
-            break;
-        case PRLTxConstructMessage:
-            state = protocol_tx_construct_message();
-            break;
-        case PRLTxWaitResponse:
-            state = protocol_tx_wait_response();
-            break;
-        case PRLTxMatchMessageID:
-            state = protocol_tx_match_messageid();
-            break;
-        case PRLTxTransmissionError:
-            state = protocol_tx_transmission_error();
-            break;
-        case PRLTxMessageSent:
-            state = protocol_tx_message_sent();
-            break;
-        case PRLTxDiscardMessage:
-            state = protocol_tx_discard_message();
-            break;
-        default:
-            state = PRLTxPHYReset;
-            break;
-        }
-    }
+	while (true) {
+		switch (state) {
+		case PRLTxPHYReset:
+			state = protocol_tx_phy_reset();
+			break;
+		case PRLTxWaitMessage:
+			state = protocol_tx_wait_message();
+			break;
+		case PRLTxReset:
+			state = protocol_tx_reset();
+			break;
+		case PRLTxConstructMessage:
+			state = protocol_tx_construct_message();
+			break;
+		case PRLTxWaitResponse:
+			state = protocol_tx_wait_response();
+			break;
+		case PRLTxMatchMessageID:
+			state = protocol_tx_match_messageid();
+			break;
+		case PRLTxTransmissionError:
+			state = protocol_tx_transmission_error();
+			break;
+		case PRLTxMessageSent:
+			state = protocol_tx_message_sent();
+			break;
+		case PRLTxDiscardMessage:
+			state = protocol_tx_discard_message();
+			break;
+		default:
+			state = PRLTxPHYReset;
+			break;
+		}
+	}
 }
 
 void ProtocolTransmit::notify(ProtocolTransmit::Notifications notification) {
-    if (xEventGroupHandle != NULL) {
-        xEventGroupSetBits(xEventGroupHandle, (uint32_t)notification);
-    }
+	if (xEventGroupHandle != NULL) {
+		xEventGroupSetBits(xEventGroupHandle, (uint32_t) notification);
+	}
 }
 
 void ProtocolTransmit::init() {
-    messagesWaiting = xQueueCreateStatic(PDB_MSG_POOL_SIZE,
-                                         sizeof(union pd_msg), ucQueueStorageArea, &xStaticQueue);
+	messagesWaiting = xQueueCreateStatic(PDB_MSG_POOL_SIZE,
+			sizeof(union pd_msg), ucQueueStorageArea, &xStaticQueue);
 
-    osThreadStaticDef(pd_txTask, thread, PDB_PRIO_PRL, 0, TaskStackSize,
-                      TaskBuffer, &TaskControlBlock);
-    TaskHandle = osThreadCreate(osThread(pd_txTask), NULL);
-    xEventGroupHandle = xEventGroupCreateStatic(&xCreatedEventGroup);
+	osThreadStaticDef(pd_txTask, thread, PDB_PRIO_PRL, 0, TaskStackSize,
+			TaskBuffer, &TaskControlBlock);
+	TaskHandle = osThreadCreate(osThread(pd_txTask), NULL);
+	xEventGroupHandle = xEventGroupCreateStatic(&xCreatedEventGroup);
 }
 
 void ProtocolTransmit::pushMessage(union pd_msg *msg) {
-    if (messagesWaiting) {
-        xQueueSend(messagesWaiting, msg, 100);
-    }
+	if (messagesWaiting) {
+		xQueueSend(messagesWaiting, msg, 100);
+	}
 }
 
 bool ProtocolTransmit::messagePending() {
-    if (messagesWaiting) {
-        return uxQueueMessagesWaiting(messagesWaiting) > 0;
-    }
-    return false;
+	if (messagesWaiting) {
+		return uxQueueMessagesWaiting(messagesWaiting) > 0;
+	}
+	return false;
 }
 
 void ProtocolTransmit::getMessage() {
-    //Loads the pending message into the buffer
-    if (messagesWaiting) {
-        xQueueReceive(messagesWaiting, &temp_msg, 1);
-    }
+	//Loads the pending message into the buffer
+	if (messagesWaiting) {
+		xQueueReceive(messagesWaiting, &temp_msg, 1);
+	}
 }
 
 ProtocolTransmit::Notifications ProtocolTransmit::waitForEvent(uint32_t mask,
-                                                               TickType_t ticksToWait) {
-    if (xEventGroupHandle) {
-        return (Notifications)xEventGroupWaitBits(xEventGroupHandle, mask,
-                                                  mask,
-                                                  pdFALSE, ticksToWait);
-    }
-    return (Notifications)0;
+		TickType_t ticksToWait) {
+	if (xEventGroupHandle) {
+		return (Notifications) xEventGroupWaitBits(xEventGroupHandle, mask,
+				mask,
+				pdFALSE, ticksToWait);
+	}
+	return (Notifications)0;
 }

workspace/TS100/Core/Drivers/FUSB302/protocol_tx.h

@@ -18,80 +18,80 @@
 #ifndef PDB_PROTOCOL_TX_H
 #define PDB_PROTOCOL_TX_H
 
+#include <stdint.h>
 #include "policy_engine.h"
 #include "protocol_rx.h"
 #include <pd.h>
-#include <stdint.h>
 
 /* Events for the Protocol TX thread */
 
 class ProtocolTransmit {
-  public:
-    static void init();
-    //Push a message to the queue to be sent out the pd comms bus
-    static void pushMessage(union pd_msg *msg);
+public:
+	static void init();
+	//Push a message to the queue to be sent out the pd comms bus
+	static void pushMessage(union pd_msg *msg);
 
-    enum class Notifications {
+	enum class Notifications {
 
-        PDB_EVT_PRLTX_RESET = EVENT_MASK(0),       //
-        PDB_EVT_PRLTX_I_TXSENT = EVENT_MASK(1),    //
-        PDB_EVT_PRLTX_I_RETRYFAIL = EVENT_MASK(2), //
-        PDB_EVT_PRLTX_DISCARD = EVENT_MASK(3),     //
-        PDB_EVT_PRLTX_MSG_TX = EVENT_MASK(4),      //
-        PDB_EVT_PRLTX_START_AMS = EVENT_MASK(5),   //
-    };
-    static void notify(Notifications notification);
-
-  private:
-    static void thread(const void *args);
-    static EventGroupHandle_t xEventGroupHandle;
-    static StaticEventGroup_t xCreatedEventGroup;
-    static osThreadId TaskHandle;
-    static const size_t TaskStackSize = 1024 / 4;
-    static uint32_t TaskBuffer[TaskStackSize];
-    static osStaticThreadDef_t TaskControlBlock;
-    static bool messageSending;
-    /*
+		PDB_EVT_PRLTX_RESET = EVENT_MASK(0), //
+		PDB_EVT_PRLTX_I_TXSENT = EVENT_MASK(1), //
+		PDB_EVT_PRLTX_I_RETRYFAIL = EVENT_MASK(2), //
+		PDB_EVT_PRLTX_DISCARD = EVENT_MASK(3), //
+		PDB_EVT_PRLTX_MSG_TX = EVENT_MASK(4), //
+		PDB_EVT_PRLTX_START_AMS = EVENT_MASK(5), //
+	};
+	static void notify(Notifications notification);
+private:
+	static void thread(const void *args);
+	static EventGroupHandle_t xEventGroupHandle;
+	static StaticEventGroup_t xCreatedEventGroup;
+	static osThreadId TaskHandle;
+	static const size_t TaskStackSize = 1024 / 4;
+	static uint32_t TaskBuffer[TaskStackSize];
+	static osStaticThreadDef_t TaskControlBlock;
+	static bool messageSending;
+	/*
 	 * Protocol TX machine states
 	 *
 	 * Because the PHY can automatically send retries, the Check_RetryCounter state
 	 * has been removed, transitions relating to it are modified appropriately, and
 	 * we don't even keep a RetryCounter.
 	 */
-    enum protocol_tx_state {
-        PRLTxPHYReset,
-        PRLTxWaitMessage,
-        PRLTxReset,
-        PRLTxConstructMessage,
-        PRLTxWaitResponse,
-        PRLTxMatchMessageID,
-        PRLTxTransmissionError,
-        PRLTxMessageSent,
-        PRLTxDiscardMessage
-    };
-    //Internal states
-    static protocol_tx_state protocol_tx_discard_message();
-    static protocol_tx_state protocol_tx_message_sent();
-    static protocol_tx_state protocol_tx_transmission_error();
-    static protocol_tx_state protocol_tx_match_messageid();
-    static protocol_tx_state protocol_tx_wait_response();
-    static protocol_tx_state protocol_tx_construct_message();
-    static protocol_tx_state protocol_tx_reset();
-    static protocol_tx_state protocol_tx_wait_message();
-    static protocol_tx_state protocol_tx_phy_reset();
-    //queue of up to PDB_MSG_POOL_SIZE messages to send
-    static StaticQueue_t xStaticQueue;
-    /* The array to use as the queue's storage area.  This must be at least
+	enum protocol_tx_state {
+		PRLTxPHYReset,
+		PRLTxWaitMessage,
+		PRLTxReset,
+		PRLTxConstructMessage,
+		PRLTxWaitResponse,
+		PRLTxMatchMessageID,
+		PRLTxTransmissionError,
+		PRLTxMessageSent,
+		PRLTxDiscardMessage
+	};
+	//Internal states
+	static protocol_tx_state protocol_tx_discard_message();
+	static protocol_tx_state protocol_tx_message_sent();
+	static protocol_tx_state protocol_tx_transmission_error();
+	static protocol_tx_state protocol_tx_match_messageid();
+	static protocol_tx_state protocol_tx_wait_response();
+	static protocol_tx_state protocol_tx_construct_message();
+	static protocol_tx_state protocol_tx_reset();
+	static protocol_tx_state protocol_tx_wait_message();
+	static protocol_tx_state protocol_tx_phy_reset();
+	//queue of up to PDB_MSG_POOL_SIZE messages to send
+	static StaticQueue_t xStaticQueue;
+	/* The array to use as the queue's storage area.  This must be at least
 	 uxQueueLength * uxItemSize bytes. */
-    static uint8_t ucQueueStorageArea[PDB_MSG_POOL_SIZE * sizeof(union pd_msg)];
-    static QueueHandle_t messagesWaiting;
-    static uint8_t _tx_messageidcounter;
-    static bool messagePending();
-    //Reads a message off the queue into the temp message
-    static void getMessage();
-    static union pd_msg temp_msg;
-    static Notifications waitForEvent(uint32_t mask, TickType_t ticksToWait =
-                                                         portMAX_DELAY);
+	static uint8_t ucQueueStorageArea[PDB_MSG_POOL_SIZE * sizeof(union pd_msg)];
+	static QueueHandle_t messagesWaiting;
+	static uint8_t _tx_messageidcounter;
+	static bool messagePending();
+	//Reads a message off the queue into the temp message
+	static void getMessage();
+	static union pd_msg temp_msg;
+	static Notifications waitForEvent(uint32_t mask, TickType_t ticksToWait =
+	portMAX_DELAY);
+
 };
 
 #endif /* PDB_PROTOCOL_TX_H */

workspace/TS100/Core/Drivers/OLED.cpp

@@ -97,10 +97,12 @@ void OLED::initialize() {
 	// initialisation data to the OLED.
 
 	setDisplayState(DisplayState::ON);
-	FRToSI2C::writeRegistersBulk(DEVICEADDR_OLED, OLED_Setup_Array, sizeof(OLED_Setup_Array) / sizeof(OLED_Setup_Array[0]));
-
+	for (int tries = 0; tries < 10; tries++) {
+		if (FRToSI2C::writeRegistersBulk(DEVICEADDR_OLED, OLED_Setup_Array, sizeof(OLED_Setup_Array) / sizeof(OLED_Setup_Array[0]))) {
+			return;
+		}
+	}
 }
-
 void OLED::setFramebuffer(uint8_t *buffer) {
 	if (buffer == NULL) {
 		firstStripPtr = &screenBuffer[FRAMEBUFFER_START];
@@ -176,13 +178,13 @@ void OLED::transitionSecondaryFramebuffer(bool forwardNavigation) {
 			progress = OLED_WIDTH;
 		}
 
-		// When forward, current contents move to the left out.
-		// Otherwise the contents move to the right out.
+// When forward, current contents move to the left out.
+// Otherwise the contents move to the right out.
 		uint8_t oldStart = forwardNavigation ? 0 : progress;
 		uint8_t oldPrevious = forwardNavigation ? progress - offset : offset;
 
-		// Content from the second framebuffer moves in from the right (forward)
-		// or from the left (not forward).
+// Content from the second framebuffer moves in from the right (forward)
+// or from the left (not forward).
 		uint8_t newStart = forwardNavigation ? OLED_WIDTH - progress : 0;
 		uint8_t newEnd = forwardNavigation ? 0 : OLED_WIDTH - progress;
 
@@ -231,7 +233,7 @@ void OLED::setRotation(bool leftHanded) {
 
 	screenBuffer[5] = inLeftHandedMode ? 0 : 32; // display is shifted by 32 in left handed
 												 // mode as driver ram is 128 wide
-	screenBuffer[7] = inLeftHandedMode ? 95 : 0x7F; // End address of the ram segment we are writing to (96 wide)
+	screenBuffer[7] = inLeftHandedMode ? 95 : 0x7F;													 // End address of the ram segment we are writing to (96 wide)
 	screenBuffer[9] = inLeftHandedMode ? 0xC8 : 0xC0;
 }
 
@@ -245,7 +247,7 @@ void OLED::print(const char *str) {
 
 void OLED::setFont(uint8_t fontNumber) {
 	if (fontNumber == 1) {
-		// small font
+// small font
 		currentFont = USER_FONT_6x8;
 		fontHeight = 8;
 		fontWidth = 6;
@@ -337,9 +339,9 @@ void OLED::drawSymbol(uint8_t symbolID) {
 void OLED::drawArea(int16_t x, int8_t y, uint8_t wide, uint8_t height, const uint8_t *ptr) {
 	// Splat this from x->x+wide in two strides
 	if (x <= -wide)
-		return;  // cutoffleft
+		return; // cutoffleft
 	if (x > 96)
-		return;      // cutoff right
+		return; // cutoff right
 
 	uint8_t visibleStart = 0;
 	uint8_t visibleEnd = wide;
@@ -353,13 +355,13 @@ void OLED::drawArea(int16_t x, int8_t y, uint8_t wide, uint8_t height, const uin
 	}
 
 	if (y == 0) {
-		// Splat first line of data
+// Splat first line of data
 		for (uint8_t xx = visibleStart; xx < visibleEnd; xx++) {
 			firstStripPtr[xx + x] = ptr[xx];
 		}
 	}
 	if (y == 8 || height == 16) {
-		// Splat the second line
+// Splat the second line
 		for (uint8_t xx = visibleStart; xx < visibleEnd; xx++) {
 			secondStripPtr[x + xx] = ptr[xx + (height == 16 ? wide : 0)];
 		}
@@ -373,7 +375,7 @@ void OLED::drawAreaSwapped(int16_t x, int8_t y, uint8_t wide, uint8_t height, co
 	if (x <= -wide)
 		return;  // cutoffleft
 	if (x > 96)
-		return;      // cutoff right
+		return;  // cutoff right
 
 	uint8_t visibleStart = 0;
 	uint8_t visibleEnd = wide;
@@ -387,14 +389,14 @@ void OLED::drawAreaSwapped(int16_t x, int8_t y, uint8_t wide, uint8_t height, co
 	}
 
 	if (y == 0) {
-		// Splat first line of data
+// Splat first line of data
 		for (uint8_t xx = visibleStart; xx < visibleEnd; xx += 2) {
 			firstStripPtr[xx + x] = ptr[xx + 1];
 			firstStripPtr[xx + x + 1] = ptr[xx];
 		}
 	}
 	if (y == 8 || height == 16) {
-		// Splat the second line
+// Splat the second line
 		for (uint8_t xx = visibleStart; xx < visibleEnd; xx += 2) {
 			secondStripPtr[x + xx] = ptr[xx + 1 + (height == 16 ? wide : 0)];
 			secondStripPtr[x + xx + 1] = ptr[xx + (height == 16 ? wide : 0)];
@@ -407,7 +409,7 @@ void OLED::fillArea(int16_t x, int8_t y, uint8_t wide, uint8_t height, const uin
 	if (x <= -wide)
 		return;  // cutoffleft
 	if (x > 96)
-		return;      // cutoff right
+		return;  // cutoff right
 
 	uint8_t visibleStart = 0;
 	uint8_t visibleEnd = wide;
@@ -421,13 +423,13 @@ void OLED::fillArea(int16_t x, int8_t y, uint8_t wide, uint8_t height, const uin
 	}
 
 	if (y == 0) {
-		// Splat first line of data
+// Splat first line of data
 		for (uint8_t xx = visibleStart; xx < visibleEnd; xx++) {
 			firstStripPtr[xx + x] = value;
 		}
 	}
 	if (y == 8 || height == 16) {
-		// Splat the second line
+// Splat the second line
 		for (uint8_t xx = visibleStart; xx < visibleEnd; xx++) {
 			secondStripPtr[x + xx] = value;
 		}
@@ -473,7 +475,7 @@ void OLED::drawHeatSymbol(uint8_t state) {
 	// Draw symbol 14
 	// Then draw over it, the bottom 5 pixels always stay. 8 pixels above that are
 	// the levels masks the symbol nicely
-	state /= 31;  // 0-> 8 range
+	state /= 31;	// 0-> 8 range
 	// Then we want to draw down (16-(5+state)
 	uint8_t cursor_x_temp = cursor_x;
 	drawSymbol(14);