A.9 Message.hh

1 // Message.hh

2

3#ifndef __MESSGAE_HH_DEFINED__

4#define __MESSGAE_HH_DEFINED__

5class Message

6{

7public:

11void * Body;

12const Task * Sender;

13};

14

15 #endif __MESSGAE_HH_DEFINED__

A.10 Channels.hh

1// Channels.hh

2#ifndef __CHANNELS_HH_DEFINED__

3#define __CHANNELS_HH_DEFINED__

5enum Channel {

13extern Channel MonitorIn;

14extern Channel MonitorOut;

15extern Channel ErrorOut;

16extern Channel GeneralOut;

18#endif __CHANNELS_HH_DEFINED__

A.11 SerialOut.hh

1 /* SerialOut.hh */

2

3#ifndef __SERIALOUT_HH_DEFINED__

4#define __SERIALOUT_HH_DEFINED__

6#include "Channels.hh"

8// forward declarations...

9class Semaphore;

10 template <class Type> class Queue_Psem;

11

12class SerialOut

13{

14public:

15SerialOut(Channel);

16~SerialOut();

17

18static int Print(Channel, const char *, ...);

19static int IsEmpty(Channel);

20

21int Print(const char *, ...);

22void Putc(int character);

23private:

24static int print_form(void (*)(int),

28static void Putc_0(int c);

29static void Putc_1(int c);

36static Semaphore Channel_0;

37static Semaphore Channel_1;

39static Queue_Psem<unsigned char> outbuf_0;

40static Queue_Psem<unsigned char> outbuf_1;

42static int TxEnabled_0;

43static int TxEnabled_1;

44};

46#endif __SERIALOUT_HH_DEFINED__

A.12 SerialOut.cc

1 /* SerialOut.cc */

2

3#include "System.config"

4#include "os.hh"

5#include "Task.hh"

6#include "SerialOut.hh"

7#include "Duart.hh"

8

9//=================================================================

10Queue_Psem<unsigned char> SerialOut::outbuf_0 (OUTBUF_0_SIZE);

11Queue_Psem<unsigned char> SerialOut::outbuf_1 (OUTBUF_1_SIZE);

12

13 int SerialOut::TxEnabled_0 = 1; // pretend Transmitter is enabled at startup

14 int SerialOut::TxEnabled_1 = 1;

15

16Semaphore SerialOut::Channel_0;

17Semaphore SerialOut::Channel_1;

19//=================================================================

20SerialOut::SerialOut(Channel ch) : channel(ch)

21{

22switch(channel)

23{

24case SERIAL_0:

34case SERIAL_0_POLLED:

35case SERIAL_1_POLLED:

41}

42}

43//-----------------------------------------------------------------

44SerialOut::~SerialOut()

45{

46switch(channel)

47{

50}

51}

52//=================================================================

53void SerialOut::Putc_0(int c)

54{

55unsigned char cc = c;

57outbuf_0.Put(cc);

58if (!TxEnabled_0)

59{

60TxEnabled_0 = 1;

62}

63}

64//-----------------------------------------------------------------

65void SerialOut::Putc_1(int c)

66{

67unsigned char cc = c;

68

69outbuf_1.Put(cc);

70if (!TxEnabled_1)

71{

72TxEnabled_1 = 1;

74}

75}

76//-----------------------------------------------------------------

77void SerialOut::Putc_0_polled(int c)

78{

86}

87//-----------------------------------------------------------------

88void SerialOut::Putc_1_polled(int c)

89{

97}

98//-----------------------------------------------------------------

99void SerialOut::Putc_dummy(int)

100{

101// dummy Putc to compute length

102}

103//-----------------------------------------------------------------

104void SerialOut::Putc(int c)

105{

106switch(channel)

107{

114}

115}

116//=================================================================

118const char * const hex = "0123456789abcdef";

119const char * const HEX = "0123456789ABCDEF";

121//-----------------------------------------------------------------

122int SerialOut::IsEmpty(Channel channel)

123{

124switch(channel)

125{

126case 0: return outbuf_0.IsEmpty();

127case 1: return outbuf_1.IsEmpty();

128}

129return 1; // Polled, dummy and remote IO is always empty

130}

131//-----------------------------------------------------------------

132int SerialOut::Print(Channel channel, const char * format, ...)

133{

134SerialOut so(channel);

135

136void (*putc)(int);

137const unsigned char ** ap = (const unsigned char **)&format;

142switch(channel)

143{

156return len;

157}

158//-----------------------------------------------------------------

159int SerialOut::Print(const char * format, ...)

160{

161void (*putc)(int);

162const unsigned char ** ap = (const unsigned char **)&format;

163const unsigned char * f = *ap++;

164int len = 0;

165int cc;

166

167switch(channel)

168{

181return len;

182}

183//=================================================================

184int

185SerialOut::print_form(void (*putc)(int),

188{

189int len = 0;

190int min_len = 0;

191int buf_idx = 0;

192union { const unsigned char * cp;

193const char * scp;

194long lo;

195unsigned long ul; } data;

196int cc;

197unsigned char buf[10];

198

199for (;;)

200{

201switch(cc = *f++)

202{

275}

276}

277//=================================================================