truck/DashInterface/DashInterface.cpp

// Dash Interface
//
// Douglas Thrift
//
// $Id$

#include <iomanip>
#include <iostream>
#include <sstream>

#include <foreach.hpp>
#include <hash.hpp>
#include <regex.hpp>

#include <Audacious.hpp>
#include <GPS.hpp>

#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/utsname.h>

#include <sqlite3.h>

#include "Display.hpp"

bool debug(false);

void Uname(Display &display, time_t now = 0, bool change = false)
{
        if (!now || change)
        {
                utsname os;

                ::uname(&os);

                static Pcre::RegEx version(_B("^(\\d+\\.\\d+)-([A-Z])[A-Z]*(-p\\d+)?.*$"));
                Pcre::RegEx::Match match(version(os.release));

                display.Set(0, 1, os.sysname + _B(" ") + match[1] + match[2] + match[3]);
        }

        int mib[] = { CTL_KERN, KERN_BOOTTIME };
        timeval boottime;
        size_t size(sizeof (boottime));

        if (now && ::sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 && boottime.tv_sec != 0)
        {
                time_t uptime(now - boottime.tv_sec);

                if (uptime > 60)
                        uptime += 30;

                char *when;
                int days(uptime / 86400);

                uptime %= 86400;

                int hours(uptime / 3600);

                uptime %= 3600;

                int minutes(uptime / 60), seconds(uptime % 60);

                ::asprintf(&when, "%i+%02i:%02i:%02i", days, hours, minutes, seconds);

                std::string then(when);

                then.append(17 - std::strlen(when), ' ');

                std::free(when);

                if (change)
                        display.Set(0, 2, _B("up ") + then);
                else
                        display.Set(3, 2, then);
        }
        else
                display.Set(0, 2, _B("up -+--:--:--       "));

        double averages[3];

        if (::getloadavg(averages, 3) == -1 || !now)
                display.Set(0, 3, _B("-.--, -.--, -.--    "));
        else
        {
                char *load;

                ::asprintf(&load, "%.2f, %.2f, %.2f", averages[0], averages[1] , averages[2]);

                display.Set(0, 3, load + std::string(20 - std::strlen(load), ' '));

                std::free(load);
        }
}

