Bosco Test

1// 3_apparecchiatura_cpp: implementazione del modulo per la gestione della  barriera laser
2
3namespace Apparecchiatura {
4	
5	Barriera::Barriera(int  pin_laser_a, int pin_laser_b, int pin_foto_a, int pin_foto_b)
6		:pin_l_a{pin_laser_a},  pin_f_a{pin_foto_a} {
7		// eventuale correzione dell'input
8		pin_l_b =  pin_laser_b <= pin_laser_a ? pin_l_a + 1 : pin_laser_b;
9		pin_f_b = pin_foto_b  <= pin_foto_a ? pin_f_a + 1: pin_foto_b;
10		// configurazione pin
11		for  (int i { pin_l_a }; i < pin_l_b; ++i)
12			pinMode(i, OUTPUT);
13		// spengimento  eventuali laser rimasti accesi da precedente utilizzo
14		imposta_laser(LOW);
15	}
16
17	Barriera::~Barriera()  {
18		spegni();
19	}
20
21	int Barriera::pin_laser_a() const {
22		return  pin_l_a;
23	}
24
25	int Barriera::pin_laser_b() const {
26		return pin_l_b;
27	}
28
29	int  Barriera::pin_foto_a() const {
30		return pin_f_a;
31	}
32
33	int Barriera::pin_foto_b()  const {
34		return pin_f_b;
35	}
36	
37	bool Barriera::stato() const {
38		return  st;
39	}
40
41	bool Barriera::accendi() {
42		if (st) // barriera gi accesa
43			return  false;
44		luce_naturale = leggi_fotoresistenze();
45		imposta_laser(HIGH);
46		st  = true;
47		return true;
48	}
49
50	bool Barriera::spegni() {
51		if  (!(st && luce_naturale)) // barriera gi spenta, barriera accesa non correttamente
52			return  false;
53		imposta_laser(LOW);
54		st = false;
55		return true;
56	}
57
58	bool  Barriera::ostacolo() const {
59		if (!st) // barriera spenta
60			return  false;
61		for (int i { pin_f_a }; i < pin_f_b; ++i)
62			if (analogRead(i)  <= luce_naturale + tolleranza)
63				return true;
64		return false;
65	}
66	
67	void  Barriera::imposta_laser(int valore) {
68		for (int i { pin_l_a }; i < pin_l_b;  ++i)
69			digitalWrite(i, valore);
70	}
71
72	int Barriera::leggi_fotoresistenze()  const {
73		int somma { 0 };
74		for (int i { pin_f_a }; i < pin_f_b; ++i)
75			somma  += analogRead(i);
76		return somma / (pin_f_b - pin_f_a);
77	}
78}
79

1// 2_main_cpp: il punto di ingresso del programma (contiene setup() e   void())
2
3namespace {
4	constexpr int pin_laser_inizio { 2 },
5				   pin_laser_fine { 3 },
6				  pin_fotoresistenza_inizio { 0 },
7				   pin_fotoresistenza_fine { 1 },
8				  pin_bluetooth_trasmettitore { 10 },
9				   pin_bluetooth_ricevitore { 11 };
10	
11	Apparecchiatura::Barriera pedana(pin_laser_inizio,   pin_laser_fine, pin_fotoresistenza_inizio, pin_fotoresistenza_fine);
12	Connessione::Terminale   operatore(pedana, pin_bluetooth_trasmettitore, pin_bluetooth_ricevitore); 
13}
14
15void   setup() {
16	operatore.setup();
17}
18
19void loop() {
20  operatore.loop();
21}
22

