Re: Ultra-minimial module for using LCD proc with custom hardware
Fake Name <[email protected]> Mon, 27 Jan 2014 21:35:36 -0800
| Newsgroups | gmane.comp.sysutils.lcdproc |
|---|---|
| Message-ID | <[email protected]> |
This is a multi-part message in MIME format.
--------------010107000008070305080308
Content-Type: multipart/alternative;
boundary="------------010907000801040107000306"
--------------010907000801040107000306
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
On 1/26/2014 1:47 AM, Markus Dolze wrote:
> On 23.01.2014 05:58, Fake Name wrote:
>> I apologize for spamming up the list, then.
>>
>> The youtube video seems to be in the mail, at least when viewed on
>> the mailing-list online viewer
>> (http://lists.omnipotent.net/pipermail/lcdproc/2014-January/014187.html),
>> but here it is as a non-inlined URL anyways:
>> www.youtube.com/watch?v=RsW7MzdMGhg
>>
>> Basically, it's just analog gauges that show current network traffic
>> in realtime via the LCDProc plugin for PFsense, with some non-linear
>> scaling (square root scaling). PFSense uses a custom PHP script for
>> the LCDProc client, rather then the built-in LCDProc client, so there
>> was some hacking there, which I'd be happy to release (though it's
>> not germane to the patch). I'd just need to figure out where it went
>> (bsd and updates are weird).
>>
>> Connor
>
> Hi Connor,
>
> I still have not looked at the driver, but I watched the video and now
> have a better understanding of what you want to achieve and why you
> want to use LCDproc for that purpose.
>
> My first thought was: 'Why is he parsing LCDd's output instead of just
> reading the stat values himself?' I now understand that the values are
> supplied by pfsense.
>
> Next was: 'Why is he not implementing some existing update protocol?'
> - Because you need to parse the output. OK for this application.
> Usually I advice people to implement some existing protocol. Even 8
> bit micro controllers can be taught to understand control codes with
> just a few lines of code. (see [1]).
>
> [1] http://mmdolze.users.sourceforge.net/display-with-rotary-encoder.html
>
> Then I checked if a driver already exists that is as simple as yours
> (except for the timing). To my surprise there isn't.
>
> What I like about your driver is the ability to adapt the frame buffer
> (size) to other loaded drivers. So one may use your driver well for
> debugging purpose, too.
>
> However, I suggest the following changes:
>
> 1. Rename the driver to 'simpleserial'. It is 'reallysimpleserial',
> but I feel this sound like a joke - which it is not.
> 2. Do not rely on the number of calls to flush() to count for one
> second. Yes, LCDd is coded to 8 Hz, but it is designed as a
> changeable value. I suggest to use the system's time functions.
> 'timing.h' provides some examples.
> 3. Make the refresh rate configurable. If implementing 2, it is
> simply the milli seconds until the next update (or 0 to update
> every time and 1000 as default). This makes it a fully blown
> serial debug driver.
> 4. Make the serial speed configurable. It doesn't need to support the
> full range of speeds (like hd44780-serial.c), but some 'low'
> (9600) or 'high' (115200) speed would be great.
>
> Regards,
> Markus
>
Ok, here is a updated patch that includes the suggested changes.
1. I've renamed the driver rawserial, since that's more descriptive.
2. Updates are now managed through a internal timing system, though the
overall updates are still managed by flush() call rate (is there a
better way to get internal callbacks?). This means the *maximum* rate
possible is 8 hz, though I think that's probably plenty, and I didn't
want to play with threading.
3, 4. Baud rate and update-rate are configurable. Baud rates were
stolen from the Cfontz driver, so available rates are 1200, 2400, 4800,
9600, 19200, and 115200.
~~The internal timing is measured via gettimeofday(), which is the same
way this is measured in the main server loop (in main.c). However, it's
worth noting that this is *not*a good way to get delta-times, since
gettimeofday() is *not monotonic*. This means that if the clock goes
backwards such as during daylight-savings-time or NTP updates, you can
have inaccurate or excessive delays. For example, if something is
scheduled for 125 ms in the future, and the clock is set back an hour,
the next update will not occur for an hour + 125 ms.
The main loop is doing some lag calculation stuff, and I have not looked
at it deeply enough to determine if it fixes the possible DST/NTP
issues, I think it may (`(t_diff < 0) )`) would prevent negative times,
though with some jitter around the transition period, but it would be on
the order of a few seconds only, I think.
It's a pretty minor issue, but it's worth looking at.
FWIW, the "proper" way to deal with this is to use
clock_gettime(CLOCK_MONOTONIC), but that requires linking against librt
(lib realtime). It may not be enough of a problem to bother with.~~
Never mind, I examined the stuff in main.c more closely, and it's doing
a bit of checking to ensure that any excessively large time-steps cause
the delta tracking mechanisms to be reset. I still think switching to
CLOCK_MONOTONIC is /probably/ a good idea, but the inconvenience of
having to link against librealtime mean it's likely not worth changing.
Anyways, I implemented similar checking to the things in main.c in my
timer loop, so it should be safe as well.
Connor.
--------------010907000801040107000306
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: 7bit
<html>
<head>
<meta content="text/html; charset=ISO-8859-1"
http-equiv="Content-Type">
</head>
<body bgcolor="#FFFFFF" text="#000000">
<div class="moz-cite-prefix">On 1/26/2014 1:47 AM, Markus Dolze
wrote:<br>
</div>
<blockquote cite="mid:[email protected]" type="cite">
<meta content="text/html; charset=ISO-8859-1"
http-equiv="Content-Type">
<div class="moz-cite-prefix">On 23.01.2014 05:58, Fake Name wrote:<br>
</div>
<blockquote cite="mid:[email protected]"
type="cite">
<meta content="text/html; charset=ISO-8859-1"
http-equiv="Content-Type">
I apologize for spamming up the list, then.<br>
<br>
The youtube video seems to be in the mail, at least when viewed
on the mailing-list online viewer (<a moz-do-not-send="true"
class="moz-txt-link-freetext"
href="http://lists.omnipotent.net/pipermail/lcdproc/2014-January/014187.html">http://lists.omnipotent.net/pipermail/lcdproc/2014-January/014187.html</a>),
but here it is as a non-inlined URL anyways: <a
moz-do-not-send="true" class="moz-txt-link-abbreviated"
href="http://www.youtube.com/watch?v=RsW7MzdMGhg">www.youtube.com/watch?v=RsW7MzdMGhg</a><br>
<br>
Basically, it's just analog gauges that show current network
traffic in realtime via the LCDProc plugin for PFsense, with
some non-linear scaling (square root scaling). PFSense uses a
custom PHP script for the LCDProc client, rather then the
built-in LCDProc client, so there was some hacking there, which
I'd be happy to release (though it's not germane to the patch).
I'd just need to figure out where it went (bsd and updates are
weird).<br>
<br>
Connor<br>
</blockquote>
<br>
Hi Connor,<br>
<br>
I still have not looked at the driver, but I watched the video and
now have a better understanding of what you want to achieve and
why you want to use LCDproc for that purpose.<br>
<br>
My first thought was: 'Why is he parsing LCDd's output instead of
just reading the stat values himself?' I now understand that the
values are supplied by pfsense.<br>
<br>
Next was: 'Why is he not implementing some existing update
protocol?' - Because you need to parse the output. OK for this
application. Usually I advice people to implement some existing
protocol. Even 8 bit micro controllers can be taught to understand
control codes with just a few lines of code. (see [1]).<br>
<br>
[1] <a moz-do-not-send="true" class="moz-txt-link-freetext"
href="http://mmdolze.users.sourceforge.net/display-with-rotary-encoder.html">http://mmdolze.users.sourceforge.net/display-with-rotary-encoder.html</a><br>
<br>
Then I checked if a driver already exists that is as simple as
yours (except for the timing). To my surprise there isn't.<br>
<br>
What I like about your driver is the ability to adapt the frame
buffer (size) to other loaded drivers. So one may use your driver
well for debugging purpose, too.<br>
<br>
However, I suggest the following changes:<br>
<ol>
<li>Rename the driver to 'simpleserial'. It is
'reallysimpleserial', but I feel this sound like a joke -
which it is not.</li>
<li>Do not rely on the number of calls to flush() to count for
one second. Yes, LCDd is coded to 8 Hz, but it is designed as
a changeable value. I suggest to use the system's time
functions. 'timing.h' provides some examples.</li>
<li>Make the refresh rate configurable. If implementing 2, it is
simply the milli seconds until the next update (or 0 to update
every time and 1000 as default). This makes it a fully blown
serial debug driver.<br>
</li>
<li>Make the serial speed configurable. It doesn't need to
support the full range of speeds (like hd44780-serial.c), but
some 'low' (9600) or 'high' (115200) speed would be great.<br>
</li>
</ol>
<p>Regards,<br>
Markus<br>
<br>
</p>
</blockquote>
<br>
Ok, here is a updated patch that includes the suggested changes.<br>
<br>
1. I've renamed the driver rawserial, since that's more descriptive.<br>
2. Updates are now managed through a internal timing system, though
the overall updates are still managed by flush() call rate (is there
a better way to get internal callbacks?). This means the *maximum*
rate possible is 8 hz, though I think that's probably plenty, and I
didn't want to play with threading.<br>
3, 4. Baud rate and update-rate are configurable. Baud rates were
stolen from the Cfontz driver, so available rates are 1200, 2400,
4800, 9600, 19200, and 115200.<br>
<br>
<strike>~~The internal timing is measured via gettimeofday(), which
is the same way this is measured in the main server loop (in
main.c). However, it's worth noting that this is </strike><strike><b>not</b></strike><strike>
a good way to get delta-times, since gettimeofday() is </strike><strike><b>not
monotonic</b></strike><strike>. This means that if the clock
goes backwards such as during daylight-savings-time or NTP
updates, you can have inaccurate or excessive delays. For example,
if something is scheduled for 125 ms in the future, and the clock
is set back an hour, the next update will not </strike><strike>occur
for an hour + 125 ms. </strike><strike><br>
</strike><strike>The main loop is doing some lag calculation stuff,
and I have not looked at it deeply enough to determine if it fixes
the possible DST/NTP issues, I think it may (`(t_diff < 0) )`)
would prevent negative times, though with some jitter around the
transition period, but it would be on the order of a few seconds
only, I think.</strike><strike><br>
</strike><strike><br>
</strike><strike>It's a pretty minor issue, but it's worth looking
at.</strike><strike><br>
</strike><strike>FWIW, the "proper" way to deal with this is to use
clock_gettime(CLOCK_MONOTONIC), but that requires linking against
librt (lib realtime). It may not be enough of a problem to bother
with.~~</strike><br>
<br>
Never mind, I examined the stuff in main.c more closely, and it's
doing a bit of checking to ensure that any excessively large
time-steps cause the delta tracking mechanisms to be reset. I still
think switching to CLOCK_MONOTONIC is <i>probably</i> a good idea,
but the inconvenience of having to link against librealtime mean
it's likely not worth changing.<br>
<br>
Anyways, I implemented similar checking to the things in main.c in
my timer loop, so it should be safe as well.<br>
<br>
Connor.<br>
</body>
</html>
--------------010907000801040107000306--
--------------010107000008070305080308
Content-Type: text/plain; charset=windows-1252;
name="rawserial.patch"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
filename="rawserial.patch"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--------------010107000008070305080308
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: inline
_______________________________________________
LCDproc mailing list
[email protected]
http://lists.omnipotent.net/mailman/listinfo/lcdproc
--------------010107000008070305080308--