truck/DashInterface/Display.hpp

// Display (Crystalfontz CFA-635 USB LCD)
//
// Douglas Thrift
//
// $Id$

#ifndef _Display_hpp_
#define _Display_hpp_

#include <threads.hpp>
#include <truck.hpp>

#include <queue>

class Display
{
        int ucom;
        Pthreads::ThreadMutex ucomLock;
        Pthreads::ThreadCondition ucomCondition;
        volatile bool running;
        struct Packet
        {
                enum Command
                {
                        PingCommand                                                             = 0x00,
                        GetHardwareAndFirmwareVersion                   = 0x01,
                        WriteUserFlashArea                                              = 0x02,
                        ReadUserFlashArea                                               = 0x03,
                        StoreCurrentStateAsBootState                    = 0x04,
                        RebootResetHostOrPowerOffHost                   = 0x05,
                        ClearLCDScreen                                                  = 0x06,
                        SetLCDSpecialCharacterData                              = 0x09,
                        Read8ByesOfLCDMemory                                    = 0x0a,
                        SetLCDCursorPosition                                    = 0x0b,
                        SetLCDCursorStyle                                               = 0x0c,
                        SetLCDContrast                                                  = 0x0d,
                        SetLCDAndKeypadBacklight                                = 0x0e,
                        SetUpFanReporting                                               = 0x10,
                        SetFanPower                                                             = 0x11,
                        ReadDOWDeviceInformation                                = 0x12,
                        SetUpTemperatureReporting                               = 0x13,
                        ArbitraryDOWTransaction                                 = 0x14,
                        SendCommandDirectlyToTheLCDController   = 0x16,
                        ConfigureKeyReporting                                   = 0x17,
                        ReadKeypad                                                              = 0x18,
                        SetFanPowerFailSafe                                             = 0x19,
                        SetFanTachometerGlitchFilter                    = 0x1a,
                        QueryFanPowerAndFailSafeMask                    = 0x1b,
                        SetATXPowerSwitchFunctionality                  = 0x1c,
                        EnableDisableAndResetTheWatchdog                = 0x1d,
                        ReadReportingAndStatus                                  = 0x1e,
                        SendDataToLCD                                                   = 0x1f,
                        SetBaudRate                                                             = 0x21,
                        SetOrSetAndConfigureGPIOPin                             = 0x22,
                        ReadGPIOPinLevelsAndConfigurationState  = 0x23,
                        Response                                                                = 0x40,
                        Report                                                                  = 0x80,
                        KeyActivity                                                             = 0x80,
                        FanSpeedReport                                                  = 0x81,
                        TemperatureSensorReport                                 = 0x82,
                        Error                                                                   = 0xc0,
                };

                uint8_t command;
                uint8_t length;
                uint8_t data[22];
                uint16_t crc;

                inline Packet() {}
                Packet(Command command, uint8_t length, const uint8_t *data);

                inline std::string GetData() const { return std::string(reinterpret_cast<const char *>(data), length); }
        };
        std::queue<Packet> responses;
        Pthreads::ThreadMutex responsesLock;
        Pthreads::ThreadCondition responsesCondition;
        std::queue<Packet> keyActivity;
        Pthreads::ThreadMutex keyActivityLock;
        Pthreads::Thread thread;

        inline Packet Communicate(Packet::Command command) { return Communicate_(command, 0, reinterpret_cast<const uint8_t *>(NULL)); }
        template <typename Arg0>
        Packet Communicate(Packet::Command command, Arg0 arg0);
        template <typename Arg0, typename Arg1>
        Packet Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1);
        template <typename Arg0, typename Arg1, typename Arg2>
        Packet Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1, Arg2 arg2);
        void Communicate_();
        Packet Communicate_(Packet::Command command, uint8_t length, const uint8_t *data);

public:
        enum CursorStyle
        {
                NoCursor                                        = 0,
                BlinkingBlockCursor                     = 1,
                UnderscoreCursor                        = 2,
                BlinkingBlockPlusUnderscore     = 3,
                InvertingBlinkingBlock          = 4,
        };
        enum Key
        {
                Up              = 0x01,
                Enter   = 0x02,
                Cancel  = 0x04,
                Left    = 0x08,
                Right   = 0x10,
                Down    = 0x20,
        };
        enum Color
        {
                Green   = 1,
                Red             = 0,
        };
        enum KeyActivity
        {
                None                    = 0,
                UpPress                 = 1,
                DownPress               = 2,
                LeftPress               = 3,
                RightPress              = 4,
                EnterPress              = 5,
                ExitPress               = 6,
                UpRelease               = 7,
                DownRelease             = 8,
                LeftRelease             = 9,
                RightRelease    = 10,
                EnterRelease    = 11,
                ExitRelease             = 12,
        };

        Display(const std::string &device);
        ~Display();

        bool Ping(const std::string &data = std::string());
        std::string Version();
        inline void Store() { Communicate(Packet::StoreCurrentStateAsBootState); }
        inline void Clear() { Communicate(Packet::ClearLCDScreen); }
        inline void SetCursorPosition(uint8_t column, uint8_t row) { Communicate(Packet::SetLCDCursorPosition, column, row); }
        inline void SetCursorStyle(CursorStyle style) { Communicate(Packet::SetLCDCursorStyle, style); }
        inline void SetContrast(uint8_t contrast) { Communicate(Packet::SetLCDContrast, contrast); }
        inline void SetBacklight(uint8_t backlight) { Communicate(Packet::SetLCDAndKeypadBacklight, backlight); }
        inline void KeyReporting(uint8_t press, uint8_t release) { Communicate(Packet::ConfigureKeyReporting, press, release); }
        void Set(uint8_t column, uint8_t row, const std::string &data);
        void Set(uint8_t led, Color color, uint8_t brightness) { Communicate(Packet::SetOrSetAndConfigureGPIOPin, 12 - (led << 1) - color, brightness); }
        KeyActivity GetKeyActivity();

        friend std::ostream &operator<<(std::ostream &output, const Packet &packet);
        friend void operator<<(int fd, const Display::Packet &packet);
        friend void operator>>(int fd, Display::Packet &packet);
        friend void Communicate(Display *display);
};

