logging and state implemented

Pipe/main.c

@@ -25,13 +25,13 @@ void square(pipe_t * const p)
 
 void integrate(pipe_t * const p)
 {
-  static uint32_t state = 0;
+	uint32_t * state = p->state;
 
 	while (Pipe_isFilled(p))
 	{
 		uint32_t item = Pipe_Read(p);
-    state = state + item;
+		*state = *state + item;
-    Pipe_Write(p, state);
+		Pipe_Write(p, *state);
 	}
 }
 
@@ -59,22 +59,36 @@ void average(pipe_t * const p)
 	Pipe_Write(p, average);
 }
 
+void print(pipe_t * const p)
+{
+	printf("\nOutput:\n");
+	while (Pipe_isFilled(p))
+		printf("%d\n", Pipe_Read(p));
+}
+
+void log(pipe_t * const from, pipe_t * const to, uint32_t elem)
+{
+	printf("%s -> %d -> %s\n", from->name, elem, to->name);
+}
+
 int main(int argc, char * argv[])
 {
+	uint32_t counter = 0;
+
 	/* Create pipes and connect them */
-  Pipe_Create(increment_pipe, 4);
+	Pipe_Create(increment_pipe, NULL, 4, log);
-  Pipe_Create(square_pipe, 4);
+	Pipe_Create(square_pipe, NULL, 4, log);
-  Pipe_Create(integrate_pipe, 8);
+	Pipe_Create(integrate_pipe, &counter, 8, log);
-  Pipe_Create(sum_pipe, 8);
+	Pipe_Create(sum_pipe, NULL, 8, log);
-  Pipe_Create(average_pipe, 8);
+	Pipe_Create(average_pipe, NULL, 8, log);
+	Pipe_Create(print_pipe, NULL, 4, log);
 
 	Pipe_Connect(&increment_pipe, &integrate_pipe);
 	Pipe_Connect(&square_pipe, &integrate_pipe);
-  Pipe_CreateOutput(integrate_pipe, integrate_output_rb, 8);
 	Pipe_Connect(&integrate_pipe, &sum_pipe);
-  Pipe_CreateOutput(sum_pipe, sum_output_rb, 4);
 	Pipe_Connect(&integrate_pipe, &average_pipe);
-  Pipe_CreateOutput(average_pipe, average_output_rb, 4);
+	Pipe_Connect(&sum_pipe, &print_pipe);
+	Pipe_Connect(&average_pipe, &print_pipe);
 
 	/* Generate input */
 	Pipe_Insert(&increment_pipe, 1);
@@ -85,24 +99,13 @@ int main(int argc, char * argv[])
 	Pipe_Insert(&square_pipe, 4);
 	Pipe_Insert(&square_pipe, 6);
 
-  /* run the functions */
+	/* run the functions (each can run in an own thread) */
 	increment(&increment_pipe);
 	square(&square_pipe);
 	integrate(&integrate_pipe);
 	sum(&sum_pipe);
 	average(&average_pipe);
-
+	print(&print_pipe);
-  /* print the output */
-  printf("Output:\n");
-  printf("%d\n", RingBuffer_Read(&integrate_output_rb));
-  printf("%d\n", RingBuffer_Read(&integrate_output_rb));
-  printf("%d\n", RingBuffer_Read(&integrate_output_rb));
-  printf("%d\n", RingBuffer_Read(&integrate_output_rb));
-  printf("%d\n", RingBuffer_Read(&integrate_output_rb));
-  printf("%d\n", RingBuffer_Read(&integrate_output_rb));
-  printf("\n");
-  printf("Summe: %d\n", RingBuffer_Read(&sum_output_rb));
-  printf("Average: %d\n", RingBuffer_Read(&average_output_rb));
 
 	getchar();
 

Pipe/pipe.h

@@ -10,56 +10,57 @@
 /* number of counts */
 #define PIPE_OUTPUT_COUNT 4
 
-typedef struct
+typedef struct pipe_tt
 {
 	ringbuffer_t * input;
-  ringbuffer_t *output[PIPE_OUTPUT_COUNT];
+	void * state;
+	struct pipe_tt *output[PIPE_OUTPUT_COUNT];
 	uint8_t output_count;
+	char * name;
+	void(*log)(struct pipe_tt * from, struct pipe_tt * to, uint32_t elem);
 } pipe_t;
 
+
 /***********************************/
 /* Functions to contruct pipe mesh */
 /***********************************/
 
-static inline void Pipe_Init(pipe_t * const p, ringbuffer_t * const arg_input)
+#define Concat2(a, b) a ## b
+#define Concat(a, b) Concat2(a, b)
+#define SizeOfArray(arg) ( sizeof(arg) / sizeof(arg[0]) )
+
+#define Pipe_Create(arg_name, arg_state, arg_size, arg_log)                     \
+  static uint32_t Concat(buffer, __LINE__)[arg_size];              \
+  ringbuffer_t arg_name ## _rb; \
+  RingBuffer_InitFromArray(&arg_name ## _rb, Concat(buffer, __LINE__), SizeOfArray(Concat(buffer, __LINE__))); \
+  pipe_t arg_name; \
+  Pipe_Init(&arg_name, &arg_name ## _rb, arg_state, #arg_name, arg_log)
+
+static inline void Pipe_Init(
+	pipe_t * const p,
+	ringbuffer_t * const arg_input,
+	void * arg_state,
+	char * const arg_name,
+	void(*arg_log)(struct pipe_tt * from, struct pipe_tt * to, uint32_t elem)
+	)
 {
 	p->input = arg_input;
+	p->state = arg_state;
 
 	for (uint8_t i = 0; i < PIPE_OUTPUT_COUNT; i++)
 		p->output[i] = NULL;
 
 	p->output_count = 0;
+	p->name = arg_name;
+	p->log = arg_log;
 }
 
 static inline void Pipe_Connect(pipe_t * const a, pipe_t * const b)
 {
-  a->output[a->output_count] = b->input;
+	a->output[a->output_count] = b;
 	a->output_count++;
 }
 
-static inline void Pipe_AddOutput(pipe_t * const p, ringbuffer_t * const rb)
-{
-  p->output[p->output_count] = rb;
-  p->output_count++;
-}
-
-#define Concat2(a, b) a ## b
-#define Concat(a, b) Concat2(a, b)
-#define SizeOfArray(arg) ( sizeof(arg) / sizeof(arg[0]) )
-
-#define Pipe_Create(arg_name, arg_size)                     \
-  static uint32_t Concat(buffer, __LINE__)[arg_size];              \
-  ringbuffer_t arg_name ## _rb; \
-  RingBuffer_InitFromArray(&arg_name ## _rb, Concat(buffer, __LINE__), SizeOfArray(Concat(buffer, __LINE__))); \
-  pipe_t arg_name; \
-  Pipe_Init(&arg_name, &arg_name ## _rb)
-
-#define Pipe_CreateOutput(arg_pipe, arg_name, arg_size)                     \
-  static uint32_t Concat(buffer, __LINE__)[arg_size];              \
-  ringbuffer_t arg_name; \
-  RingBuffer_InitFromArray(&arg_name, Concat(buffer, __LINE__), SizeOfArray(Concat(buffer, __LINE__))); \
-  Pipe_AddOutput(&arg_pipe, &arg_name);
-
 
 /************************************/
 /* Functions to work with pipe mesh */
@@ -78,7 +79,10 @@ static inline uint32_t Pipe_Read(pipe_t * p)
 static inline void Pipe_Write(pipe_t * p, uint32_t elem)
 {
 	for (uint8_t i = 0; i < p->output_count; i++)
-    RingBuffer_Write(p->output[i], elem);
+	{
+		p->log(p, p->output[i], elem);
+		RingBuffer_Write(p->output[i]->input, elem);
+	}
 }
 
 static inline uint8_t Pipe_isFilled(pipe_t * p)