summaryrefslogtreecommitdiff
path: root/cesar/test_general/ecos/src/mutex.c
blob: 390bbc4a399779dbd046706e517e52f59697d219 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
/* Cesar project {{{
 *
 * Copyright (C) 2008 Spidcom
 *
 * <<<Licence>>>
 *
 * }}} */
/**
 * \file    mutex.c
 * \brief   « brief description »
 * \ingroup « module »
 *
 * « long description »
 */
#include <cyg/kernel/kapi.h>
#include <cyg/infra/diag.h>
#include <cyg/io/io.h>
#include <stdio.h>

#define THREAD_STACK_SIZE (40960 / sizeof(int))

int thread_a_stack[THREAD_STACK_SIZE];
cyg_handle_t thread_a_handle;
cyg_thread thread_a_obj;
int thread_b_stack[THREAD_STACK_SIZE];
cyg_handle_t thread_b_handle;
cyg_thread thread_b_obj;

cyg_mutex_t mut_shared;

unsigned char transfert_message[] = "Nobody";

//
// Thread A.
//
void thread_a(cyg_addrword_t index)
{
    unsigned char write_buffer[] = "Thread A";

    // Run this thread forever.
    while (1)
    {
        // Delay for 5 seconds (10ms * 500ticks).
        cyg_thread_delay(500);

        // Get the mutex.
        cyg_mutex_lock(&mut_shared);

        diag_printf("Thrd A : %s\n",transfert_message);
        // Write data to the global buffer.
        memcpy(transfert_message, write_buffer, sizeof(write_buffer));

        // Release the mutex.
        cyg_mutex_unlock(&mut_shared);
    }
}

//
// Thread B.
//
void thread_b(cyg_addrword_t index)
{
    unsigned char write_buffer[] = "Thread B";

    // Run this thread forever.
    while (1)
    {
        // Delay for 2 seconds (10ms * 200ticks).
        cyg_thread_delay(200);

        // Get the mutex.
        cyg_mutex_lock(&mut_shared);

        diag_printf("Thrd B : %s\n",transfert_message);
        // Write data to the global buffer.
        memcpy(transfert_message, write_buffer, sizeof(write_buffer));

        // Release the mutex.
        cyg_mutex_unlock(&mut_shared);
    }
}

//
// Main.
//
void cyg_user_start(void)
{
  cyg_thread_create(12, thread_a, (cyg_addrword_t) 0,
		    "Thread A", &thread_a_stack, THREAD_STACK_SIZE,
		    &thread_a_handle, &thread_a_obj);
  cyg_thread_create(12, thread_b, (cyg_addrword_t) 0,
		    "Thread B", &thread_b_stack, THREAD_STACK_SIZE,
		    &thread_b_handle, &thread_b_obj);

  // Mutex creation
  cyg_mutex_init(&mut_shared);

  cyg_thread_resume(thread_a_handle);
  cyg_thread_resume(thread_b_handle);

  diag_write_string("Starting Scheduler...\n");
  
  cyg_scheduler_start();
}