Family blogs

RSS

I imagine there were others in the mental ward, non-nurses or doctors, with four year degrees. But it made me kind of proud and humbled that I achieved some of the things I have in my life inspite of a mental diagnosis.

I felt very much like Siddhartha might have felt when he left the privileged place where he was raised and went out to walk with the people.

I never in my life would have not allowed me to get the degree - my greatest achievement. It was a goal that I set and made half the world struggle with me as I went out like the most determined person in the world to get it. It was so so hard to fight for that 4 year degree in 12 long hard years. But I made a lot of friends along the way.

My friends in the mental ward had parole officers, had done wrong things I know I never would do, had been violent or done drugs or hurt themselves. I am not better than them. But I made my strife for something different. I made my fight for something else. It was for 12 years a degree.

Now I am volunteering for River's Way. I want to help them get better donations so they might help more people. I had other goals, that feel as if they might have been lofty. I wanted to work and take complete control of my life, to be 100 percent independent. Now having seen what I saw in the ward, I know I don't have to.

I have so much more family and friends, in the deepest most wonderful beloved way than any of the people I know, even the nurses. I come from a place of pure helping, and for just a while I would like just to try a little bit harder to be a little bit more grateful in everything I do.

I have been listening to Joe Purdy's Children of Privilege. And it occurs to me oddly that I think I met this man who sings my tune. Once long ago in Berea he might have visited Rheldi Purdy or I am wrong, but if it was him, it could have been because he apparently has Fayetteville connections.

My brother Joey helped me so much. And then if I start naming everyone I just get so many names down and it gets boring on paper to look at. My own professor guide even called me in there and I got to talk to her beautiful husband. I am just so blessed.

Joey

The first library is a libmodbus binding in haskell.

There are a couple of other haskell modbus libraries, but none that support serial communication out of the box. I've been using a python library to talk to my solar charge controller, but it is not great at dealing with the slightly flakey interface. The libmodbus C library has features that make it more robust, and it also supports fast batched reads.

So a haskell interface to it seemed worth starting while I was doing laundry, and then for some reason it seemed worth writing a whole bunch more FFIs that I may never use, so it covers libmodbus fairly extensively. 660 lines of code all told.

Writing a good binding to a C library has art to it. I've seen ones that are so close you feel you're writing C and not haskell. On the other hand, some are so far removed from the underlying library that its documentation does not carry over at all.

I tried to strike a balance. Same function names so the extensive libmodbus documentation is easy to refer to while using it, but plenty of haskell data types so you won't mix up the parity with the stop bits.

And while it uses a mutable vector under the hood as the buffer for the FFI interface, so it can be just as fast as the C library, I also made functions for reading stuff like registers and coils be polymorphic so easier data types can be used at the expense of a bit of extra allocation.

The big win in this haskell binding is that you can leverage all the nice haskell libraries for dealing with binary data to parse the modbus data, rather than the ad-hoc integer and float conversion stuff from the C library.

For example, the Epever solar charge controller has its own slightly nonstandard way to represent 16 bit and 32 bit floats. Using the binary library to parse its registers in applicative style came out quite nice:

data Epever = Epever
    { pv_array_voltage :: Float
    , pv_array_current :: Float
    , pv_array_power :: Float
    , battery_voltage :: Float
    } deriving (Show)

getEpever :: Get Epever
getEpever = Epever
    <$> epeverfloat  -- register 0x3100
    <*> epeverfloat  -- register 0x3101
    <*> epeverfloat2 -- register 0x3102 (low) and 0x3103 (high)
    <*> epeverfloat  -- register 0x3104
 where
    epeverfloat = decimals 2 <$> getWord16host
    epeverfloat2 = do
        l <- getWord16host
        h <- getWord16host
        return (decimals 2 (l + h*2^16))
    decimals n v = fromIntegral v / (10^n)

The second library is a git-lfs implementation in pure Haskell.

Emphasis on the pure -- there is not a scrap of IO code in this library, just 400+ lines of data types, parsing, and serialization.

I wrote it a couple weeks ago so git-annex can store files in a git-lfs remote. I've also used it as a git-lfs server, mostly while exploring interesting edge cases of git-lfs.

This work was sponsored by Jake Vosloo on Patreon.