1// 1_connessione_h: intestazione del modulo di connessione bluetooth al   terminale
2
3#ifndef CONNESSIONE_H
4#define CONNESSIONE_H
5
6#include   <SoftwareSerial.h>
7
8namespace Connessione {
9
10	class Terminale {
11	public:
12		//   inizializzazione obbligatoria
13		Terminale(Apparecchiatura::Barriera& barriera,   int pin_tra, int pin_ric,
14				  long baud = baud_def, HardwareSerial& debug   = Serial, long baud_debug = baud_debug_def);
15		Terminale(Apparecchiatura::Barriera&   barriera, int pin_tra, int pin_ric,
16				  HardwareSerial& debug, long baud_debug   = baud_debug_def);
17		Terminale() = delete;
18		// spostamento consentito
19		Terminale(Terminale&&)   = default;
20		Terminale& operator=(Terminale&&) = default;
21		// copia vietata:   un pin dovrebbe appartenere a un solo terminale
22		Terminale(const Terminale&)   = default;
23		Terminale& operator=(const Terminale&) = delete;
24		// distruttore   predefinito
25		~Terminale() = default;
26
27		// costanti
28		static   constexpr long baud_def { 9600 }, baud_debug_def { 9600 };
29		static constexpr   char comando_stato { '0' }, // chiede se la barriera sia accesa
30							   comando_spegni { '1' }, // spegne la barriera
31							  comando_accendi   { '2' }, // accende la barriera
32							  comando_chiedi { '3' }, // chiede   una prova di N salti
33							  comando_abortisci { '4' }; // annulla la   richiesta
34		static constexpr int salti_richiesti_default { 1 };
35		static   constexpr size_t salti_richiesti_string_dim { 10 };
36
37		// getter
38		Apparecchiatura::Barriera&   barriera() const;
39		int pin_tra() const;
40		int pin_ric() const;
41		long   baud() const;
42		HardwareSerial& debug() const;
43		long baud_debug() const;
44
45		void   setup();
46		void loop();
47
48	private:
49		Apparecchiatura::Barriera&   bar; // la barriera controllata dal terminale
50		int pin_tx, pin_rx; // pin   del flusso di comunicazione col terminale
51		SoftwareSerial m; // modulo per   la comunicazione col terminale
52		long b; // velocit di trasmissione (in baud)   col terminale
53		HardwareSerial& d; // pin del flusso di comunicazione per debug
54		long   b_d; // velocit di trasmissione (in baud) per debug 
55
56		void azione_stato();
57		void   azione_spegni();
58		void azione_accendi();
59		void azione_chiedi();
60		bool   azione_aborto();
61		void azione_sconosciuta(char input);
62
63		int calcola_salti_richiesti();
64	};
65	
66}
67
68#endif
69

1// 2_main_cpp: il punto di ingresso del programma (contiene setup() e  void())
2
3namespace {
4	constexpr int pin_laser_inizio { 2 },
5				  pin_laser_fine { 3 },
6				  pin_fotoresistenza_inizio { 0 },
7				  pin_fotoresistenza_fine { 1 },
8				  pin_bluetooth_trasmettitore { 10 },
9				  pin_bluetooth_ricevitore { 11 };
10	
11	Apparecchiatura::Barriera pedana(pin_laser_inizio,  pin_laser_fine, pin_fotoresistenza_inizio, pin_fotoresistenza_fine);
12	Connessione::Terminale  operatore(pedana, pin_bluetooth_trasmettitore, pin_bluetooth_ricevitore); 
13}
14
15void  setup() {
16	operatore.setup();
17}
18
19void loop() {
20  operatore.loop();
21}
22

1// 3_apparecchiatura_cpp: implementazione del modulo per la gestione della
2  barriera laser
3
4namespace Apparecchiatura {
5	
6	Barriera::Barriera(int
7  pin_laser_a, int pin_laser_b, int pin_foto_a, int pin_foto_b)
8		:pin_l_a{pin_laser_a},
9  pin_f_a{pin_foto_a} {
10		// eventuale correzione dell'input
11		pin_l_b =
12  pin_laser_b <= pin_laser_a ? pin_l_a + 1 : pin_laser_b;
13		pin_f_b = pin_foto_b
14  <= pin_foto_a ? pin_f_a + 1: pin_foto_b;
15		// configurazione pin
16		for
17  (int i { pin_l_a }; i < pin_l_b; ++i)
18			pinMode(i, OUTPUT);
19		// spengimento
20  eventuali laser rimasti accesi da precedente utilizzo
21		imposta_laser(LOW);
22	}
23
24	Barriera::~Barriera()
25  {
26		spegni();
27	}
28
29	int Barriera::pin_laser_a() const {
30		return
31  pin_l_a;
32	}
33
34	int Barriera::pin_laser_b() const {
35		return pin_l_b;
36	}
37
38	int
39  Barriera::pin_foto_a() const {
40		return pin_f_a;
41	}
42
43	int Barriera::pin_foto_b()
44  const {
45		return pin_f_b;
46	}
47	
48	bool Barriera::stato() const {
49		return
50  st;
51	}
52
53	bool Barriera::accendi() {
54		if (st) // barriera gi accesa
55			return
56  false;
57		luce_naturale = leggi_fotoresistenze();
58		imposta_laser(HIGH);
59		st
60  = true;
61		return true;
62	}
63
64	bool Barriera::spegni() {
65		if
66  (!(st && luce_naturale)) // barriera gi spenta, barriera accesa non correttamente
67			return
68  false;
69		imposta_laser(LOW);
70		st = false;
71		return true;
72	}
73
74	bool
75  Barriera::ostacolo() const {
76		if (!st) // barriera spenta
77			return
78  false;
79		for (int i { pin_f_a }; i < pin_f_b; ++i)
80			if (analogRead(i)
81  <= luce_naturale + tolleranza)
82				return true;
83		return false;
84	}
85	
86	void
87  Barriera::imposta_laser(int valore) {
88		for (int i { pin_l_a }; i < pin_l_b;
89  ++i)
90			digitalWrite(i, valore);
91	}
92
93	int Barriera::leggi_fotoresistenze()
94  const {
95		int somma { 0 };
96		for (int i { pin_f_a }; i < pin_f_b; ++i)
97			somma
98  += analogRead(i);
99		return somma / (pin_f_b - pin_f_a);
100	}
101}
102

