1////////////////////////////////////////////////////////////////////////////////
2// //
3// This software is supplied under the terms of a license agreement or //
4// nondisclosure agreement with Mitov Software and may not be copied //
5// or disclosed except in accordance with the terms of that agreement. //
6// Copyright(c) 2002-2016 Mitov Software. All Rights Reserved. //
7// //
8////////////////////////////////////////////////////////////////////////////////
9#ifndef _MITOV_7SEGMENT_h
11#define _MITOV_7SEGMENT_h
12#include <Mitov.h>
14#include <Mitov_BasicDisplay.h>
15namespace Mitov
17{
18 const byte C_Segments[16] =
19 {
20 0b0111111, // = 0
21 0b0000110, // = 1
22 0b1011011, // = 2
23 0b1001111, // = 3
24 0b1100110, // = 4
25 0b1101101, // = 5
26 0b1111101, // = 6
27 0b0000111, // = 7
28 0b1111111, // = 8
29 0b1101111, // = 9
30 0b1110111, // = A
31 0b1111100, // = B
32 0b1011000, // = C
33 0b1011110, // = D
34 0b1111001, // = E
35 0b1110001 // = F
36 };
37//---------------------------------------------------------------------------
38 template<typename T> class DisplayBasic7Segment : public Mitov::BasicDisplay<T>
39 {
40 typedef Mitov::BasicDisplay<T> inherited;
41 public:
43 Mitov::SimpleList<OpenWire::SourcePin> SegmentPins;
44 public:
46 bool InvertedSegments;
47 public:
49 DisplayBasic7Segment() :
50 InvertedSegments( false )
51 {
52 SegmentPins.SetCount(16);
53 }
54 };
56//---------------------------------------------------------------------------
57 class Display7Segment : public Mitov::DisplayBasic7Segment<long>
58 {
59 typedef Mitov::DisplayBasic7Segment<long> inherited;
60 protected:
62 virtual void DoReceive( void *_Data )
63 {
64 inherited::DoReceive( _Data );
65 UpdateDisplay();
66 }
67 virtual void UpdateDisplay()
69 {
70 int AValue = (Enabled) ? C_Segments[ FValue & 0xF ] : 0;
71 for( int i = 0; i < 16; ++i )
72 {
73 bool ABitValue = AValue & 1;
74 ABitValue ^= InvertedSegments;
75 SegmentPins[ i ].Notify( &ABitValue );
76 AValue >>= 1;
77 }
78 }
79 };
81//---------------------------------------------------------------------------
82 template<typename T> class DisplayBasicDynamic7Segment : public Mitov::DisplayBasic7Segment<T>
83 {
84 typedef Mitov::DisplayBasic7Segment<T> inherited;
85 public:
87 Mitov::SimpleList<OpenWire::SourcePin> DigitPins;
88 public:
90 unsigned long RefreshInterval = 1000;
91 bool InvertedDigits = false;
92 protected:
94 unsigned long FLastTime = 0;
95 int FDigit = 0;
96 protected:
98 virtual int GetSegmentsValue() = 0;
99 virtual void UpdateDisplay()
101 {
102 int AValue;
103 if( inherited::Enabled )
104 AValue = GetSegmentsValue();
105 else
107 AValue = 0;
108 for( int i = 0; i < DigitPins.size(); ++i )
110 {
111 bool ABitValue = false;
112 ABitValue ^= InvertedDigits;
113 DigitPins[ i ].Notify( &ABitValue );
114 }
115 for( int i = 0; i < 16; ++i )
117 {
118 bool ABitValue = AValue & 1;
119 ABitValue ^= inherited::InvertedSegments;
120 inherited::SegmentPins[ i ].Notify( &ABitValue );
121 AValue >>= 1;
122 }
123 AValue = FDigit;
125 for( int i = 0; i < DigitPins.size(); ++i )
126 {
127 bool ABitValue = ( AValue-- == 0 );
128 ABitValue ^= InvertedDigits;
129 DigitPins[ i ].Notify( &ABitValue );
130 }
131 }
132 public:
134 virtual void SystemLoopBegin( unsigned long currentMicros )
135 {
136 if( ( currentMicros - FLastTime ) < RefreshInterval )
137 return;
138 ++FDigit;
140 if( FDigit >= DigitPins.size() )
142 FDigit = 0;
143 FLastTime = currentMicros;
145 UpdateDisplay();
146 }
147 };
149//---------------------------------------------------------------------------
150 class DisplayIntegerDynamic7Segment : public Mitov::DisplayBasicDynamic7Segment<long>
151 {
152 typedef Mitov::DisplayBasicDynamic7Segment<long> inherited;
153 public:
155 bool LeadingZeroes = false;
156 protected:
158 Mitov::SimpleList<unsigned int> FPowers;
159 long FMaxValue; // The biggest possible to display value
160 long FMinValue; // The smallest possible to display value
161 protected:
163 virtual int GetSegmentsValue()
164 {
165 int AValue;
166 if( FValue > FMaxValue )
167 AValue = 0b0000001;
168 else if( FValue < FMinValue )
170 AValue = 0b0001000;
171 else
173 {
174 AValue = ( (int)abs( FValue ) ) / FPowers[ FDigit ];
175 if( ( FValue < 0 ) && ( FDigit > 0 ))
176 {
177 if( ( !LeadingZeroes ) && ( AValue == 0 ) )
178 {
179 int APreviousValue = ( -FValue ) / FPowers[ FDigit - 1 ];
180 if( APreviousValue > 0 )
181 AValue = 0b1000000;
182 else
184 AValue = 0;
185 }
187 else
188 {
189 if( FDigit == DigitPins.size() - 1 )
190 AValue = 0b1000000;
191 else
193 {
194 int ADigitValue = AValue % 10;
195 AValue = C_Segments[ ADigitValue ];
196 }
197 }
198 }
199 else
200 {
201 if( ( !LeadingZeroes ) && ( AValue == 0 ) )
202 AValue = 0;
203 else
205 {
206 int ADigitValue = AValue % 10;
207 AValue = C_Segments[ ADigitValue ];
208 }
209 }
210 }
211 return AValue;
213 }
214 virtual void SystemInit()
216 {
217 FPowers.SetCount( DigitPins.size() );
218 for( int i = 0; i < DigitPins.size(); ++i )
219 FPowers[ i ] = pow( 10, i ) + 0.5;
220 FMaxValue = pow( 10, DigitPins.size() ) + 0.5 - 1;
222 FMinValue = -( pow( 10, DigitPins.size() - 1 ) + 0.5 - 1 );
223 inherited::SystemInit();
225 }
226 };
228//---------------------------------------------------------------------------
229 class DisplayAnalogDynamic7Segment : public Mitov::DisplayBasicDynamic7Segment<float>
230 {
231 typedef Mitov::DisplayBasicDynamic7Segment<float> inherited;
232 public:
234 unsigned char Precision = 2;
235 protected:
237 char *FBuffer;
238 char *FStartChar;
239 unsigned char FTextLength;
240 unsigned char FFirstPos;
241 char FDecimalPointPos;
243 protected:
245 virtual int GetSegmentsValue()
246 {
247 int AValue;
248 int ANumDigits = DigitPins.size();
249 if( ! FStartChar )
250 {
251 FStartChar = dtostrf( FValue, 1, Precision, FBuffer );
252// Serial.println( FStartChar );
253 String AText( FStartChar );
254 FTextLength = AText.length(); // strlen( FStartChar );
255// FTextLength = strlen( FStartChar );
256// Serial.println( FTextLength );
257 FDecimalPointPos = AText.indexOf( '.' );
258 if( Precision == 0 )
259 {
260 if( FTextLength <= ANumDigits )
261 FFirstPos = FTextLength - 1;
262 else
264 FFirstPos = ANumDigits - 1;
265
267// Serial.println( FStartChar );
268// Serial.println( FTextLength );
269// Serial.println( FFirstPos );
270// Serial.println( FDecimalPointPos );
271 }
272 else
274 {
275 if( FTextLength <= ANumDigits + 1 )
276 FFirstPos = FTextLength - 1;
277 else
279 FFirstPos = ANumDigits + 1 - 1;
280 }
281// Serial.println( FFirstPos );
283 }
284 int ACorrectedTextLength = FTextLength;
286 if( Precision > 0 )
287 --ACorrectedTextLength;
288 if( ( ACorrectedTextLength - Precision ) > ANumDigits )
290 {
291 if( FValue > 0 )
292 AValue = 0b0000001; // Overflow +
293 else
295 AValue = 0b0001000; // Overflow -
296 }
297 else
299 {
300 int ATextPos = FFirstPos - FDigit;
301 if( ATextPos < 0 )
302 AValue = 0;
303 else
305 {
306 if( ATextPos < 0 )
307 return( 0 );
308 bool ADecimalPoint = ( FStartChar[ ATextPos ] == '.' );
310 if( ATextPos <= FDecimalPointPos )
311 --ATextPos;
312// if( ADecimalPoint )
314// --ATextPos;
315 if( ATextPos < 0 )
317 return( 0 );
318/*
320 if( FDigit == 0 )
321 {
322 Serial.println( FStartChar );
323 Serial.println( ATextPos );
324 }
325*/
326 if( FStartChar[ ATextPos ] == '-' )
327 AValue = 0b1000000;
328 else
330 {
331 AValue = FStartChar[ ATextPos ] - '0';
332 AValue = C_Segments[ AValue ];
333 }
334 if( ADecimalPoint )
336 AValue |= 0x80;
337 }
339 }
340 return AValue;
342 }
343 virtual void DoReceive( void *_Data )
345 {
346 FStartChar = NULL;
347 inherited::DoReceive( _Data );
348 }
349 public:
351 virtual void SystemInit()
352 {
353 FBuffer = new char[ 15 + Precision ];
354 inherited::SystemInit();
355 }
356/*
358 virtual ~DisplayAnalogDynamic7Segment()
359 {
360 delete [] FBuffer;
361 }
362*/
363 };
364}
366#endif