Guest User

Untitled

a guest
Dec 16th, 2018
87
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.25 KB | None | 0 0
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <errno.h>
  4. #include <pthread.h>
  5. #include <unistd.h>
  6. #include "sbuffer.h"
  7. #include "config.h"
  8.  
  9. pthread_mutex_t data_mutex = PTHREAD_MUTEX_INITIALIZER;
  10.  
  11. // Declaration of thread condition variable
  12. pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
  13. pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
  14.  
  15. sbuffer_t * buffer;
  16.  
  17. int go = 1;
  18.  
  19. FILE * file1;
  20. FILE * file2;
  21. FILE * file1_text;
  22. FILE * file2_text;
  23.  
  24.  
  25. void pthread_err_handler( int err_code, char *msg, char *file_name, char line_nr )
  26. {
  27. if ( 0 != err_code )
  28. {
  29. fprintf( stderr, "n%s failed with error code %d in file %s at line %dn", msg, err_code, file_name, line_nr );
  30. }
  31. }
  32.  
  33. void *write1 (void)
  34. {
  35. int presult;
  36.  
  37. FILE * sensor_datat = fopen("sensor_data", "rb");
  38. uint16_t sens_ID;
  39. double temp;
  40. time_t ts;
  41.  
  42.  
  43. while(fread(&sens_ID, sizeof(uint16_t), 1, sensor_datat) == 1 && fread(&temp, sizeof(double), 1, sensor_datat) == 1 && fread(&ts, sizeof(time_t), 1, sensor_datat) == 1){
  44.  
  45. sbuffer_data_t * buffer_data = malloc(sizeof(sbuffer_data_t));
  46. buffer_data->data.id = sens_ID;
  47. buffer_data->data.value = temp;
  48. buffer_data->data.ts = ts;
  49. buffer_data->datamgr_read = 0;
  50. buffer_data->storagemgr_read = 0;
  51.  
  52. presult = pthread_mutex_lock( &data_mutex );
  53. pthread_err_handler( presult, "pthread_mutex_lock", __FILE__, __LINE__ );
  54.  
  55. sbuffer_insert(buffer, buffer_data);
  56.  
  57. pthread_cond_signal(&cond1);
  58.  
  59. presult = pthread_mutex_unlock( &data_mutex );
  60. pthread_err_handler( presult, "pthread_mutex_unlock", __FILE__, __LINE__ );
  61.  
  62. free(buffer_data);
  63. }
  64.  
  65. fclose(sensor_datat);
  66.  
  67. while(1){
  68.  
  69. presult = pthread_mutex_lock( &data_mutex );
  70. pthread_err_handler( presult, "pthread_mutex_lock", __FILE__, __LINE__ );
  71.  
  72. pthread_cond_signal(&cond1);
  73.  
  74. presult = pthread_mutex_unlock( &data_mutex );
  75. pthread_err_handler( presult, "pthread_mutex_unlock", __FILE__, __LINE__ );
  76.  
  77. }
  78. return NULL;
  79. }
  80.  
  81.  
  82. void *datamgrf (void)
  83. {
  84. int presult;
  85. file1 = fopen("sensor_data_out", "w");
  86. file1_text = fopen("sensor_data_text", "w");
  87.  
  88. sbuffer_data_t * buffer_data_prev = malloc(sizeof(sbuffer_data_t));
  89. buffer_data_prev->data.id = 0;
  90. buffer_data_prev->data.value = 0;
  91. buffer_data_prev->data.ts = 0;
  92. buffer_data_prev->datamgr_read = 0;
  93. buffer_data_prev->storagemgr_read = 0;
  94.  
  95.  
  96. while(go){
  97.  
  98. sbuffer_data_t * buffer_data = malloc(sizeof(sbuffer_data_t));
  99.  
  100. buffer_data->data.id = 0;
  101. buffer_data->data.value = 0;
  102. buffer_data->data.ts = 0;
  103. buffer_data->datamgr_read = 0;
  104. buffer_data->storagemgr_read = 0;
  105.  
  106. presult = pthread_mutex_lock( &data_mutex );
  107. pthread_err_handler( presult, "pthread_mutex_lock", __FILE__, __LINE__ );
  108.  
  109. pthread_cond_wait(&cond1, &data_mutex);
  110.  
  111. if(sbuffer_read(buffer, buffer_data) == SBUFFER_NO_DATA){
  112. exit(0);
  113. }
  114.  
  115. pthread_cond_signal(&cond2);
  116.  
  117.  
  118. presult = pthread_mutex_unlock( &data_mutex );
  119. pthread_err_handler( presult, "pthread_mutex_unlock", __FILE__, __LINE__ );
  120.  
  121. if(!(buffer_data_prev->data.id == buffer_data->data.id && buffer_data_prev->data.ts == buffer_data->data.ts)){
  122.  
  123. printf("sensor id van de eerste = %d - temperature = %g - timestamp = %ldn", buffer_data->data.id, buffer_data->data.value, (long int)buffer_data->data.ts);
  124. fwrite(&buffer_data->data.id, sizeof(buffer_data->data.id), 1, file1);
  125. fwrite(&buffer_data->data.value, sizeof(buffer_data->data.value), 1, file1);
  126. fwrite(&buffer_data->data.ts, sizeof(buffer_data->data.ts), 1, file1);
  127. fprintf(file1_text, "%d %g %ldn", buffer_data->data.id, buffer_data->data.value, buffer_data->data.ts);
  128.  
  129. }
  130.  
  131. buffer_data_prev = buffer_data;
  132. free(buffer_data);
  133.  
  134.  
  135. }
  136.  
  137. fclose(file1);
  138. fclose(file1_text);
  139. free(buffer_data_prev);
  140. return NULL;
  141. }
  142.  
  143. void *storagemgrf (void)
  144. {
  145.  
  146. int presult;
  147. file2 = fopen("sensor_data_out2", "w");
  148. file2_text = fopen("sensor_data_text2", "w");
  149.  
  150. while(go){
  151.  
  152. sbuffer_data_t * buffer_data = malloc(sizeof(sbuffer_data_t));
  153.  
  154. buffer_data->data.id = 0;
  155. buffer_data->data.value = 0;
  156. buffer_data->data.ts = 0;
  157. buffer_data->datamgr_read = 0;
  158. buffer_data->storagemgr_read = 0;
  159.  
  160. presult = pthread_mutex_lock( &data_mutex );
  161. pthread_err_handler( presult, "pthread_mutex_lock", __FILE__, __LINE__ );
  162.  
  163. pthread_cond_wait(&cond2, &data_mutex);
  164.  
  165. if(sbuffer_remove(buffer, buffer_data) == SBUFFER_NO_DATA){
  166. printf("here now 2");
  167. go = 0;
  168. }
  169.  
  170. presult = pthread_mutex_unlock( &data_mutex );
  171. pthread_err_handler( presult, "pthread_mutex_unlock", __FILE__, __LINE__ );
  172.  
  173. printf("sensor id = %d - temperature = %g - timestamp = %ldn", buffer_data->data.id, buffer_data->data.value, (long int)buffer_data->data.ts);
  174. fwrite(&buffer_data->data.id, sizeof(buffer_data->data.id), 1, file2);
  175. fwrite(&buffer_data->data.value, sizeof(buffer_data->data.value), 1, file2);
  176. fwrite(&buffer_data->data.ts, sizeof(buffer_data->data.ts), 1, file2);
  177. fprintf(file2_text, "%d %g %ldn", buffer_data->data.id, buffer_data->data.value, buffer_data->data.ts);
  178.  
  179. free(buffer_data);
  180.  
  181. }
  182.  
  183. fclose(file2);
  184. fclose(file2_text);
  185. return NULL;
  186. }
  187.  
  188.  
  189. int main(void)
  190. {
  191.  
  192. pthread_t connmgr, datamgr, storagemgr;
  193.  
  194. int presult;
  195.  
  196. sbuffer_init(&buffer);
  197.  
  198. presult = pthread_create(&connmgr, NULL, (void*)&write1, NULL);
  199. pthread_err_handler( presult, "pthread_create", __FILE__, __LINE__ );
  200.  
  201. presult = pthread_create(&datamgr, NULL, (void*)&datamgrf, NULL);
  202. pthread_err_handler( presult, "pthread_create", __FILE__, __LINE__ );
  203.  
  204. presult = pthread_create(&storagemgr, NULL, (void*)&storagemgrf, NULL);
  205. pthread_err_handler( presult, "pthread_create", __FILE__, __LINE__ );
  206.  
  207. printf("n Created threadn");
  208.  
  209. presult = pthread_join(connmgr, NULL);
  210. pthread_err_handler( presult, "pthread_join", __FILE__, __LINE__ );
  211.  
  212. pthread_join(datamgr, NULL);
  213. pthread_err_handler( presult, "pthread_join", __FILE__, __LINE__ );
  214.  
  215. pthread_join(storagemgr, NULL);
  216. pthread_err_handler( presult, "pthread_join", __FILE__, __LINE__ );
  217.  
  218. sbuffer_free(&buffer);
  219.  
  220.  
  221. presult = pthread_mutex_destroy( &data_mutex );
  222. pthread_err_handler( presult, "pthread_mutex_destroy", __FILE__, __LINE__ );
  223.  
  224. return 0;
  225. }
  226.  
  227. #include <stdlib.h>
  228. #include <stdio.h>
  229. #include <errno.h>
  230. #include "sbuffer.h"
  231.  
  232. typedef struct sbuffer_node {
  233. struct sbuffer_node * next;
  234. sbuffer_data_t element;
  235. } sbuffer_node_t;
  236.  
  237. struct sbuffer {
  238. sbuffer_node_t * head;
  239. sbuffer_node_t * tail;
  240. };
  241.  
  242.  
  243. int sbuffer_init(sbuffer_t ** buffer)
  244. {
  245. *buffer = malloc(sizeof(sbuffer_t));
  246. if (*buffer == NULL) return SBUFFER_FAILURE;
  247. (*buffer)->head = NULL;
  248. (*buffer)->tail = NULL;
  249. return SBUFFER_SUCCESS;
  250. }
  251.  
  252.  
  253. int sbuffer_free(sbuffer_t ** buffer)
  254. {
  255. sbuffer_node_t * dummy;
  256. if ((buffer==NULL) || (*buffer==NULL))
  257. {
  258. return SBUFFER_FAILURE;
  259. }
  260. while ( (*buffer)->head )
  261. {
  262. dummy = (*buffer)->head;
  263. (*buffer)->head = (*buffer)->head->next;
  264. free(dummy);
  265. }
  266. free(*buffer);
  267. *buffer = NULL;
  268. return SBUFFER_SUCCESS;
  269. }
  270.  
  271.  
  272. int sbuffer_read(sbuffer_t * buffer, sbuffer_data_t * buffer_data)
  273. {
  274. if (buffer == NULL) return SBUFFER_FAILURE;
  275. if (buffer->head == NULL) return SBUFFER_NO_DATA;
  276. *buffer_data = buffer->head->element;
  277.  
  278. return SBUFFER_SUCCESS;
  279.  
  280. }
  281.  
  282.  
  283. int sbuffer_remove(sbuffer_t * buffer, sbuffer_data_t * buffer_data)
  284. {
  285. sbuffer_node_t * dummy;
  286. if (buffer == NULL) return SBUFFER_FAILURE;
  287. if (buffer->head == NULL) return SBUFFER_NO_DATA;
  288. *buffer_data = buffer->head->element;
  289. dummy = buffer->head;
  290. if (buffer->head == buffer->tail) // buffer has only one node
  291. {
  292. buffer->head = buffer->tail = NULL;
  293. }
  294. else // buffer has many nodes empty
  295. {
  296. buffer->head = buffer->head->next;
  297. }
  298. free(dummy);
  299. return SBUFFER_SUCCESS;
  300. }
  301.  
  302.  
  303. int sbuffer_insert(sbuffer_t * buffer, sbuffer_data_t * buffer_data)
  304. {
  305. sbuffer_node_t * dummy;
  306. if (buffer == NULL) return SBUFFER_FAILURE;
  307. dummy = malloc(sizeof(sbuffer_node_t));
  308. if (dummy == NULL) return SBUFFER_FAILURE;
  309. dummy->element = *buffer_data;
  310. dummy->next = NULL;
  311. if (buffer->tail == NULL) // buffer empty (buffer->head should also be NULL
  312. {
  313. buffer->head = buffer->tail = dummy;
  314. }
  315. else // buffer not empty
  316. {
  317. buffer->tail->next = dummy;
  318. buffer->tail = buffer->tail->next;
  319. }
  320. return SBUFFER_SUCCESS;
  321. }
  322.  
  323. int sbuffer_insert_head(sbuffer_t * buffer, sbuffer_data_t * buffer_data){
  324.  
  325. sbuffer_node_t * dummy;
  326. if (buffer == NULL) return SBUFFER_FAILURE;
  327. dummy = malloc(sizeof(sbuffer_node_t));
  328. if (dummy == NULL) return SBUFFER_FAILURE;
  329. dummy->element = *buffer_data;
  330.  
  331. if (buffer->tail == NULL) // buffer empty (buffer->head should also be NULL
  332. {
  333. buffer->head = buffer->tail = dummy;
  334. dummy->next = NULL;
  335. }
  336. else // buffer not empty
  337. {
  338. buffer->head = dummy;
  339. dummy->next = buffer->head;
  340. }
  341. return SBUFFER_SUCCESS;
  342.  
  343.  
  344. }
  345.  
  346. #ifndef _SBUFFER_H_
  347. #define _SBUFFER_H_
  348.  
  349. #include "config.h"
  350.  
  351. #define SBUFFER_FAILURE -1
  352. #define SBUFFER_SUCCESS 0
  353. #define SBUFFER_NO_DATA 1
  354.  
  355.  
  356. typedef struct sbuffer sbuffer_t;
  357.  
  358. /*
  359. * All data that can be stored in the sbuffer should be encapsulated in a
  360. * structure, this structure can then also hold extra info needed for your implementation
  361. */
  362. //typedef struct sbuffer_data sbuffer_data_t;
  363. typedef struct sbuffer_data {
  364. sensor_data_t data;
  365. int datamgr_read;
  366. int storagemgr_read;
  367.  
  368. } sbuffer_data_t;
  369.  
  370.  
  371. /*
  372. * Allocates and initializes a new shared buffer
  373. * Returns SBUFFER_SUCCESS on success and SBUFFER_FAILURE if an error occured
  374. */
  375. int sbuffer_init(sbuffer_t ** buffer);
  376.  
  377.  
  378. /*
  379. * All allocated resources are freed and cleaned up
  380. * Returns SBUFFER_SUCCESS on success and SBUFFER_FAILURE if an error occured
  381. */
  382. int sbuffer_free(sbuffer_t ** buffer);
  383.  
  384.  
  385. int sbuffer_read(sbuffer_t * buffer, sbuffer_data_t * buffer_data);
  386.  
  387. /*
  388. * Removes the first data in 'buffer' (at the 'head') and returns this data as '*data'
  389. * 'data' must point to allocated memory because this functions doesn't allocated memory
  390. * If 'buffer' is empty, the function doesn't block until new data becomes available but returns SBUFFER_NO_DATA
  391. * Returns SBUFFER_SUCCESS on success and SBUFFER_FAILURE if an error occured
  392. */
  393. int sbuffer_remove(sbuffer_t * buffer, sbuffer_data_t * buffer_data);
  394.  
  395.  
  396. /* Inserts the data in 'data' at the end of 'buffer' (at the 'tail')
  397. * Returns SBUFFER_SUCCESS on success and SBUFFER_FAILURE if an error occured
  398. */
  399. int sbuffer_insert(sbuffer_t * buffer, sbuffer_data_t * data);
  400.  
  401. int sbuffer_insert_head(sbuffer_t * buffer, sbuffer_data_t * data);
  402.  
  403.  
  404. #endif //_SBUFFER_H_
Add Comment
Please, Sign In to add comment