A new forlder for embedded software in our common structure

1 files changed, 245 insertions, 0 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c
new file mode 100644
index 000000000..d792d9b5f
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c
@@ -0,0 +1,245 @@
+/************************************************************
+ * Utils.h
+ * general module of system utility functions
+ **************************************************************/
+
+#include <inc/hw_ints.h>
+#include <inc/hw_memmap.h>
+#include <driverlib/rom.h>
+#include <time.h>
+#include "Common/Utilities/Utils.h"
+//#include <driverlib/systick.h>
+#include "driverlib/hibernate.h"
+
+static const float speedCoef = 5.3051647697298445256294587790838f;//(200 micro steping)/2*Pi*Radius - 200 micro steping
+
+//*****************************************************************************
+
+bool DanserCheckPosition(uint16_t position , Danser_t danser, bool test)
+{
+    if (test == false) return true;
+#ifdef DEBUG_DANCER
+	ProfileType_t profileType = GetCurrentProfileType();
+	if (position <  DANSER_POS_MIN)
+	{
+		if(danser == Winder)
+		{
+			if(profileType == Manual)
+			{
+				JigStopAllWithError("Thread torn in winder danser");//for stoping the system operation
+			}
+			else if (profileType == User)
+			{
+				//notify the UI about an error and pause the system
+				SendMessageToHost(ERROR_IN_PROFILE_EXECUTION,"Thread torn in winder danser");
+				JigPauseAll();
+			}
+		}
+		else
+		{
+			if(profileType == Manual)
+			{
+				JigStopAllWithError("Thread torn in pooler danser");//for stoping the system operation
+			}
+			else if (profileType == User)
+			{
+				//notify the UI about an error and pause the system
+				SendMessageToHost(ERROR_IN_PROFILE_EXECUTION,"Thread torn in pooler danser");
+				JigPauseAll();
+			}
+		}
+		return false;
+	}
+
+	if (position >  DANSER_POS_MAX)
+	{
+		if(danser == Pooler)
+		{
+			if(profileType == Manual)
+			{
+				JigStopAllWithError("Thread stocked in pooler danser");
+			}
+			else if (profileType == User)
+			{
+				SendMessageToHost(ERROR_IN_PROFILE_EXECUTION,"Thread stuck in pooler danser");
+				JigPauseAll();
+			}
+		}
+		else
+		{
+			if(profileType == Manual)
+			{
+				JigStopAllWithError("Thread stocked in winder danser");
+			}
+			else if (profileType ==User)
+			{
+				SendMessageToHost(ERROR_IN_PROFILE_EXECUTION,"Thread stuck in winder danser");
+				JigPauseAll();
+			}
+		}
+		return false;
+	}
+#endif
+	return true;
+}
+
+//*****************************************************************************
+//convert thread speed recieved in milimeters per second into motor steps of pps
+//*****************************************************************************
+uint16_t ConvertSpeed2Pps(uint16_t milimeterPerSecond)
+{
+	float res = speedCoef*(float)milimeterPerSecond;
+	return (uint16_t)res;
+}
+//*****************************************************************************
+
+uint16_t ConvertPpsToSpeed(uint16_t Pps)
+{
+	float res = (float)Pps/speedCoef;
+	return (uint16_t)res;
+
+}
+
+//*****************************************************************************
+//
+// Init WD timer
+//
+//*****************************************************************************
+void InitWatchdog(uint32_t clock)
+{
+	//
+	// Enable the watchdog interrupt.
+	//
+	ROM_IntEnable(INT_WATCHDOG);
+
+	//
+	// Set the period of the watchdog timer.
+	//
+	ROM_WatchdogReloadSet(WATCHDOG0_BASE, clock);
+
+	//
+	// Enable reset generation from the watchdog timer.
+	//
+	ROM_WatchdogResetEnable(WATCHDOG0_BASE);
+
+	//
+	// Enable the watchdog timer.
+	//
+	ROM_WatchdogEnable(WATCHDOG0_BASE);
+}
+void utilsInit(uint32_t ui32SysClock)
+{
+
+    cb_init();
+//    SysTickPeriodSet(120000);
+//    SysTickEnable();
+    // Configure Hibernate module clock.
+    //
+    HibernateEnableExpClk(ui32SysClock);
+
+
+    // Enable RTC mode.
+    //
+    HibernateRTCEnable();
+
+    //
+    // Configure the hibernate module counter to 24-hour calendar mode.
+    //
+    // HibernateCounterMode(HIBERNATE_COUNTER_24HR);
+    // Configure the hibernate module counter to RTC counter mode.
+    HibernateCounterMode(HIBERNATE_COUNTER_RTC);
+
+
+}
+
+
+uint32_t UsersysTickGet (void) {
+    uint32_t tick = 0;
+//    tick =  SysTickValueGet();
+    tick = HibernateRTCSSGet()*10000/0x8000;
+    return tick;
+}
+
+//*****************************************************************************
+//
+// The interrupt handler for the watchdog.  This feeds the dog (so that the
+// processor does not get reset) and winks the LED connected to GPIO B3.
+//
+//*****************************************************************************
+void WatchdogIntHandler(void)
+{
+     //
+     // Clear the watchdog interrupt.
+     //
+     ROM_WatchdogIntClear(WATCHDOG0_BASE);
+}
+
+bool sendDataToHost = false;
+void UtilsSetCommunicationOk(void)
+{
+    sendDataToHost = true;
+}
+
+typedef struct circular_buffer
+{
+    void *buffer;     // data buffer
+    void *buffer_end; // end of data buffer
+    uint16_t capacity;  // maximum number of items in the buffer
+    uint16_t count;     // number of items in the buffer
+    uint16_t sz;        // size of each item in the buffer
+    void *head;       // pointer to head
+    void *tail;       // pointer to tail
+} circular_buffer;
+
+uint8_t LogBuffer[8002];
+circular_buffer cb;
+void cb_init()
+{
+    //cb.buffer = malloc(capacity * sz);
+    //if(cb.buffer == NULL)
+        // handle error
+    cb.buffer = LogBuffer;
+    cb.buffer_end = &LogBuffer[3950];
+    cb.capacity = 4000;
+    cb.count = 0;
+    cb.sz = 60;
+    cb.head = cb.buffer;
+    cb.tail = cb.buffer;
+}
+
+void cb_free(circular_buffer *cb)
+{
+    //free(cb.buffer);
+    // clear out other fields too, just to be safe
+}
+
+void cb_push_back(/*circular_buffer *cb,*/ const void *item, int size)
+{
+    if(cb.count == cb.capacity){
+        return;
+        // handle error
+    }
+    if ((int)(cb.head) + size > (int)(cb.buffer_end)){
+        size = (int)(cb.buffer_end) - (int)(cb.head);
+    }
+
+    memcpy(cb.head, item, size);
+    cb.head = (char*)cb.head + size;
+    if(cb.head >= cb.buffer_end)
+        cb.head = cb.buffer;
+    cb.count++;
+//    if (sendDataToHost)
+//        SendMessageToHost(DEBUG_LOG,item);
+}
+
+void cb_pop_front(/*circular_buffer *cb,*/ void *item)
+{
+    if(cb.count == 0){
+        // handle error
+    }
+    memcpy(item, cb.tail, cb.sz);
+    cb.tail = (char*)cb.tail + cb.sz;
+    if(cb.tail == cb.buffer_end)
+        cb.tail = cb.buffer;
+    cb.count--;
+}