template <typename Arg0>
inline Display::Packet Display::Communicate(Packet::Command command, Arg0 arg0)
{
        uint8_t data(arg0);

        return Communicate_(command, 1, &data);
}

template <>
inline Display::Packet Display::Communicate(Packet::Command command, const std::string &string)
{
        return Communicate_(command, string.size(), reinterpret_cast<const uint8_t *>(string.data()));
}

template <typename Arg0, typename Arg1>
inline Display::Packet Display::Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1)
{
        uint8_t data[] = { arg0, arg1 };

        return Communicate_(command, 2, data);
}

template <typename Arg0, typename Arg1, typename Arg2>
inline Display::Packet Display::Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1, Arg2 arg2)
{
        uint8_t data[] = { arg0, arg1, arg2 };

        return Communicate_(command, 2, data);
}

template <>
inline Display::Packet Display::Communicate(Packet::Command command, uint8_t arg0, uint8_t arg1, std::string string)
{
        string.insert(0, 1, arg0);
        string.insert(1, 1, arg1);

        return Communicate<const std::string &>(command, string);
}

#endif//_Display_hpp_
Revision:	33
Committed:	2008-02-29T19:05:18-08:00 (17 years, 3 months ago) by douglas
File size:	5761 byte(s)
Log Message:	This is starting to work, but there seems to be some strange with mutexes every once in a while, grr!
#	Content
1	// Display (Crystalfontz CFA-635 USB LCD)
2	//
3	// Douglas Thrift
4	//
5	// $Id$
6
7	#ifndef _Display_hpp_
8	#define _Display_hpp_
9
10	#include <threads.hpp>
11	#include <truck.hpp>
12
13	#include <queue>
14
15	class Display
16	{
17	int ucom;
18	Pthreads::ThreadMutex ucomLock;
19	Pthreads::ThreadCondition ucomCondition;
20	volatile bool running;
21	struct Packet
22	{
23	enum Command
24	{
25	PingCommand = 0x00,
26	GetHardwareAndFirmwareVersion = 0x01,
27	WriteUserFlashArea = 0x02,
28	ReadUserFlashArea = 0x03,
29	StoreCurrentStateAsBootState = 0x04,
30	RebootResetHostOrPowerOffHost = 0x05,
31	ClearLCDScreen = 0x06,
32	SetLCDSpecialCharacterData = 0x09,
33	Read8ByesOfLCDMemory = 0x0a,
34	SetLCDCursorPosition = 0x0b,
35	SetLCDCursorStyle = 0x0c,
36	SetLCDContrast = 0x0d,
37	SetLCDAndKeypadBacklight = 0x0e,
38	SetUpFanReporting = 0x10,
39	SetFanPower = 0x11,
40	ReadDOWDeviceInformation = 0x12,
41	SetUpTemperatureReporting = 0x13,
42	ArbitraryDOWTransaction = 0x14,
43	SendCommandDirectlyToTheLCDController = 0x16,
44	ConfigureKeyReporting = 0x17,
45	ReadKeypad = 0x18,
46	SetFanPowerFailSafe = 0x19,
47	SetFanTachometerGlitchFilter = 0x1a,
48	QueryFanPowerAndFailSafeMask = 0x1b,
49	SetATXPowerSwitchFunctionality = 0x1c,
50	EnableDisableAndResetTheWatchdog = 0x1d,
51	ReadReportingAndStatus = 0x1e,
52	SendDataToLCD = 0x1f,
53	SetBaudRate = 0x21,
54	SetOrSetAndConfigureGPIOPin = 0x22,
55	ReadGPIOPinLevelsAndConfigurationState = 0x23,
56	Response = 0x40,
57	Report = 0x80,
58	KeyActivity = 0x80,
59	FanSpeedReport = 0x81,
60	TemperatureSensorReport = 0x82,
61	Error = 0xc0,
62	};
63
64	uint8_t command;
65	uint8_t length;
66	uint8_t data[22];
67	uint16_t crc;
68
69	inline Packet() {}
70	Packet(Command command, uint8_t length, const uint8_t *data);
71
72	inline std::string GetData() const { return std::string(reinterpret_cast<const char *>(data), length); }
73	};
74	std::queue<Packet> responses;
75	Pthreads::ThreadMutex responsesLock;
76	Pthreads::ThreadCondition responsesCondition;
77	std::queue<Packet> keyActivity;
78	Pthreads::ThreadMutex keyActivityLock;
79	Pthreads::Thread thread;
80
81	inline Packet Communicate(Packet::Command command) { return Communicate_(command, 0, reinterpret_cast<const uint8_t *>(NULL)); }
82	template <typename Arg0>
83	Packet Communicate(Packet::Command command, Arg0 arg0);
84	template <typename Arg0, typename Arg1>
85	Packet Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1);
86	template <typename Arg0, typename Arg1, typename Arg2>
87	Packet Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1, Arg2 arg2);
88	void Communicate_();
89	Packet Communicate_(Packet::Command command, uint8_t length, const uint8_t *data);
90
91	public:
92	enum CursorStyle
93	{
94	NoCursor = 0,
95	BlinkingBlockCursor = 1,
96	UnderscoreCursor = 2,
97	BlinkingBlockPlusUnderscore = 3,
98	InvertingBlinkingBlock = 4,
99	};
100	enum Key
101	{
102	Up = 0x01,
103	Enter = 0x02,
104	Cancel = 0x04,
105	Left = 0x08,
106	Right = 0x10,
107	Down = 0x20,
108	};
109	enum Color
110	{
111	Green = 1,
112	Red = 0,
113	};
114	enum KeyActivity
115	{
116	None = 0,
117	UpPress = 1,
118	DownPress = 2,
119	LeftPress = 3,
120	RightPress = 4,
121	EnterPress = 5,
122	ExitPress = 6,
123	UpRelease = 7,
124	DownRelease = 8,
125	LeftRelease = 9,
126	RightRelease = 10,
127	EnterRelease = 11,
128	ExitRelease = 12,
129	};
130
131	Display(const std::string &device);
132	~Display();
133
134	bool Ping(const std::string &data = std::string());
135	std::string Version();
136	inline void Store() { Communicate(Packet::StoreCurrentStateAsBootState); }
137	inline void Clear() { Communicate(Packet::ClearLCDScreen); }
138	inline void SetCursorPosition(uint8_t column, uint8_t row) { Communicate(Packet::SetLCDCursorPosition, column, row); }
139	inline void SetCursorStyle(CursorStyle style) { Communicate(Packet::SetLCDCursorStyle, style); }
140	inline void SetContrast(uint8_t contrast) { Communicate(Packet::SetLCDContrast, contrast); }
141	inline void SetBacklight(uint8_t backlight) { Communicate(Packet::SetLCDAndKeypadBacklight, backlight); }
142	inline void KeyReporting(uint8_t press, uint8_t release) { Communicate(Packet::ConfigureKeyReporting, press, release); }
143	void Set(uint8_t column, uint8_t row, const std::string &data);
144	void Set(uint8_t led, Color color, uint8_t brightness) { Communicate(Packet::SetOrSetAndConfigureGPIOPin, 12 - (led << 1) - color, brightness); }
145	KeyActivity GetKeyActivity();
146
147	friend std::ostream &operator<<(std::ostream &output, const Packet &packet);
148	friend void operator<<(int fd, const Display::Packet &packet);
149	friend void operator>>(int fd, Display::Packet &packet);
150	friend void Communicate(Display *display);
151	};
152
153	template <typename Arg0>
154	inline Display::Packet Display::Communicate(Packet::Command command, Arg0 arg0)
155	{
156	uint8_t data(arg0);
157
158	return Communicate_(command, 1, &data);
159	}
160
161	template <>
162	inline Display::Packet Display::Communicate(Packet::Command command, const std::string &string)
163	{
164	return Communicate_(command, string.size(), reinterpret_cast<const uint8_t *>(string.data()));
165	}
166
167	template <typename Arg0, typename Arg1>
168	inline Display::Packet Display::Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1)
169	{
170	uint8_t data[] = { arg0, arg1 };
171
172	return Communicate_(command, 2, data);
173	}
174
175	template <typename Arg0, typename Arg1, typename Arg2>
176	inline Display::Packet Display::Communicate(Packet::Command command, Arg0 arg0, Arg1 arg1, Arg2 arg2)
177	{
178	uint8_t data[] = { arg0, arg1, arg2 };
179
180	return Communicate_(command, 2, data);
181	}
182
183	template <>
184	inline Display::Packet Display::Communicate(Packet::Command command, uint8_t arg0, uint8_t arg1, std::string string)
185	{
186	string.insert(0, 1, arg0);
187	string.insert(1, 1, arg1);
188
189	return Communicate<const std::string &>(command, string);
190	}
191
192	#endif//_Display_hpp_