File view

plc_logging.lib

      
            /*** BeginHeader *//
          
            #ifndef ISM_LOGGING_LIB
          
            #define ISM_LOGGING_LIB
          
            /*** EndHeader */
          
            /*** Message Format - 8 bytes *****************************************************
          
            	  bb      bbb      bbb      bbb       bb        bbb     hh hh	  hh hh hh hh
          
            	|-log-| |-code-| |-Prod-| |-Ch-| |-status-| |-Notes-| |-Rate-| |-time stamp-|
          
            	|-log-|  		<< 2   = Alarm, Test, or system
          
            	|-code-| 		<< 3   = Alarm or Test code
          
            	|-Prod-|   	   << 3   = Product number
          
            	|-status-| 		<< 2	 = Test Pass / Fail or Alarm Open / Closed
          
            	|-Chl-|  		<< 3   = Channel number
          
            	|-Notes-| 		<< 3   = Test Notes  or other
          
            	|-Rate-| 		2 bite = Test Rate * 1000 or 3GPH test count
          
            	|-time stamp-| 4 byte = Posted date / time
          
            *********************************************************************************/
          
            /*** BeginHeader
          
            	InitializeLogs,
          
            	InitEvent,
          
            	FormatEvent,
          
            	AddLogEvent,
          
               SearchEvent,
          
               UpdataFlashLog
          
            */
          
            #define RECORD_SIZE	 8
          
            #define RAM_LOG_LEN	 20
          
            #define MAX_FILE_SIZE (XMEM_RESERVE_SIZE - (XMEM_RESERVE_SIZE / 8))
          
            // Global Function declerations ********************************************************
          
            void  InitializeLogs (int InitStr);
          
            void 	InitEvent		(EventSt *EventSet);
          
            void 	FormatEvent		(EventSt *EventSet, char *string1, char *string2);
          
            void 	AddLogEvent		(EventSt *EventSet);
          
            int  	SearchEvent		(int logType, int action, EventSt *EventDataSet);
          
            int 	UpdataFlashLog (void);
          
            /*** EndHeader */
          
            // Local function declerations *******************************************************
          
            typedef struct adrSt 
          
            {
          
            	long	startAdd;
          
            	long	wrtAdd;
          
               long	rdAdd;
          
            	long	eof;
          
            } AdrSt;
          
            typedef AdrSt * AdrStPtr;
          
            typedef struct rLogSt 
          
            {
          
            	int  		CurIdx;
          
            	int	   GPH3DayCnt;
          
            	uint8_t *RLog;
          
            	uint8_t *NextRLog;
          
            } RLogSt;
          
            typedef RLogSt * RLogStPtr;
          
            AdrSt Position			(int filehandle);
          
            int	CreateLogFile	(int logType);
          
            int 	ReadEvent		(long rdAdr, EventSt *EventSet);
          
            void 	AddGPH3P			(EventSt *EventSet);
          
            void 	UpdateLog 		(EventSt *EventSet);
          
            // Local Var
          
            root uint8_t 	RLogR[RAM_LOG_LEN][RECORD_SIZE];
          
            root uint8_t	RLogW[RAM_LOG_LEN][RECORD_SIZE];
          
            	  EventSt	Gph3P[N_PROD];
          
              	  EventSt	Last2[N_PROD];
          
            	  RLogSt		RamLogWr;
          
            	  RLogSt		RamLogRd;
          
            	  AdrSt		RdAdr;
          
            // Initualize loggint data structures **********************************************
          
            void InitializeLogs(int InitStr) {
          
            	int i;
          
            	int j;
          
            	if (InitStr) {
          
            		for (i = 0 ; i < RAM_LOG_LEN ; i++) 
          
            		{
          
            	      for (j = 0 ; j < RECORD_SIZE ; j++) 
          
            		  {
          
            	         	RLogW[i][j] = 0;
          
             				RLogR[i][j] = 0;
          
            	      }
          
            	   }
          
            	   for (i = 0 ; i < N_PROD ; i++) 
          
            	   {
          
            	   	InitEvent(&Gph3P[i]);
          
            	   	InitEvent(&Last2[i]);
          
            	   }
          
            	   RamLogWr.CurIdx        = 0;
          
            	   RamLogWr.GPH3DayCnt    = 0;
          
            	   RamLogWr.RLog          = RLogW[0];
          
            	   RamLogWr.NextRLog      = RLogW[RamLogWr.CurIdx];
          
            	   RamLogRd.CurIdx        = 0;
          
            	   RamLogRd.GPH3DayCnt    = 0;
          
            	   RamLogRd.RLog          = RLogR[0];
          
            	   RamLogRd.NextRLog      = RLogR[RamLogRd.CurIdx];
          
            	}
          
            	else if (RamLogWr.CurIdx != 0)
          
            		i = UpdataFlashLog();
          
            	i = sizeof(RdAdr);
          
            	RdAdr.startAdd = i;
          
            	RdAdr.wrtAdd 	= i;
          
            	RdAdr.rdAdd		= i;
          
            	RdAdr.eof 		= i;
          
            }
          
            // CreateLogFile *****************************************************************
          
            int CreateLogFile(int logType) {
          
            	root AdrSt 	init;
          
               	  File 	logFile;
          
            		  int 	AdrSize;
          
               	  int  	fileHandle;
          
               	  int 	result;
          
            	result 		= 0;
          
               fileHandle 	= 0;
          
            	AdrSize 		= sizeof(init);
          
               fdelete(logType);
          
            	fileHandle = fcreate (&logFile, logType);
          
            	fileHandle = fopen_wr(&logFile, logType);
          
            	if (fileHandle == 0) {
          
                  init.startAdd 	= AdrSize;
          
                  init.wrtAdd 	= AdrSize;
          
                  init.rdAdd 		= AdrSize;
          
                  init.eof 		= 0;
          
                  fseek(&logFile, 0 ,SEEK_SET);
          
                  result  = fwrite(&logFile, (char*)&init, sizeof(init));
          
                  result -= sizeof(init);
          
                  fclose(&logFile);
          
            	}
          
               else
          
               	printf("Could not create log file for   some reason\n");
          
               return result;
          
            }
          
            // Return current position in log file *********************************************
          
            AdrSt Position(int fileHandle) 
          
            {
          
               	root AdrSt result;
          
               	File  logFile;
          
               	int   readResult;
          
               	fopen_rd(&logFile, fileHandle);
          
               	readResult  = fseek(&logFile, 0, SEEK_SET);
          
            	readResult += fread(&logFile, (char*)&result, sizeof(result));
          
            	readResult -= sizeof(result);
          
            	if (readResult)
          
            	{
          
            	   printf("Could not read pointer structure\n");
          
            	}
          
               	fclose(&logFile);
          
            	printf("Logfile POS - %u %u %u \n", result.startAdd, result.rdAdd, result.wrtAdd);
          
              return result;
          
            }
          
            // AddLogEvent *******************************************************************
          
            void AddLogEvent(EventSt *EventSet) 
          
            {
          
            	if 	  (EventSet->Code == TEST_GPH3 && EventSet->Status == PASS)
          
            	{
          
            		//AddGPH3P(EventSet);
          
            		UpdateLog(EventSet);
          
            	}
          
            	else if (EventSet->Code == TEST_PNT2 && EventSet->Status == PASS) 
          
            	{
          
            		memcpy(&Last2[EventSet->Product], EventSet, sizeof(EventSet));
          
            	 	UpdateLog(EventSet);
          
            	}
          
            	else
          
            	{
          
              		UpdateLog(EventSet);
          
            	}
          
            }
          
            // Add 3GPH Pass Logs ************************************************************
          
            void AddGPH3P(EventSt *EventSet) 
          
            {
          
            	int prod;
          
            	prod = EventSet->Product;
          
            	mktm  (&EventSet->TOD,  EventSet->Time);
          
            	if (Gph3P[prod].Time == 0) 
          
            	{
          
            		memcpy(&Gph3P[prod], EventSet, sizeof(EventSet));
          
            		Gph3P[prod].Rate = 1.0;
          
            	}
          
            	else if (Gph3P[prod].TOD.tm_year == EventSet->TOD.tm_year &&
          
            				Gph3P[prod].TOD.tm_mday == EventSet->TOD.tm_mday &&
          
            				Gph3P[prod].TOD.tm_mon	== EventSet->TOD.tm_mon) 
          
            	{
          
            		Gph3P[prod].Rate += 1.0;
          
            	}
          
            	else 
          
            	{
          
            		UpdateLog(&Gph3P[prod]);
          
            		memcpy(&Gph3P[prod], EventSet, sizeof(EventSet));
          
            		Gph3P[prod].Rate = 1.0;
          
            	}
          
            }
          
            // Add entry to log file *********************************************************
          
            void UpdateLog(EventSt *EventSet) 
          
            {
          
            	uint8_t		data[2];
          
            	int			rate;
          
               	int 			result;
          
               	int i;
          
               	result  = 0;
          
               	rate 	  =  (int)(EventSet->Rate * 1000.0);
          
            	data[0] = (((char)EventSet->LogType << 6) & 0xC0);
          
            	data[0] = (((char)EventSet->Code    << 3) & 0x38) | data[0];
          
            	data[0] = (((char)EventSet->Product     ) & 0x07) | data[0];
          
            	data[1] = (((char)EventSet->Channel << 6) & 0xC0);
          
            	data[1] = (((char)EventSet->Status  << 3) & 0x38) | data[1];
          
            	data[1] = (((char)EventSet->Notes       ) & 0x07) | data[1];
          
               RamLogWr.NextRLog[0] = data[0];
          
               RamLogWr.NextRLog[1] = data[1];
          
               memcpy(&RamLogWr.NextRLog[2], (char*)&rate,           sizeof(rate)          );
          
               memcpy(&RamLogWr.NextRLog[4], (char*)&EventSet->Time, sizeof(EventSet->Time));
          
               if (++RamLogWr.CurIdx >= RAM_LOG_LEN)
          
               {
          
                  result = UpdataFlashLog();
          
               }
          
               else
          
               {
          
                  RamLogWr.NextRLog = RLogW[RamLogWr.CurIdx];
          
               }
          
            	if (result)
          
            	{
          
            		printf("Error writing Ram log to Flash Log\n");
          
            	}
          
            }
          
            // Read / Parse single event from log *********************************************
          
            int ReadEvent(long rdAdr, EventSt *EventSet) 
          
            {
          
            	root uint8_t	data[8];
          
            	File 		logFile;
          
               	FSLXnum 	flash1;
          
               	int 		result;
          
               	int			rate;
          
                int i;
          
            	result = 0;
          
            	if (RamLogWr.CurIdx > 0)
          
            		result = UpdataFlashLog();
          
            	flash1  = fs_get_flash_lx();
          
               	result += fopen_rd(&logFile, LOG_FILE);
          
               	result += fseek(&logFile, rdAdr, SEEK_SET);
          
            	result  = fread(&logFile, (char*)&data, sizeof(data));
          
            	result -= sizeof(data);
          
            	fclose(&logFile);
          
            	if (result == 0) 
          
            	{
          
            		memcpy(&EventSet->Time, (char*)&data[4], sizeof(EventSet->Time));
          
            		memcpy(&rate, 			   (char*)&data[2], sizeof(rate));
          
            		mktm  (&EventSet->TOD,  EventSet->Time);
          
            		EventSet->Rate 	= (float)rate  / 1000.0;
          
            		EventSet->Product = (int)(data[0]     ) & 0x07;
          
            	   	EventSet->Code		= (int)(data[0] >> 3) & 0x07;
          
            		EventSet->LogType = (int)(data[0] >> 6) & 0x03;
          
            		EventSet->Notes   = (int)(data[1]  	  ) & 0x07;
          
            		EventSet->Status	= (int)(data[1] >> 3) & 0x07;
          
            		EventSet->Channel	= (int)(data[1] >> 6) & 0x03;
          
            	}
          
            	return result;
          
            }
          
            // Write Log to Fladh *************************************************************
          
            int UpdataFlashLog(void) 
          
            {
          
               	File 			logFile;
          
               	FSLXnum 		flash1;
          
            	root AdrSt	pos;
          
            	int 			fileHandle;
          
               	int			Records;
          
            	int			result;
          
            	fileHandle 	= 0;
          
               	result 		= 0;
          
            	Records		= RamLogWr.CurIdx * RECORD_SIZE;
          
               	flash1 		= fs_get_flash_lx();
          
            	fileHandle	= fopen_wr(&logFile, LOG_FILE);
          
               	if (fileHandle) 
          
            	{
          
               		fileHandle = CreateLogFile(LOG_FILE);
          
                  	fopen_wr(&logFile, LOG_FILE);
          
               	}
          
               if (fileHandle) 
          
               {
          
                  printf("Error Opening Log File\n");
          
                  result = 1;
          
               }
          
               else 
          
               {
          
            		pos 				= Position(LOG_FILE);
          
            		if (pos.wrtAdd + Records >= MAX_FILE_SIZE) 
          
            		{
          
            	      pos.eof 		= pos.wrtAdd - RECORD_SIZE;
          
            	      pos.wrtAdd  = sizeof(pos);
          
            		}
          
            		result		+= fseek (&logFile, pos.wrtAdd, SEEK_SET);
          
            		result 		+= fwrite(&logFile, (char*)RamLogWr.RLog, Records);
          
            		result 		-= Records;
          
                  	pos.wrtAdd 	+= Records;
          
                  	result		+= fseek (&logFile, 0, SEEK_SET);
          
                  	result 		+= fwrite(&logFile, (char*)&pos, sizeof(pos));
          
                  	result 		-= sizeof(pos);
          
                  	RamLogWr.CurIdx 	= 0;
          
                  	RamLogWr.NextRLog = RLogW[RamLogWr.CurIdx];
          
               }
          
            	if (result)
          
            	{
          
                  printf("Error Writing to Log File\n");
          
            	}
          
            }
          
            // Show Alarms *******************************************************************
          
            int SearchEvent(int logType, int action, EventSt *EventData) 
          
            {
          
               int validEvent;
          
               int result;
          
               validEvent = 0;
          
               result 	  = 0;
          
               while (validEvent == 0 && result == 0) 
          
               {
          
                  if 	  (action == OPEN_FILE) 
          
            	  {
          
                  		RdAdr 		= Position(LOG_FILE);
          
                     	RdAdr.rdAdd = RdAdr.wrtAdd;
          
                     	action 		= PREVIOUS_EVENT;
          
                  }
          
                  else if (action == CLOSE_FILE) 
          
            	  {
          
                     	result = 1;
          
                  }
          
                  else if (action == PREVIOUS_EVENT) 
          
            	  {
          
                     RdAdr.rdAdd -= RECORD_SIZE;
          
                     if (RdAdr.rdAdd <= RdAdr.startAdd) 
          
            		 {
          
                        if (RdAdr.eof > RdAdr.wrtAdd)
          
            			{
          
                       		RdAdr.rdAdd = RdAdr.eof;
          
            			}
          
            			else
          
            			{
          
            				result = 1;
          
            			}
          
                     }
          
                     else if (RdAdr.rdAdd == RdAdr.wrtAdd)
          
            		 {
          
                     	result = 1;
          
            		 }
          
                     else if (RdAdr.rdAdd == 0)
          
            		 {
          
                     	result = 1;
          
            		 }
          
                     if (result == 0)
          
            		 {
          
                     	result = ReadEvent(RdAdr.rdAdd, EventData);
          
            		 }
          
                     if (EventData->LogType == logType)
          
            		 {
          
                     	validEvent = 1;
          
            		 }
          
                     else
          
            		 {
          
                     	action = PREVIOUS_EVENT;
          
            		 }
          
                  }
          
               }
          
               return result;
          
            }
          
            // Output Format ******************************************************************
          
            void FormatEvent(EventSt *EventSet, char *string1, char *string2) 
          
            {
          
               char	tmpStrg [DISPLAY_LENGTH + 1];
          
               char year;
          
            	// Foramt Data String
          
               if (EventSet->TOD.tm_year > 99)
          
               {
          
                  year = EventSet->TOD.tm_year - 100;
          
               }
          
               else
          
               {
          
                  year = EventSet->TOD.tm_year;
          
               }
          
               sprintf(string1, "%02d/%02d/%02d %02d:%02d", EventSet->TOD.tm_mon,
          
            	                                             EventSet->TOD.tm_mday,
          
            	                                             				     year,
          
            	                                             EventSet->TOD.tm_hour,
          
            	                                             EventSet->TOD.tm_min);
          
            	switch (EventSet->LogType) 
          
            	{
          
            	   case TEST_LOG:
          
            	      	FormatTestResault(string2, tmpStrg, EventSet);
          
                     	if (EventSet->Code != TEST_GPH3)
          
            		 	{
          
            	      		sprintf(string2, "%s %s", string2, tmpStrg);
          
            		 	}
          
            	      break;
          
            	   case ALRM_LOG:
          
            	      FormatAlarm(string2, tmpStrg, EventSet);
          
            	      sprintf(string2, "%s %s", string2, tmpStrg);
          
            	      break;
          
            	   case SYST_LOG:
          
            	      sprintf(string2, "SYSTEM BOOT");
          
            	      break;
          
            	   default:
          
            	      sprintf(string2, "");
          
            	}
          
            }
          
            // Init Event Structure *********************************************************
          
            void InitEvent(EventSt *EventSet) 
          
            {
          
            	EventSet->TOD.tm_sec    = 0;
          
            	EventSet->TOD.tm_min    = 0;
          
            	EventSet->TOD.tm_hour   = 0;
          
            	EventSet->TOD.tm_mday   = 0;
          
            	EventSet->TOD.tm_mon    = 0;
          
            	EventSet->TOD.tm_year   = 0;
          
            	EventSet->TOD.tm_wday   = 0;
          
            	EventSet->Time          = 0;
          
            	EventSet->Rate          = 0.0;
          
            	EventSet->Product       = 0;
          
            	EventSet->Channel       = 0;
          
            	EventSet->LogType       = 0;
          
            	EventSet->Code          = 0;
          
            	EventSet->Status        = 0;
          
            	EventSet->Notes         = 0;
          
            }
          
            /*** BeginHeader */
          
            #endif
          
            /*** EndHeader */

