truck/DashInterface/Display.cpp

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

#include <foreach.hpp>
#include <scopes.hpp>
#include <timing.hpp>

#include <cassert>
#include <iomanip>
#include <iostream>

#include <fcntl.h>
#include <termios.h>

#include "Display.hpp"

extern bool debug;

static uint16_t GetCRC(uint8_t *buffer, size_t length)
{
        static const uint16_t table[256] = {
                0x00000, 0x01189, 0x02312, 0x0329b, 0x04624, 0x057ad, 0x06536, 0x074bf,
                0x08C48, 0x09DC1, 0x0AF5A, 0x0BED3, 0x0CA6C, 0x0DBE5, 0x0E97E, 0x0F8F7,
                0x01081, 0x00108, 0x03393, 0x0221a, 0x056a5, 0x0472c, 0x075b7, 0x0643e,
                0x09CC9, 0x08D40, 0x0BFDB, 0x0AE52, 0x0DAED, 0x0CB64, 0x0F9FF, 0x0E876,
                0x02102, 0x0308b, 0x00210, 0x01399, 0x06726, 0x076af, 0x04434, 0x055bd,
                0x0AD4A, 0x0BCC3, 0x08E58, 0x09FD1, 0x0EB6E, 0x0FAE7, 0x0C87C, 0x0D9F5,
                0x03183, 0x0200a, 0x01291, 0x00318, 0x077a7, 0x0662e, 0x054b5, 0x0453c,
                0x0BDCB, 0x0AC42, 0x09ED9, 0x08F50, 0x0FBEF, 0x0EA66, 0x0D8FD, 0x0C974,
                0x04204, 0x0538d, 0x06116, 0x0709f, 0x00420, 0x015a9, 0x02732, 0x036bb,
                0x0ce4c, 0x0dfc5, 0x0ed5e, 0x0fcd7, 0x08868, 0x099e1, 0x0ab7a, 0x0baf3,
                0x05285, 0x0430c, 0x07197, 0x0601e, 0x014a1, 0x00528, 0x037b3, 0x0263a,
                0x0decd, 0x0cf44, 0x0fddf, 0x0ec56, 0x098e9, 0x08960, 0x0bbfb, 0x0aa72,
                0x06306, 0x0728f, 0x04014, 0x0519d, 0x02522, 0x034ab, 0x00630, 0x017b9,
                0x0EF4E, 0x0FEC7, 0x0CC5C, 0x0DDD5, 0x0A96A, 0x0B8E3, 0x08A78, 0x09BF1,
                0x07387, 0x0620e, 0x05095, 0x0411c, 0x035a3, 0x0242a, 0x016b1, 0x00738,
                0x0FFCF, 0x0EE46, 0x0DCDD, 0x0CD54, 0x0B9EB, 0x0A862, 0x09AF9, 0x08B70,
                0x08408, 0x09581, 0x0a71a, 0x0b693, 0x0c22c, 0x0d3a5, 0x0e13e, 0x0f0b7,
                0x00840, 0x019c9, 0x02b52, 0x03adb, 0x04e64, 0x05fed, 0x06d76, 0x07cff,
                0x09489, 0x08500, 0x0b79b, 0x0a612, 0x0d2ad, 0x0c324, 0x0f1bf, 0x0e036,
                0x018c1, 0x00948, 0x03bd3, 0x02a5a, 0x05ee5, 0x04f6c, 0x07df7, 0x06c7e,
                0x0a50a, 0x0b483, 0x08618, 0x09791, 0x0e32e, 0x0f2a7, 0x0c03c, 0x0d1b5,
                0x02942, 0x038cb, 0x00a50, 0x01bd9, 0x06f66, 0x07eef, 0x04c74, 0x05dfd,
                0x0b58b, 0x0a402, 0x09699, 0x08710, 0x0f3af, 0x0e226, 0x0d0bd, 0x0c134,
                0x039C3, 0x0284A, 0x01AD1, 0x00B58, 0x07FE7, 0x06E6E, 0x05CF5, 0x04D7C,
                0x0c60c, 0x0d785, 0x0e51e, 0x0f497, 0x08028, 0x091a1, 0x0a33a, 0x0b2b3,
                0x04a44, 0x05bcd, 0x06956, 0x078df, 0x00c60, 0x01de9, 0x02f72, 0x03efb,
                0x0d68d, 0x0c704, 0x0f59f, 0x0e416, 0x090a9, 0x08120, 0x0b3bb, 0x0a232,
                0x05AC5, 0x04B4C, 0x079D7, 0x0685E, 0x01CE1, 0x00D68, 0x03FF3, 0x02E7A,
                0x0e70e, 0x0f687, 0x0c41c, 0x0d595, 0x0a12a, 0x0b0a3, 0x08238, 0x093b1,
                0x06b46, 0x07acf, 0x04854, 0x059dd, 0x02d62, 0x03ceb, 0x00e70, 0x01ff9,
                0x0f78f, 0x0e606, 0x0d49d, 0x0c514, 0x0b1ab, 0x0a022, 0x092b9, 0x08330,
                0x07BC7, 0x06A4E, 0x058D5, 0x0495C, 0x03DE3, 0x02C6A, 0x01EF1, 0x00F78,
        };
        register uint16_t crc(0xffff);

        while (length--)
                crc = (crc >> 8) ^ table[(crc ^ *buffer++) & 0xff];

        return ~crc;
}