1/*
2	Program: test di bosco
3	Date: 16/09/2019
4	Author: Volpe  Stefano | V Bsa | L.S. "A. Oriani" Ravenna
5	
6	Currently, everything is  coded "in Italian" (WIP?)
7*/

1// 4_connessione_cpp: implementazione del modulo di connessione bluetooth
2  al terminale
3
4namespace Connessione {
5	
6	Terminale::Terminale(Apparecchiatura::Barriera&
7  barriera, int pin_tra, int pin_ric,
8						 long baud, HardwareSerial& debug,
9  long baud_debug)
10		:bar{barriera},
11		pin_tx{pin_tra},
12		pin_rx{pin_ric},
13		m{SoftwareSerial(pin_tx,
14  pin_rx)},
15		b{baud}, d{debug},
16		b_d{baud_debug} {
17		// preparazione
18  modulo di connessione
19		m.begin(b);
20	}
21
22	Terminale::Terminale(Apparecchiatura::Barriera&
23  barriera, int pin_tra, int pin_ric,
24						 HardwareSerial& debug, long
25  baud_debug)
26		:Terminale{barriera, pin_tra, pin_ric, baud_def, debug, baud_debug}
27  { }
28
29	Apparecchiatura::Barriera& Terminale::barriera() const {
30		return
31  bar;
32	}
33
34	int Terminale::pin_tra() const {
35		return pin_tx;
36	}
37
38	int
39  Terminale::pin_ric() const {
40		return pin_rx;
41	}
42
43	long Terminale::baud()
44  const {
45		return b;
46	}
47
48	HardwareSerial& Terminale::debug() const
49  {
50		return d;
51	}
52
53	long Terminale::baud_debug() const {
54		return
55  b_d;
56	}
57
58	void Terminale::setup() {
59		d.begin(b_d);
60		d.println("Modulo
61  di connessione al terminale in funzione.");
62	}
63	
64	void Terminale::loop()
65  {
66		if (m.available()) {
67			char input { m.read() };
68			switch
69  (input) {
70			case comando_stato:
71				azione_stato();
72				break;
73			case
74  comando_spegni:
75				azione_spegni();
76				break;
77			case comando_accendi:
78				azione_accendi();
79				break;
80			case
81  comando_chiedi:
82				azione_chiedi();
83				break;
84			case comando_abortisci:
85				d.println("Aborto
86  fallito (nessuna richiesta da abortire.");
87				break;
88			default:
89				azione_sconosciuta(input);
90			}
91		}
92	}
93	
94	void
95  Terminale::azione_stato() {
96		m.println(bar.stato());
97		d.println("Stato
98  della barriera comunicato.");
99	}
100	
101	void Terminale::azione_spegni()
102  {
103		if (bar.spegni())
104			d.println("Barriera spenta.");
105		else
106			d.println("Barriera
107  spenta da prima.");
108	}
109	
110	void Terminale::azione_accendi() {
111		if
112  (bar.accendi())
113			d.println("Barriera accesa.");
114		else
115			d.println("Barriera
116  accesa da prima.");		
117	}
118
119	void Terminale::azione_chiedi() {
120		if
121  (!bar.ostacolo()) {
122			m.println(false);
123			m.readString(); // ignoro
124  il resto dell'input
125			d.println("Atleta non rilevato sulla pedana.");
126			return;
127		}
128		const
129  int salti_richiesti = calcola_salti_richiesti();
130		d.print("Salti richiesti:
131  ");
132		d.print(salti_richiesti);
133		d.println(".");
134		for (int i
135  { 0 }; i < salti_richiesti; ++i) {
136			while (bar.ostacolo()) // prima dello
137  stacco
138				if (azione_aborto())
139					return;
140			const unsigned
141  long millis_stacco { millis() };
142			while (!bar.ostacolo()) // fase di volo
143				if
144  (azione_aborto())
145					return;
146			m.println(millis() - millis_stacco);
147			d.print("Salto
148  #");
149			d.print(i + 1);
150			d.println(" acquisito.");
151		}
152	}
153
154	bool
155  Terminale::azione_aborto() {
156		if (m.available() && m.read() == comando_abortisci)
157  {
158			d.println("Prova abortita.");
159			return true;
160		}
161		return
162  false;
163	}
164	
165	void Terminale::azione_sconosciuta(char input) {
166		d.print("Comando
167  '");
168		d.print(input);
169		d.println("' non riconosciuto.");
170	}
171
172	int
173  Terminale::calcola_salti_richiesti() {
174		if (!m.available())
175			return
176  salti_richiesti_default;
177		char salti_richiesti[salti_richiesti_string_dim];
178		m.readString().toCharArray(salti_richiesti,
179  salti_richiesti_string_dim);
180		return atoi(salti_richiesti);
181	}
182	
183}
184

1// 0_apparecchiatura_h: intestazione del modulo per la gestione della
2  barriera laser
3
4#ifndef APPARECCHIATURA_H
5#define APPARECCHIATURA_H
6
7namespace
8  Apparecchiatura {
9
10	// una barriera dovrebbe avere l'esclusiva sull'accesso
11  ai propri pin
12	class Barriera {
13	public:
14		// inizializzazione obbligatoria
15		Barriera(int
16  pin_laser_a, int pin_laser_b, int pin_foto_a, int pin_foto_b); // [a, b[
17		Barriera()
18  = delete;
19		// spostamento consentito
20		Barriera(Barriera&&) = default;
21		Barriera&
22  operator=(Barriera&&) = default;
23		// copia vietata: un pin dovrebbe appartenere
24  a una sola barriera
25		Barriera(const Barriera&) = default;
26		Barriera&
27  operator=(const Barriera&) = delete;
28		// la barriera viene spenta alla distruzione
29		~Barriera();
30
31		//
32  costanti e getter
33		static constexpr int tolleranza { 100 }; // fra lettura
34  luce naturale e lettura a barriera accesa con ostacolo
35		int pin_laser_a()
36  const;
37		int pin_laser_b() const;
38		int pin_foto_a() const;
39		int
40  pin_foto_b() const;
41		bool stato() const; // true = accesa, false = spenta
42
43		//
44  false: la barriera era gi nello stato desiderato
45		bool accendi();
46		bool
47  spegni();
48		bool ostacolo() const; // false se non ci sono ostacoli o a barriera
49  spenta
50
51	private:
52		int pin_l_a, pin_l_b, pin_f_a, pin_f_b; // primi
53  e ultimi pin per laser e fotoresistenze
54		bool st; // true = accesa, false
55  = spenta
56		int luce_naturale { 0 };
57		
58		void imposta_laser(int valore);
59  // HIGH o LOW
60		int leggi_fotoresistenze() const; // media delle analogRead()
61	};
62	
63}
64
65#endif
66

1// 4_connessione_cpp: implementazione del modulo di connessione bluetooth  al terminale
2
3namespace Connessione {
4	
5	Terminale::Terminale(Apparecchiatura::Barriera&  barriera, int pin_tra, int pin_ric,
6						 long baud, HardwareSerial& debug,  long baud_debug)
7		:bar{barriera},
8		pin_tx{pin_tra},
9		pin_rx{pin_ric},
10		m{SoftwareSerial(pin_tx,  pin_rx)},
11		b{baud}, d{debug},
12		b_d{baud_debug} {
13		// preparazione  modulo di connessione
14		m.begin(b);
15	}
16
17	Terminale::Terminale(Apparecchiatura::Barriera&  barriera, int pin_tra, int pin_ric,
18						 HardwareSerial& debug, long  baud_debug)
19		:Terminale{barriera, pin_tra, pin_ric, baud_def, debug, baud_debug}  { }
20
21	Apparecchiatura::Barriera& Terminale::barriera() const {
22		return  bar;
23	}
24
25	int Terminale::pin_tra() const {
26		return pin_tx;
27	}
28
29	int  Terminale::pin_ric() const {
30		return pin_rx;
31	}
32
33	long Terminale::baud()  const {
34		return b;
35	}
36
37	HardwareSerial& Terminale::debug() const  {
38		return d;
39	}
40
41	long Terminale::baud_debug() const {
42		return  b_d;
43	}
44
45	void Terminale::setup() {
46		d.begin(b_d);
47		d.println("Modulo  di connessione al terminale in funzione.");
48	}
49	
50	void Terminale::loop()  {
51		if (m.available()) {
52			char input { m.read() };
53			switch  (input) {
54			case comando_stato:
55				azione_stato();
56				break;
57			case  comando_spegni:
58				azione_spegni();
59				break;
60			case comando_accendi:
61				azione_accendi();
62				break;
63			case  comando_chiedi:
64				azione_chiedi();
65				break;
66			case comando_abortisci:
67				d.println("Aborto  fallito (nessuna richiesta da abortire.");
68				break;
69			default:
70				azione_sconosciuta(input);
71			}
72		}
73	}
74	
75	void  Terminale::azione_stato() {
76		m.println(bar.stato());
77		d.println("Stato  della barriera comunicato.");
78	}
79	
80	void Terminale::azione_spegni()  {
81		if (bar.spegni())
82			d.println("Barriera spenta.");
83		else
84			d.println("Barriera  spenta da prima.");
85	}
86	
87	void Terminale::azione_accendi() {
88		if  (bar.accendi())
89			d.println("Barriera accesa.");
90		else
91			d.println("Barriera  accesa da prima.");		
92	}
93
94	void Terminale::azione_chiedi() {
95		if  (!bar.ostacolo()) {
96			m.println(false);
97			m.readString(); // ignoro  il resto dell'input
98			d.println("Atleta non rilevato sulla pedana.");
99			return;
100		}
101		const  int salti_richiesti = calcola_salti_richiesti();
102		d.print("Salti richiesti:  ");
103		d.print(salti_richiesti);
104		d.println(".");
105		for (int i  { 0 }; i < salti_richiesti; ++i) {
106			while (bar.ostacolo()) // prima dello  stacco
107				if (azione_aborto())
108					return;
109			const unsigned  long millis_stacco { millis() };
110			while (!bar.ostacolo()) // fase di volo
111				if  (azione_aborto())
112					return;
113			m.println(millis() - millis_stacco);
114			d.print("Salto  #");
115			d.print(i + 1);
116			d.println(" acquisito.");
117		}
118	}
119
120	bool  Terminale::azione_aborto() {
121		if (m.available() && m.read() == comando_abortisci)  {
122			d.println("Prova abortita.");
123			return true;
124		}
125		return  false;
126	}
127	
128	void Terminale::azione_sconosciuta(char input) {
129		d.print("Comando  '");
130		d.print(input);
131		d.println("' non riconosciuto.");
132	}
133
134	int  Terminale::calcola_salti_richiesti() {
135		if (!m.available())
136			return  salti_richiesti_default;
137		char salti_richiesti[salti_richiesti_string_dim];
138		m.readString().toCharArray(salti_richiesti,  salti_richiesti_string_dim);
139		return atoi(salti_richiesti);
140	}
141	
142}
143

1// 1_connessione_h: intestazione del modulo di connessione bluetooth al  terminale
2
3#ifndef CONNESSIONE_H
4#define CONNESSIONE_H
5
6#include  <SoftwareSerial.h>
7
8namespace Connessione {
9
10	class Terminale {
11	public:
12		//  inizializzazione obbligatoria
13		Terminale(Apparecchiatura::Barriera& barriera,  int pin_tra, int pin_ric,
14				  long baud = baud_def, HardwareSerial& debug  = Serial, long baud_debug = baud_debug_def);
15		Terminale(Apparecchiatura::Barriera&  barriera, int pin_tra, int pin_ric,
16				  HardwareSerial& debug, long baud_debug  = baud_debug_def);
17		Terminale() = delete;
18		// spostamento consentito
19		Terminale(Terminale&&)  = default;
20		Terminale& operator=(Terminale&&) = default;
21		// copia vietata:  un pin dovrebbe appartenere a un solo terminale
22		Terminale(const Terminale&)  = default;
23		Terminale& operator=(const Terminale&) = delete;
24		// distruttore  predefinito
25		~Terminale() = default;
26
27		// costanti
28		static  constexpr long baud_def { 9600 }, baud_debug_def { 9600 };
29		static constexpr  char comando_stato { '0' }, // chiede se la barriera sia accesa
30							  comando_spegni { '1' }, // spegne la barriera
31							  comando_accendi  { '2' }, // accende la barriera
32							  comando_chiedi { '3' }, // chiede  una prova di N salti
33							  comando_abortisci { '4' }; // annulla la  richiesta
34		static constexpr int salti_richiesti_default { 1 };
35		static  constexpr size_t salti_richiesti_string_dim { 10 };
36
37		// getter
38		Apparecchiatura::Barriera&  barriera() const;
39		int pin_tra() const;
40		int pin_ric() const;
41		long  baud() const;
42		HardwareSerial& debug() const;
43		long baud_debug() const;
44
45		void  setup();
46		void loop();
47
48	private:
49		Apparecchiatura::Barriera&  bar; // la barriera controllata dal terminale
50		int pin_tx, pin_rx; // pin  del flusso di comunicazione col terminale
51		SoftwareSerial m; // modulo per  la comunicazione col terminale
52		long b; // velocit di trasmissione (in baud)  col terminale
53		HardwareSerial& d; // pin del flusso di comunicazione per debug
54		long  b_d; // velocit di trasmissione (in baud) per debug 
55
56		void azione_stato();
57		void  azione_spegni();
58		void azione_accendi();
59		void azione_chiedi();
60		bool  azione_aborto();
61		void azione_sconosciuta(char input);
62
63		int calcola_salti_richiesti();
64	};
65	
66}
67
68#endif
69

1// 0_apparecchiatura_h: intestazione del modulo per la gestione della  barriera laser
2
3#ifndef APPARECCHIATURA_H
4#define APPARECCHIATURA_H
5
6namespace  Apparecchiatura {
7
8	// una barriera dovrebbe avere l'esclusiva sull'accesso  ai propri pin
9	class Barriera {
10	public:
11		// inizializzazione obbligatoria
12		Barriera(int  pin_laser_a, int pin_laser_b, int pin_foto_a, int pin_foto_b); // [a, b[
13		Barriera()  = delete;
14		// spostamento consentito
15		Barriera(Barriera&&) = default;
16		Barriera&  operator=(Barriera&&) = default;
17		// copia vietata: un pin dovrebbe appartenere  a una sola barriera
18		Barriera(const Barriera&) = default;
19		Barriera&  operator=(const Barriera&) = delete;
20		// la barriera viene spenta alla distruzione
21		~Barriera();
22
23		//  costanti e getter
24		static constexpr int tolleranza { 100 }; // fra lettura  luce naturale e lettura a barriera accesa con ostacolo
25		int pin_laser_a()  const;
26		int pin_laser_b() const;
27		int pin_foto_a() const;
28		int  pin_foto_b() const;
29		bool stato() const; // true = accesa, false = spenta
30
31		//  false: la barriera era gi nello stato desiderato
32		bool accendi();
33		bool  spegni();
34		bool ostacolo() const; // false se non ci sono ostacoli o a barriera  spenta
35
36	private:
37		int pin_l_a, pin_l_b, pin_f_a, pin_f_b; // primi  e ultimi pin per laser e fotoresistenze
38		bool st; // true = accesa, false  = spenta
39		int luce_naturale { 0 };
40		
41		void imposta_laser(int valore);  // HIGH o LOW
42		int leggi_fotoresistenze() const; // media delle analogRead()
43	};
44	
45}
46
47#endif
48