1	/*** BeginHeader *//
2	#ifndef ISM_LOGGING_LIB
3	#define ISM_LOGGING_LIB
4	/*** EndHeader */
5
6	/* Message Format - 8 bytes ***************************************************
7	bb bbb bbb bbb bb bbb hh hh hh hh hh hh
8	\|-log-\| \|-code-\| \|-Prod-\| \|-Ch-\| \|-status-\| \|-Notes-\| \|-Rate-\| \|-time stamp-\|
9
10	\|-log-\| << 2 = Alarm, Test, or system
11	\|-code-\| << 3 = Alarm or Test code
12	\|-Prod-\| << 3 = Product number
13
14	\|-status-\| << 2 = Test Pass / Fail or Alarm Open / Closed
15	\|-Chl-\| << 3 = Channel number
16	\|-Notes-\| << 3 = Test Notes or other
17
18	\|-Rate-\| 2 bite = Test Rate * 1000 or 3GPH test count
19
20	\|-time stamp-\| 4 byte = Posted date / time
21	*********************************************************************************/
22
23	/*** BeginHeader
24	InitializeLogs,
25	InitEvent,
26	FormatEvent,
27	AddLogEvent,
28	SearchEvent,
29	UpdataFlashLog
30	*/
31
32	#define RECORD_SIZE 8
33	#define RAM_LOG_LEN 20
34	#define MAX_FILE_SIZE (XMEM_RESERVE_SIZE - (XMEM_RESERVE_SIZE / 8))
35
36	// Global Function declerations ********************************************************
37
38	void InitializeLogs (int InitStr);
39	void InitEvent (EventSt *EventSet);
40	void FormatEvent (EventSt EventSet, char string1, char *string2);
41	void AddLogEvent (EventSt *EventSet);
42	int SearchEvent (int logType, int action, EventSt *EventDataSet);
43	int UpdataFlashLog (void);
44
45	/*** EndHeader */
46
47	// Local function declerations *******************************************************
48	typedef struct adrSt
49	{
50	long startAdd;
51	long wrtAdd;
52	long rdAdd;
53	long eof;
54	} AdrSt;
55	typedef AdrSt * AdrStPtr;
56
57	typedef struct rLogSt
58	{
59	int CurIdx;
60	int GPH3DayCnt;
61	uint8_t *RLog;
62	uint8_t *NextRLog;
63	} RLogSt;
64	typedef RLogSt * RLogStPtr;
65
66	AdrSt Position (int filehandle);
67	int CreateLogFile (int logType);
68	int ReadEvent (long rdAdr, EventSt *EventSet);
69	void AddGPH3P (EventSt *EventSet);
70	void UpdateLog (EventSt *EventSet);
71
72	// Local Var
73	root uint8_t RLogR[RAM_LOG_LEN][RECORD_SIZE];
74	root uint8_t RLogW[RAM_LOG_LEN][RECORD_SIZE];
75	EventSt Gph3P[N_PROD];
76	EventSt Last2[N_PROD];
77	RLogSt RamLogWr;
78	RLogSt RamLogRd;
79	AdrSt RdAdr;
80
81	// Initualize loggint data structures **********************************************
82	void InitializeLogs(int InitStr) {
83	int i;
84	int j;
85
86	if (InitStr) {
87	for (i = 0 ; i < RAM_LOG_LEN ; i++)
88	{
89	for (j = 0 ; j < RECORD_SIZE ; j++)
90	{
91	RLogW[i][j] = 0;
92	RLogR[i][j] = 0;
93	}
94	}
95	for (i = 0 ; i < N_PROD ; i++)
96	{
97	InitEvent(&Gph3P[i]);
98	InitEvent(&Last2[i]);
99	}
100	RamLogWr.CurIdx = 0;
101	RamLogWr.GPH3DayCnt = 0;
102	RamLogWr.RLog = RLogW[0];
103	RamLogWr.NextRLog = RLogW[RamLogWr.CurIdx];
104
105	RamLogRd.CurIdx = 0;
106	RamLogRd.GPH3DayCnt = 0;
107	RamLogRd.RLog = RLogR[0];
108	RamLogRd.NextRLog = RLogR[RamLogRd.CurIdx];
109	}
110	else if (RamLogWr.CurIdx != 0)
111	i = UpdataFlashLog();
112
113	i = sizeof(RdAdr);
114	RdAdr.startAdd = i;
115	RdAdr.wrtAdd = i;
116	RdAdr.rdAdd = i;
117	RdAdr.eof = i;
118	}
119
120	// CreateLogFile *****************************************************************
121	int CreateLogFile(int logType) {
122	root AdrSt init;
123	File logFile;
124	int AdrSize;
125	int fileHandle;
126	int result;
127
128	result = 0;
129	fileHandle = 0;
130	AdrSize = sizeof(init);
131
132	fdelete(logType);
133	fileHandle = fcreate (&logFile, logType);
134	fileHandle = fopen_wr(&logFile, logType);
135	if (fileHandle == 0) {
136	init.startAdd = AdrSize;
137	init.wrtAdd = AdrSize;
138	init.rdAdd = AdrSize;
139	init.eof = 0;
140
141	fseek(&logFile, 0 ,SEEK_SET);
142	result = fwrite(&logFile, (char*)&init, sizeof(init));
143	result -= sizeof(init);
144	fclose(&logFile);
145	}
146	else
147	printf("Could not create log file for some reason\n");
148
149	return result;
150	}
151
152	// Return current position in log file *********************************************
153	AdrSt Position(int fileHandle)
154	{
155	root AdrSt result;
156	File logFile;
157	int readResult;
158
159	fopen_rd(&logFile, fileHandle);
160	readResult = fseek(&logFile, 0, SEEK_SET);
161	readResult += fread(&logFile, (char*)&result, sizeof(result));
162	readResult -= sizeof(result);
163	if (readResult)
164	{
165	printf("Could not read pointer structure\n");
166	}
167	fclose(&logFile);
168	printf("Logfile POS - %u %u %u \n", result.startAdd, result.rdAdd, result.wrtAdd);
169
170	return result;
171	}
172
173	// AddLogEvent *******************************************************************
174	void AddLogEvent(EventSt *EventSet)
175	{
176	if (EventSet->Code == TEST_GPH3 && EventSet->Status == PASS)
177	{
178	//AddGPH3P(EventSet);
179	UpdateLog(EventSet);
180	}
181	else if (EventSet->Code == TEST_PNT2 && EventSet->Status == PASS)
182	{
183	memcpy(&Last2[EventSet->Product], EventSet, sizeof(EventSet));
184	UpdateLog(EventSet);
185	}
186	else
187	{
188	UpdateLog(EventSet);
189	}
190	}
191
192	// Add 3GPH Pass Logs ************************************************************
193	void AddGPH3P(EventSt *EventSet)
194	{
195	int prod;
196
197	prod = EventSet->Product;
198	mktm (&EventSet->TOD, EventSet->Time);
199	if (Gph3P[prod].Time == 0)
200	{
201	memcpy(&Gph3P[prod], EventSet, sizeof(EventSet));
202	Gph3P[prod].Rate = 1.0;
203	}
204	else if (Gph3P[prod].TOD.tm_year == EventSet->TOD.tm_year &&
205	Gph3P[prod].TOD.tm_mday == EventSet->TOD.tm_mday &&
206	Gph3P[prod].TOD.tm_mon == EventSet->TOD.tm_mon)
207	{
208	Gph3P[prod].Rate += 1.0;
209	}
210	else
211	{
212	UpdateLog(&Gph3P[prod]);
213	memcpy(&Gph3P[prod], EventSet, sizeof(EventSet));
214	Gph3P[prod].Rate = 1.0;
215	}
216	}
217
218	// Add entry to log file *********************************************************
219	void UpdateLog(EventSt *EventSet)
220	{
221	uint8_t data[2];
222	int rate;
223	int result;
224	int i;
225
226	result = 0;
227	rate = (int)(EventSet->Rate * 1000.0);
228	data[0] = (((char)EventSet->LogType << 6) & 0xC0);
229	data[0] = (((char)EventSet->Code << 3) & 0x38) \| data[0];
230	data[0] = (((char)EventSet->Product ) & 0x07) \| data[0];
231	data[1] = (((char)EventSet->Channel << 6) & 0xC0);
232	data[1] = (((char)EventSet->Status << 3) & 0x38) \| data[1];
233	data[1] = (((char)EventSet->Notes ) & 0x07) \| data[1];
234
235	RamLogWr.NextRLog[0] = data[0];
236	RamLogWr.NextRLog[1] = data[1];
237	memcpy(&RamLogWr.NextRLog[2], (char*)&rate, sizeof(rate) );
238	memcpy(&RamLogWr.NextRLog[4], (char*)&EventSet->Time, sizeof(EventSet->Time));
239
240	if (++RamLogWr.CurIdx >= RAM_LOG_LEN)
241	{
242	result = UpdataFlashLog();
243	}
244	else
245	{
246	RamLogWr.NextRLog = RLogW[RamLogWr.CurIdx];
247	}
248
249	if (result)
250	{
251	printf("Error writing Ram log to Flash Log\n");
252	}
253	}
254
255	// Read / Parse single event from log *********************************************
256	int ReadEvent(long rdAdr, EventSt *EventSet)
257	{
258	root uint8_t data[8];
259	File logFile;
260	FSLXnum flash1;
261	int result;
262	int rate;
263	int i;
264
265	result = 0;
266
267	if (RamLogWr.CurIdx > 0)
268	result = UpdataFlashLog();
269
270	flash1 = fs_get_flash_lx();
271	result += fopen_rd(&logFile, LOG_FILE);
272	result += fseek(&logFile, rdAdr, SEEK_SET);
273	result = fread(&logFile, (char*)&data, sizeof(data));
274	result -= sizeof(data);
275	fclose(&logFile);
276
277	if (result == 0)
278	{
279	memcpy(&EventSet->Time, (char*)&data[4], sizeof(EventSet->Time));
280	memcpy(&rate, (char*)&data[2], sizeof(rate));
281	mktm (&EventSet->TOD, EventSet->Time);
282	EventSet->Rate = (float)rate / 1000.0;
283	EventSet->Product = (int)(data[0] ) & 0x07;
284	EventSet->Code = (int)(data[0] >> 3) & 0x07;
285	EventSet->LogType = (int)(data[0] >> 6) & 0x03;
286	EventSet->Notes = (int)(data[1] ) & 0x07;
287	EventSet->Status = (int)(data[1] >> 3) & 0x07;
288	EventSet->Channel = (int)(data[1] >> 6) & 0x03;
289	}
290	return result;
291	}
292
293	// Write Log to Fladh *************************************************************
294	int UpdataFlashLog(void)
295	{
296	File logFile;
297	FSLXnum flash1;
298	root AdrSt pos;
299	int fileHandle;
300	int Records;
301	int result;
302
303	fileHandle = 0;
304	result = 0;
305	Records = RamLogWr.CurIdx * RECORD_SIZE;
306
307	flash1 = fs_get_flash_lx();
308	fileHandle = fopen_wr(&logFile, LOG_FILE);
309
310	if (fileHandle)
311	{
312	fileHandle = CreateLogFile(LOG_FILE);
313	fopen_wr(&logFile, LOG_FILE);
314	}
315	if (fileHandle)
316	{
317	printf("Error Opening Log File\n");
318	result = 1;
319	}
320	else
321	{
322	pos = Position(LOG_FILE);
323	if (pos.wrtAdd + Records >= MAX_FILE_SIZE)
324	{
325	pos.eof = pos.wrtAdd - RECORD_SIZE;
326	pos.wrtAdd = sizeof(pos);
327	}
328
329	result += fseek (&logFile, pos.wrtAdd, SEEK_SET);
330	result += fwrite(&logFile, (char*)RamLogWr.RLog, Records);
331	result -= Records;
332	pos.wrtAdd += Records;
333	result += fseek (&logFile, 0, SEEK_SET);
334	result += fwrite(&logFile, (char*)&pos, sizeof(pos));
335	result -= sizeof(pos);
336
337	RamLogWr.CurIdx = 0;
338	RamLogWr.NextRLog = RLogW[RamLogWr.CurIdx];
339	}
340	if (result)
341	{
342	printf("Error Writing to Log File\n");
343	}
344	}
345
346	// Show Alarms *******************************************************************
347	int SearchEvent(int logType, int action, EventSt *EventData)
348	{
349	int validEvent;
350	int result;
351
352	validEvent = 0;
353	result = 0;
354
355	while (validEvent == 0 && result == 0)
356	{
357	if (action == OPEN_FILE)
358	{
359	RdAdr = Position(LOG_FILE);
360	RdAdr.rdAdd = RdAdr.wrtAdd;
361	action = PREVIOUS_EVENT;
362	}
363	else if (action == CLOSE_FILE)
364	{
365	result = 1;
366	}
367	else if (action == PREVIOUS_EVENT)
368	{
369	RdAdr.rdAdd -= RECORD_SIZE;
370
371	if (RdAdr.rdAdd <= RdAdr.startAdd)
372	{
373	if (RdAdr.eof > RdAdr.wrtAdd)
374	{
375	RdAdr.rdAdd = RdAdr.eof;
376	}
377	else
378	{
379	result = 1;
380	}
381	}
382	else if (RdAdr.rdAdd == RdAdr.wrtAdd)
383	{
384	result = 1;
385	}
386	else if (RdAdr.rdAdd == 0)
387	{
388	result = 1;
389	}
390	if (result == 0)
391	{
392	result = ReadEvent(RdAdr.rdAdd, EventData);
393	}
394	if (EventData->LogType == logType)
395	{
396	validEvent = 1;
397	}
398	else
399	{
400	action = PREVIOUS_EVENT;
401	}
402	}
403	}
404
405	return result;
406	}
407
408	// Output Format ******************************************************************
409	void FormatEvent(EventSt EventSet, char string1, char *string2)
410	{
411	char tmpStrg [DISPLAY_LENGTH + 1];
412	char year;
413
414	// Foramt Data String
415	if (EventSet->TOD.tm_year > 99)
416	{
417	year = EventSet->TOD.tm_year - 100;
418	}
419	else
420	{
421	year = EventSet->TOD.tm_year;
422	}
423	sprintf(string1, "%02d/%02d/%02d %02d:%02d", EventSet->TOD.tm_mon,
424	EventSet->TOD.tm_mday,
425	year,
426	EventSet->TOD.tm_hour,
427	EventSet->TOD.tm_min);
428
429	switch (EventSet->LogType)
430	{
431	case TEST_LOG:
432	FormatTestResault(string2, tmpStrg, EventSet);
433	if (EventSet->Code != TEST_GPH3)
434	{
435	sprintf(string2, "%s %s", string2, tmpStrg);
436	}
437	break;
438	case ALRM_LOG:
439	FormatAlarm(string2, tmpStrg, EventSet);
440	sprintf(string2, "%s %s", string2, tmpStrg);
441	break;
442	case SYST_LOG:
443	sprintf(string2, "SYSTEM BOOT");
444	break;
445	default:
446	sprintf(string2, "");
447	}
448	}
449
450	// Init Event Structure *********************************************************
451	void InitEvent(EventSt *EventSet)
452	{
453	EventSet->TOD.tm_sec = 0;
454	EventSet->TOD.tm_min = 0;
455	EventSet->TOD.tm_hour = 0;
456	EventSet->TOD.tm_mday = 0;
457	EventSet->TOD.tm_mon = 0;
458	EventSet->TOD.tm_year = 0;
459	EventSet->TOD.tm_wday = 0;
460	EventSet->Time = 0;
461	EventSet->Rate = 0.0;
462	EventSet->Product = 0;
463	EventSet->Channel = 0;
464	EventSet->LogType = 0;
465	EventSet->Code = 0;
466	EventSet->Status = 0;
467	EventSet->Notes = 0;
468	}
469
470	/*** BeginHeader */
471	#endif
472	/*** EndHeader */