Display::Packet::Packet(Display::Packet::Command command, uint8_t length, const uint8_t *data) : command(command), length(length)
{
        if (length > sizeof (this->data))
                throw;

        ::memcpy(this->data, data, length);

        crc = GetCRC(reinterpret_cast<uint8_t *>(this), length + 2);
}

std::ostream &operator<<(std::ostream &output, const Display::Packet &packet)
{
        return output << _B("0x") << std::hex << std::setw(2) << std::setfill('0') << unsigned(packet.command) << _B(" [") << packet.GetData() << ']';
}

void operator<<(int fd, const Display::Packet &packet)
{
        if (packet.length != sizeof (packet.data))
                ::memcpy(const_cast<uint8_t *>(packet.data) + packet.length, &packet.crc, 2);

        if (debug)
                std::cerr << _B("<< ") << packet << std::endl;

        Posix::Write(fd, &packet, packet.length + 4);
}

void operator>>(int fd, Display::Packet &packet)
{
        Posix::Read(fd, &packet, 2);
        Posix::Read(fd, packet.data, packet.length);
        Posix::Read(fd, &packet.crc, 2);

        if (debug)
                std::cerr << _B(">> ") << packet << std::endl;
}

void Communicate(Display *display)
{
        display->Communicate_();
}

void Activity(Display *display)
{
        display->Activity();
}

Display::Display(const std::string &device, Callback callback, void *data) : ucom(Posix::Open(device, O_RDWR | O_NOCTTY | O_NONBLOCK)), ucomCondition(ucomLock), running(true), responsesCondition(responsesLock), keyActivityCondition(keyActivityLock), callback(callback), data(data), communicate(reinterpret_cast<void *(*)(void *)>(::Communicate), this), activity(reinterpret_cast<void *(*)(void *)>(::Activity), this)
{
        ::termios state;

        Posix::CheckError(::tcgetattr(ucom, &state));
        Posix::CheckError(::cfsetospeed(&state, B115200));
        Posix::CheckError(::cfsetispeed(&state, B115200));

        state.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | INPCK | ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXOFF);
        state.c_iflag |= IGNPAR;
        state.c_oflag &= ~(OPOST | ONLCR | ONOCR | ONLRET);
        state.c_cflag &= ~(CSIZE | PARENB | PARODD | HUPCL | CRTSCTS);
        state.c_cflag |= CREAD | CS8 | CSTOPB | CLOCAL;
        state.c_lflag &= ~(ISIG | ICANON | IEXTEN | ECHO);
        state.c_lflag |= NOFLSH;

        Posix::CheckError(::tcsetattr(ucom, TCSANOW, &state));

        _synchronized (ucomLock)
                ucomCondition.Signal();
}