int main(int argc, char *argv[])
{
        std::string device;

        {
                Pcre::RegEx devicePath(_B("^-device=(/.+)$"));
                Pcre::RegEx deviceNumber(_B("^-device=([0-9]+)$"));
                Pcre::RegEx deviceName(_B("^-device=(.+)$"));

                for (char **arg = argv + 1; *arg; ++arg)
                {
                        Pcre::RegEx::Match match;

                        if (*arg == _B("-debug"))
                                debug = true;
                        else if (match = devicePath(*arg))
                                device = match[1];
                        else if (match = deviceNumber(*arg))
                                device = _B("/dev/cuaU") + match[1];
                        else if (match = deviceName(*arg))
                                device = _B("/dev/") + match[1];
                        else
                                goto usage;
                }
        }

        if (device.empty())
        {
usage:  std::cout << _B("Usage: ") << argv[0] << _B(" [-debug] [-device=device]") << std::endl;

                return 2;
        }

        try
        {
                Display display(device);

                display.Clear();
                display.SetBacklight(100);
                display.Set(2, 0, _B("--:--:-- -- ---"));

                enum { Running };

                display.Set(Running, Display::Green, 0);
                display.Set(Running, Display::Red, 100);

                {
                        uint8_t mask(Display::Up | Display::Enter | Display::Cancel | Display::Left | Display::Right | Display::Down);

                        display.KeyReporting(mask, mask);
                }

                ::Uname(display);

                display.Store();
                display.Set(Running, Display::Green, 100);
                display.Set(Running, Display::Red, 0);

                enum Mode { Uname, Music, English, Metric, Nautical, Last } mode(Uname);
                //Audacious::Audacious audacious;
                //GPS::GPS gps;

                _forever
                {
                        time_t now(std::time(NULL));

                        {
                                char when[16];

                                std::strftime(when, sizeof (when), "%l:%M:%S %p %Z", std::localtime(&now));

                                display.Set(2, 0, when);
                        }

                        switch (mode)
                        {
                        default:
                                ::Uname(display, now);

                                break;
                        case Music:
                        case English:
                        case Metric:
                        case Nautical:
                                break;
                        }

                        ::sleep(1);
                }
        }
        catch (const std::exception &exception)
        {
                std::cerr << argv[0] << _B(": ") << exception.what() << std::endl;

                return 1;
        }

        return 0;
}
Revision:	36
Committed:	2008-03-04T22:24:35-08:00 (17 years, 3 months ago) by douglas
File size:	3635 byte(s)
Log Message:	Huzzah, figured that one out!
#	User	Rev	Content
1	douglas	22	// Dash Interface
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7	douglas	33	#include <iomanip>
8	douglas	25	#include <iostream>
9	douglas	33	#include <sstream>
10	douglas	25
11			#include <foreach.hpp>
12			#include <hash.hpp>
13	douglas	26	#include <regex.hpp>
14	douglas	25
15	douglas	24	#include <Audacious.hpp>
16			#include <GPS.hpp>
17
18	douglas	33	#include <sys/types.h>
19			#include <sys/sysctl.h>
20			#include <sys/utsname.h>
21
22	douglas	25	#include <sqlite3.h>
23
24	douglas	26	#include "Display.hpp"
25
26			bool debug(false);
27
28	douglas	35	void Uname(Display &display, time_t now = 0, bool change = false)
29	douglas	33	{
30	douglas	35	if (!now \|\| change)
31			{
32			utsname os;
33	douglas	33
34	douglas	35	::uname(&os);
35	douglas	33
36	douglas	35	static Pcre::RegEx version(_B("^(\\d+\\.\\d+)-([A-Z])[A-Z](-p\\d+)?.$"));
37			Pcre::RegEx::Match match(version(os.release));
38	douglas	33
39	douglas	35	display.Set(0, 1, os.sysname + _B(" ") + match[1] + match[2] + match[3]);
40			}
41	douglas	33
42			int mib[] = { CTL_KERN, KERN_BOOTTIME };
43			timeval boottime;
44			size_t size(sizeof (boottime));
45
46			if (now && ::sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 && boottime.tv_sec != 0)
47			{
48			time_t uptime(now - boottime.tv_sec);
49
50			if (uptime > 60)
51			uptime += 30;
52
53	douglas	35	char *when;
54			int days(uptime / 86400);
55	douglas	33
56			uptime %= 86400;
57
58	douglas	35	int hours(uptime / 3600);
59	douglas	33
60			uptime %= 3600;
61
62	douglas	35	int minutes(uptime / 60), seconds(uptime % 60);
63	douglas	33
64	douglas	35	::asprintf(&when, "%i+%02i:%02i:%02i", days, hours, minutes, seconds);
65
66			std::string then(when);
67
68			then.append(17 - std::strlen(when), ' ');
69
70			std::free(when);
71
72			if (change)
73			display.Set(0, 2, _B("up ") + then);
74			else
75			display.Set(3, 2, then);
76	douglas	33	}
77			else
78			display.Set(0, 2, _B("up -+--:--:-- "));
79
80			double averages[3];
81
82			if (::getloadavg(averages, 3) == -1 \|\| !now)
83			display.Set(0, 3, _B("-.--, -.--, -.-- "));
84			else
85			{
86	douglas	35	char *load;
87	douglas	33
88	douglas	35	::asprintf(&load, "%.2f, %.2f, %.2f", averages[0], averages[1] , averages[2]);
89	douglas	33
90	douglas	35	display.Set(0, 3, load + std::string(20 - std::strlen(load), ' '));
91
92			std::free(load);
93	douglas	33	}
94			}
95
96	douglas	22	int main(int argc, char *argv[])
97			{
98	douglas	26	std::string device;
99
100	douglas	25	{
101	douglas	26	Pcre::RegEx devicePath(_B("^-device=(/.+)$"));
102			Pcre::RegEx deviceNumber(_B("^-device=([0-9]+)$"));
103			Pcre::RegEx deviceName(_B("^-device=(.+)$"));
104	douglas	25
105	douglas	26	for (char *arg = argv + 1; arg; ++arg)
106	douglas	25	{
107	douglas	26	Pcre::RegEx::Match match;
108	douglas	25
109	douglas	26	if (*arg == _B("-debug"))
110			debug = true;
111			else if (match = devicePath(*arg))
112			device = match[1];
113			else if (match = deviceNumber(*arg))
114			device = _B("/dev/cuaU") + match[1];
115			else if (match = deviceName(*arg))
116			device = _B("/dev/") + match[1];
117			else
118			goto usage;
119	douglas	25	}
120			}
121	douglas	26
122			if (device.empty())
123			{
124			usage: std::cout << _B("Usage: ") << argv[0] << _B(" [-debug] [-device=device]") << std::endl;
125
126			return 2;
127			}
128
129			try
130			{
131			Display display(device);
132
133	douglas	28	display.Clear();
134	douglas	29	display.SetBacklight(100);
135	douglas	33	display.Set(2, 0, _B("--:--:-- -- ---"));
136	douglas	28
137	douglas	36	enum { Running };
138
139			display.Set(Running, Display::Green, 0);
140			display.Set(Running, Display::Red, 100);
141
142	douglas	33	{
143			uint8_t mask(Display::Up \| Display::Enter \| Display::Cancel \| Display::Left \| Display::Right \| Display::Down);
144
145			display.KeyReporting(mask, mask);
146			}
147
148			::Uname(display);
149
150			display.Store();
151	douglas	36	display.Set(Running, Display::Green, 100);
152			display.Set(Running, Display::Red, 0);
153	douglas	33
154	douglas	35	enum Mode { Uname, Music, English, Metric, Nautical, Last } mode(Uname);
155			//Audacious::Audacious audacious;
156			//GPS::GPS gps;
157	douglas	33
158	douglas	35	_forever
159			{
160			time_t now(std::time(NULL));
161	douglas	26
162	douglas	35	{
163			char when[16];
164	douglas	26
165	douglas	35	std::strftime(when, sizeof (when), "%l:%M:%S %p %Z", std::localtime(&now));
166	douglas	33
167	douglas	35	display.Set(2, 0, when);
168			}
169	douglas	33
170	douglas	35	switch (mode)
171			{
172			default:
173			::Uname(display, now);
174
175			break;
176			case Music:
177			case English:
178			case Metric:
179			case Nautical:
180			break;
181			}
182
183			::sleep(1);
184			}
185	douglas	26	}
186	douglas	25	catch (const std::exception &exception)
187			{
188			std::cerr << argv[0] << _B(": ") << exception.what() << std::endl;
189
190			return 1;
191			}
192
193	douglas	22	return 0;
194			}