Display::~Display()
{
        running = false;

        communicate.Join();
        activity.Join();

        Posix::Close(ucom);
}

void Display::Communicate_()
{
        _synchronized (ucomLock)
                ucomCondition.Wait();

        while (running)
        {
                Packet response;

                _synchronized (ucomLock)
                        try
                        {
                                ucom >> response;
                        }
                        catch (const Posix::Error error)
                        {
                                if (error.what() != _B("Resource temporarily unavailable"))
                                        throw error;

                                goto next;
                        }

                if ((response.command & Packet::Error) == Packet::Error);
                else if ((response.command & Packet::Report) == Packet::Report)
                        switch (response.command)
                        {
                        case Packet::KeyActivity:
                                _synchronized (keyActivityLock)
                                {
                                        keyActivity.push(response);
                                        keyActivityCondition.Signal();
                                }

                                break;
                        case Packet::FanSpeedReport:
                        case Packet::TemperatureSensorReport:
                                break;
                        }
                else if ((response.command & Packet::Response) == Packet::Response)
                        _synchronized (responsesLock)
                        {
                                responses.push(response);
                                responsesCondition.Signal();
                        }

next:   Timing::NanoSleep(Timing::Time(0, 10000000));
        }

        keyActivityCondition.Signal();
}

Display::Packet Display::Communicate_(Display::Packet::Command command, uint8_t length, const uint8_t *data)
{
        Packet packet(command, length, data);

retry:
        _synchronized (ucomLock)
                ucom << packet;

        _synchronized (responsesLock)
        {
                while (responses.empty())
                        try
                        {
                                responsesCondition.Wait(Timing::GetTimeOfDay() += Timing::Time(0, 1));
                        }
                        catch (const Posix::Error &error)
                        {
                                if (error.what() != _B("Operation timed out"))
                                        throw error;

                                goto retry;
                        }

                Packet response(responses.front());

                responses.pop();

                assert ((packet.command | Packet::Response) == response.command);

                return response;
        }

        throw;
}

void Display::Activity()
{
        if (callback == NULL)
                return;

        while (running)
                _synchronized (keyActivityLock)
                {
                        while (keyActivity.empty())
                                keyActivityCondition.Wait();

                        while (keyActivity.size())
                        {
                                KeyActivity activity(KeyActivity(*keyActivity.front().data));

                                keyActivity.pop();

                                _desynchronized (keyActivityLock)
                                        callback(activity, data);
                        }
                }
}

bool Display::Ping(const std::string &data)
{
        return data == Communicate<const std::string &>(Packet::PingCommand, data).GetData();
}

std::string Display::Version()
{
        return Communicate(Packet::GetHardwareAndFirmwareVersion).GetData();
}

void Display::Set(uint8_t column, uint8_t row, const std::string &data)
{
        Communicate(Packet::SendDataToLCD, column, row, data);
}
Revision:	53
Committed:	2008-07-12T17:00:15-07:00 (16 years, 11 months ago) by douglas
File size:	7633 byte(s)
Log Message:	64bit cleanify.
#	Content
1	// Display (Crystalfontz CFA-635 USB LCD)
2	//
3	// Douglas Thrift
4	//
5	// $Id$
6
7	#include <foreach.hpp>
8	#include <scopes.hpp>
9	#include <timing.hpp>
10
11	#include <cassert>
12	#include <iomanip>
13	#include <iostream>
14
15	#include <fcntl.h>
16	#include <termios.h>
17
18	#include "Display.hpp"
19
20	extern bool debug;
21
22	static uint16_t GetCRC(uint8_t *buffer, size_t length)
23	{
24	static const uint16_t table[256] = {
25	0x00000, 0x01189, 0x02312, 0x0329b, 0x04624, 0x057ad, 0x06536, 0x074bf,
26	0x08C48, 0x09DC1, 0x0AF5A, 0x0BED3, 0x0CA6C, 0x0DBE5, 0x0E97E, 0x0F8F7,
27	0x01081, 0x00108, 0x03393, 0x0221a, 0x056a5, 0x0472c, 0x075b7, 0x0643e,
28	0x09CC9, 0x08D40, 0x0BFDB, 0x0AE52, 0x0DAED, 0x0CB64, 0x0F9FF, 0x0E876,
29	0x02102, 0x0308b, 0x00210, 0x01399, 0x06726, 0x076af, 0x04434, 0x055bd,
30	0x0AD4A, 0x0BCC3, 0x08E58, 0x09FD1, 0x0EB6E, 0x0FAE7, 0x0C87C, 0x0D9F5,
31	0x03183, 0x0200a, 0x01291, 0x00318, 0x077a7, 0x0662e, 0x054b5, 0x0453c,
32	0x0BDCB, 0x0AC42, 0x09ED9, 0x08F50, 0x0FBEF, 0x0EA66, 0x0D8FD, 0x0C974,
33	0x04204, 0x0538d, 0x06116, 0x0709f, 0x00420, 0x015a9, 0x02732, 0x036bb,
34	0x0ce4c, 0x0dfc5, 0x0ed5e, 0x0fcd7, 0x08868, 0x099e1, 0x0ab7a, 0x0baf3,
35	0x05285, 0x0430c, 0x07197, 0x0601e, 0x014a1, 0x00528, 0x037b3, 0x0263a,
36	0x0decd, 0x0cf44, 0x0fddf, 0x0ec56, 0x098e9, 0x08960, 0x0bbfb, 0x0aa72,
37	0x06306, 0x0728f, 0x04014, 0x0519d, 0x02522, 0x034ab, 0x00630, 0x017b9,
38	0x0EF4E, 0x0FEC7, 0x0CC5C, 0x0DDD5, 0x0A96A, 0x0B8E3, 0x08A78, 0x09BF1,
39	0x07387, 0x0620e, 0x05095, 0x0411c, 0x035a3, 0x0242a, 0x016b1, 0x00738,
40	0x0FFCF, 0x0EE46, 0x0DCDD, 0x0CD54, 0x0B9EB, 0x0A862, 0x09AF9, 0x08B70,
41	0x08408, 0x09581, 0x0a71a, 0x0b693, 0x0c22c, 0x0d3a5, 0x0e13e, 0x0f0b7,
42	0x00840, 0x019c9, 0x02b52, 0x03adb, 0x04e64, 0x05fed, 0x06d76, 0x07cff,
43	0x09489, 0x08500, 0x0b79b, 0x0a612, 0x0d2ad, 0x0c324, 0x0f1bf, 0x0e036,
44	0x018c1, 0x00948, 0x03bd3, 0x02a5a, 0x05ee5, 0x04f6c, 0x07df7, 0x06c7e,
45	0x0a50a, 0x0b483, 0x08618, 0x09791, 0x0e32e, 0x0f2a7, 0x0c03c, 0x0d1b5,
46	0x02942, 0x038cb, 0x00a50, 0x01bd9, 0x06f66, 0x07eef, 0x04c74, 0x05dfd,
47	0x0b58b, 0x0a402, 0x09699, 0x08710, 0x0f3af, 0x0e226, 0x0d0bd, 0x0c134,
48	0x039C3, 0x0284A, 0x01AD1, 0x00B58, 0x07FE7, 0x06E6E, 0x05CF5, 0x04D7C,
49	0x0c60c, 0x0d785, 0x0e51e, 0x0f497, 0x08028, 0x091a1, 0x0a33a, 0x0b2b3,
50	0x04a44, 0x05bcd, 0x06956, 0x078df, 0x00c60, 0x01de9, 0x02f72, 0x03efb,
51	0x0d68d, 0x0c704, 0x0f59f, 0x0e416, 0x090a9, 0x08120, 0x0b3bb, 0x0a232,
52	0x05AC5, 0x04B4C, 0x079D7, 0x0685E, 0x01CE1, 0x00D68, 0x03FF3, 0x02E7A,
53	0x0e70e, 0x0f687, 0x0c41c, 0x0d595, 0x0a12a, 0x0b0a3, 0x08238, 0x093b1,
54	0x06b46, 0x07acf, 0x04854, 0x059dd, 0x02d62, 0x03ceb, 0x00e70, 0x01ff9,
55	0x0f78f, 0x0e606, 0x0d49d, 0x0c514, 0x0b1ab, 0x0a022, 0x092b9, 0x08330,
56	0x07BC7, 0x06A4E, 0x058D5, 0x0495C, 0x03DE3, 0x02C6A, 0x01EF1, 0x00F78,
57	};
58	register uint16_t crc(0xffff);
59
60	while (length--)
61	crc = (crc >> 8) ^ table[(crc ^ *buffer++) & 0xff];
62
63	return ~crc;
64	}
65
66	Display::Packet::Packet(Display::Packet::Command command, uint8_t length, const uint8_t *data) : command(command), length(length)
67	{
68	if (length > sizeof (this->data))
69	throw;
70
71	::memcpy(this->data, data, length);
72
73	crc = GetCRC(reinterpret_cast<uint8_t *>(this), length + 2);
74	}
75
76	std::ostream &operator<<(std::ostream &output, const Display::Packet &packet)
77	{
78	return output << _B("0x") << std::hex << std::setw(2) << std::setfill('0') << unsigned(packet.command) << _B(" [") << packet.GetData() << ']';
79	}
80
81	void operator<<(int fd, const Display::Packet &packet)
82	{
83	if (packet.length != sizeof (packet.data))
84	::memcpy(const_cast<uint8_t *>(packet.data) + packet.length, &packet.crc, 2);
85
86	if (debug)
87	std::cerr << _B("<< ") << packet << std::endl;
88
89	Posix::Write(fd, &packet, packet.length + 4);
90	}
91
92	void operator>>(int fd, Display::Packet &packet)
93	{
94	Posix::Read(fd, &packet, 2);
95	Posix::Read(fd, packet.data, packet.length);
96	Posix::Read(fd, &packet.crc, 2);
97
98	if (debug)
99	std::cerr << _B(">> ") << packet << std::endl;
100	}
101
102	void Communicate(Display *display)
103	{
104	display->Communicate_();
105	}
106
107	void Activity(Display *display)
108	{
109	display->Activity();
110	}
111
112	Display::Display(const std::string &device, Callback callback, void data) : ucom(Posix::Open(device, O_RDWR \| O_NOCTTY \| O_NONBLOCK)), ucomCondition(ucomLock), running(true), responsesCondition(responsesLock), keyActivityCondition(keyActivityLock), callback(callback), data(data), communicate(reinterpret_cast<void ()(void )>(::Communicate), this), activity(reinterpret_cast<void ()(void *)>(::Activity), this)
113	{
114	::termios state;
115
116	Posix::CheckError(::tcgetattr(ucom, &state));
117	Posix::CheckError(::cfsetospeed(&state, B115200));
118	Posix::CheckError(::cfsetispeed(&state, B115200));
119
120	state.c_iflag &= ~(IGNBRK \| BRKINT \| PARMRK \| INPCK \| ISTRIP \| INLCR \| IGNCR \| ICRNL \| IXON \| IXOFF);
121	state.c_iflag \|= IGNPAR;
122	state.c_oflag &= ~(OPOST \| ONLCR \| ONOCR \| ONLRET);
123	state.c_cflag &= ~(CSIZE \| PARENB \| PARODD \| HUPCL \| CRTSCTS);
124	state.c_cflag \|= CREAD \| CS8 \| CSTOPB \| CLOCAL;
125	state.c_lflag &= ~(ISIG \| ICANON \| IEXTEN \| ECHO);
126	state.c_lflag \|= NOFLSH;
127
128	Posix::CheckError(::tcsetattr(ucom, TCSANOW, &state));
129
130	_synchronized (ucomLock)
131	ucomCondition.Signal();
132	}
133
134	Display::~Display()
135	{
136	running = false;
137
138	communicate.Join();
139	activity.Join();
140
141	Posix::Close(ucom);
142	}
143
144	void Display::Communicate_()
145	{
146	_synchronized (ucomLock)
147	ucomCondition.Wait();
148
149	while (running)
150	{
151	Packet response;
152
153	_synchronized (ucomLock)
154	try
155	{
156	ucom >> response;
157	}
158	catch (const Posix::Error error)
159	{
160	if (error.what() != _B("Resource temporarily unavailable"))
161	throw error;
162
163	goto next;
164	}
165
166	if ((response.command & Packet::Error) == Packet::Error);
167	else if ((response.command & Packet::Report) == Packet::Report)
168	switch (response.command)
169	{
170	case Packet::KeyActivity:
171	_synchronized (keyActivityLock)
172	{
173	keyActivity.push(response);
174	keyActivityCondition.Signal();
175	}
176
177	break;
178	case Packet::FanSpeedReport:
179	case Packet::TemperatureSensorReport:
180	break;
181	}
182	else if ((response.command & Packet::Response) == Packet::Response)
183	_synchronized (responsesLock)
184	{
185	responses.push(response);
186	responsesCondition.Signal();
187	}
188
189	next: Timing::NanoSleep(Timing::Time(0, 10000000));
190	}
191
192	keyActivityCondition.Signal();
193	}
194
195	Display::Packet Display::Communicate_(Display::Packet::Command command, uint8_t length, const uint8_t *data)
196	{
197	Packet packet(command, length, data);
198
199	retry:
200	_synchronized (ucomLock)
201	ucom << packet;
202
203	_synchronized (responsesLock)
204	{
205	while (responses.empty())
206	try
207	{
208	responsesCondition.Wait(Timing::GetTimeOfDay() += Timing::Time(0, 1));
209	}
210	catch (const Posix::Error &error)
211	{
212	if (error.what() != _B("Operation timed out"))
213	throw error;
214
215	goto retry;
216	}
217
218	Packet response(responses.front());
219
220	responses.pop();
221
222	assert ((packet.command \| Packet::Response) == response.command);
223
224	return response;
225	}
226
227	throw;
228	}
229
230	void Display::Activity()
231	{
232	if (callback == NULL)
233	return;
234
235	while (running)
236	_synchronized (keyActivityLock)
237	{
238	while (keyActivity.empty())
239	keyActivityCondition.Wait();
240
241	while (keyActivity.size())
242	{
243	KeyActivity activity(KeyActivity(*keyActivity.front().data));
244
245	keyActivity.pop();
246
247	_desynchronized (keyActivityLock)
248	callback(activity, data);
249	}
250	}
251	}
252
253	bool Display::Ping(const std::string &data)
254	{
255	return data == Communicate<const std::string &>(Packet::PingCommand, data).GetData();
256	}
257
258	std::string Display::Version()
259	{
260	return Communicate(Packet::GetHardwareAndFirmwareVersion).GetData();
261	}
262
263	void Display::Set(uint8_t column, uint8_t row, const std::string &data)
264	{
265	Communicate(Packet::SendDataToLCD, column, row, data);
266	}