Posts Tagged ‘Raspberry Pi’

Functional Eclipse Computer

August 8, 2017

I have progressed on the eclipse computer project past a prototype to something that mostly works. There a few minor bugs in the code, but it is usable as-is. I’ve got fixes for them, but need to test before committing. The system still doesn’t use its buzzer for an audible prompt, and I haven’t written anything yet to help take a sequence of pictures showing the progression of the eclipse. I may not get to that for a day or two to deal with travel related issues. I plan on taking it, and a bunch of camera gear, to the Nashville area to view the eclipse.Eclipse ComputerThe picture shows what is nearly the final hardware, but older software. This video shows the current software. The hardware changes between the two are all to help keep everything from moving around in the case, and to keep the barrel connector that supplies power to the upper breadboard close to the board. The connector was moving away from the board too easily and causing a reduction in the supplied voltage.

All of these problems were solved by applying solid copper wires in the right spots. I use solid copper with breadboards a lot because I can cut the wires to the length I need and the conductor is stiff enough to be inserted into the breadboard without tinning or the addition of some connector. I used a few more of these wires to hold down the barrel connector and to apply some pressure against the top of the case. It worked out quite well.

I changed the display from a 16×2 LCD to a 20×4 one just for the additional text. The video shows how I’ve made use of the space. The 20×4 display is a bit dark and needs a backlight to be readable unless it is in bright direct sunlight. The 16×2 display didn’t have this problem; it is more like a common digital watch display in how it handles light. I made and adjusted an automatic backlight control program that gets brightness measurements from a TSL2591 at its minimum gain setting and uses one of the Raspberry Pi’s PWM outputs. It seems to make the display readable enough in bright light and keeps it from being brighter than it needs to be most of the time. I’d rather have a 20×4 that is more like the 16×2, but I haven’t got the time.

I tested the computer running on 8 Eneloop NiMH 2000mAH batteries. For most of the test, the computer was indoors and used the minimum backlight setting. It recorded around 600mW power consumption under these conditions. In brighter light, power consumption got as high as 850mW. Working out a new times of totality can add about 400mW, but I wrote the code to limit how often that occurs.

The batteries kept the computer running so long that I couldn’t finish a battery life test in one day. The combined runtime before exhausting the battery charge was around 25 hours. That was much longer than I anticipated when I decided on 8 AAs. I’m still going to use 8 because I can, and the backlight will make the runtime a bit shorter, maybe 16 or 17 hours, about twice what I need. Also, a smaller battery pack would have more room to move about, and I already wrote low battery detection code based on 8 batteries in series.

I’ve got the Raspberry Pi Zero running Gentoo Linux. I made modifications to the configuration used by OpenRC to boot up the system so that it starts the program that provides information on the LCD and the separate backlight control program. A simple Bash script keeps re-running the software until it terminates without error, or the script is killed. No GUI is installed. I’m going to see if I can get it to set the clocks on my cameras, and bring up a network connection, when the corresponding device is plugged into USB. Nothing critical, but it would be nice. Hopefully plugging in a camera won’t cause it to reboot.


Eclipse Computer Prototype

July 30, 2017

I’m going to see the upcoming total solar eclipse on August 21, 2017 somewhere north of Nashville. I’d like to get some good photographs of the event, which makes anticipating when certain eclipse events will occur very helpful. For this purpose, I put together a custom computer system to provide me with some information about the eclipse based on my location.

The prototype eclipse computer

The prototype eclipse computer

The computer is based around a Raspberry Pi Zero running Gentoo Linux. I used a GPS receiver from Adafruit along with GPSD to query the location, and NTPD to synchronize the system’s clock with the atomic clocks of GPS. I also used a 16×2 LCD that is readable in bright light, and with the help of its backlight, is readable in the dark. To power it, I’m using Adafruit’s Verter product; it takes 3 to 12 volts in, and produces 5.2 volts to run everything. It makes for a flexible power supply that doesn’t require me to buy a special battery that I might not use much in the future. I plan to use 8 AA batteries.

The software figures out when totality, the part of the eclipse when the moon’s umbra blocks the sun from view, begins and ends using some data published by NASA. The data shows the irregular shape of the moon’s umbra projected onto the irregular shape of the Earth at one second intervals. Using this, I made the program search for which of the umbra shapes contains the location provided by GPSD. The resulting totality time information, plus the current time and location, cycle across the LCD. Its results don’t exactly match many of the interactive maps available online, but I think they may be using a simplified, maybe circular, umbra shape and may not account for the Earth’s terrain.

At present, the program doesn’t take any user input. I’m considering changing that, but I want it to be useful without input. I’m going to put it inside a sturdy case that is water resistant enough that it should survive a strong downpour, just in case I have to deal with less than ideal weather. The top of the case is transparent, so the current version of the system can be useful without opening the case.

What it doesn’t do right now is show when the very beginning and ending of the eclipse occurs. I’m having some trouble figuring out how to do this. I’d also like it to show the azimuth and elevation of the sun for the current time, the beginning and ending of the eclipse, and mid-totality. I hope to make a time-lapse video of the event, and want to keep the sun in the frame, but do not want to disturb the camera once it starts. I did make an attempt at computing the values based on an algorithm published by NOAA, but what I made doesn’t produce correct azimuth values. Unfortunately, that is the more important value of the two for this eclipse.

I have published my source code as two repositories on Github. The first is a library I wrote intended to provide a C++ happy high-level style interface to using low-level hardware. I called it DUDS, for Distributed Update of Data from Something. I’m not very good at names. The name shows what I’d like to do with the library in the future, but I’ve got to build up other functionality first. It is already useful for this eclipse computer, so I hurried a bit to publish the code.

The second repository is for the eclipse computer program. It also includes a program to test finding totality times that does not use DUDS, and takes longitude and latitude values from standard input.

I’ll be doing more development and testing for at least a couple weeks.

Replacement I2C kernel module for Raspbian

January 8, 2014

A while ago, I got I2C repeated starts and SMBus support to work from the Linux kernel on a Raspberry Pi. I recently built a new 3.10.25 kernel from the foundation’s kernel fork on Github and updated my own fork of their fork with just the I2C update in a new branch. In the process, I managed to misuse git so that commits now attempt to go to the Raspberry Pi Foundation’s kernel fork rather than my own. I tested the module on the copy of Raspbian that I have. It is running the 3.10.24 kernel, but is quite happy with the new kernel module (or for 3.10.37, or 3.12.24) and my MLX90614 test program. I also built the kernel module for the BMP085, but it looks like that requires more than just a kernel module file to get it working. No big deal for me; I’ll just replace the whole kernel.  I just wanted to see if I could make it really easy for someone else.

To use the updated I2C module, first download it. The file will need to replace the one in /lib/modules/<kernel version>/kernel/drivers/i2c/busses. You may want to keep a copy of what is already there. After copying it, check to see if the i2c-bcm2708 module is loaded. If not, load it up and have fun! If it is, you can either reboot or unload the i2c-bcm2708 kernel module. Before unloading will work, any dependent modules must first be unloaded. It wasn’t loaded for me right after boot, so it hopefully won’t be any trouble.

Update: I finally got the code up on Github. I hope the kernel module has been working out for anyone who has tried it. Please do leave a comment about any success or failures with it. I have yet to get any feedback, so I only have my own test case to claim that it works.

I2C repeated starts implemented on the Raspberry Pi

July 13, 2013

Update: If you just want a kernel module for something close to kernel version 3.10.25, look here.

I’m working on a project that uses the Raspberry Pi and various sensors. One sensor is a MLX90614 IR thermometer; this communicates using SMBus. One of my goals is to avoid making the project specific to the target hardware, the hardware that actually runs my code. I want the code that communicates with the sensors to be Linux specific but not Raspberry Pi specific.

Communication with a MLX90614

Communication with a MLX90614

One of the problems a lot of people have had with the Raspberry Pi is with getting SMBus communication to work. SMBus is built on I2C, a way of managing serial communication between many devices with only two wires: clock and data. I2C is more flexible, while SMBus is made to be more reliable. As part of guaranteeing reliability, mostly in a multi-master setup, SMBus requires the use of I2C’s repeated starts for read operations. The I2C master driver for Linux on the Raspberry Pi does not support this, and I have been unable to find a patch or custom version anywhere that adds support. Most people have solved the problem by using code that directly interfaces with the Raspberry Pi’s hardware, ignoring the Linux kernel support altogether. This solution not only fails to meet my goal of avoiding code specific to the target hardware, it also won’t work well if more than one process on the same host attempts to use the I2c master hardware.

I decided to solve the problem by modifying the Linux kernel’s support for the I2C master of the Raspberry Pi. I succeeded. My implementation may not be the best or bug free (works for me is a weak guarantee), but it does allow for communication with a MLX90614 using the user-space (unprivileged code outside the kernel) SMBus interface provided by Linux. Since examples with SMBus are more difficult to find than I2C, here is my test code. I also tested with a BMP085 sensor using the support for it already in Linux. This sensor uses I2C rather than SMBus, and it also functions correctly. It doesn’t need a repeated start, but it gets one anyway.

To avoid causing extra trouble, I implemented repeated starts for a subset of conditions under which they could be valid. I focused on SMBus communication. With I2C, a slew of messages going back and forth can be requested, all with repeated starts, but this isn’t normally done or required.  Also, the hardware requires that once the first message has begun transmission, the second message be setup in the registers ahead of the stop condition. To make matters worse, there is no interrupt condition for this, so polling in a busy wait is required. I stuck all this inside the bcm2708_i2c_master_xfer() function of i2c-bcm2708.c so it isn’t in the interrupt handler. After the second message is configured, the interrupt handler is used to receive the data. That avoids additional polling at the cost of not allowing additional repeated starts.

If you’d rather see the kernel change in source control, I stuck it on Github. It is a 3.6.11 kernel, but not the latest revision out there. I’m still using it for now. There is no kernel or kernel module for download here because I’m running Gentoo on my Raspberry Pi and I build my own kernels. If I gave you my kernel, you may well find that something doesn’t work anymore.

Raspberry Pi + Linux Interrupt Latency: 10μs

March 1, 2013

I decided I wanted to use a capacitive relative humidity sensor in a project with a Raspberry Pi, but that meant timing the charing or discharging of the sensor in an RC circuit. These things don’t have much capacitance, and the data sheet suggests it might not give good results under 1kHz. That makes it look like it’ll need microsecond timing at least to provide usable data.

I first tried making two consecutive calls to clock_gettime() and found that it takes between 2 to 5μs to complete one call on an otherwise idle Raspberry Pi. This wasn’t good enough, so I figured I’d dip into the kernel to see what could be done. The impact of scheduling processes and context switches should be minimized by solving the problem in the kernel. Thus far, this is the most involved attempt I’ve made at messing with the Linux kernel. The result was a bit messy, but I got it working. If you want a peek, its on Github.

I modified the code in bcm2708_gpio.c to record the time from a free-running timer whenever the output of a GPIO was changed, or an input state change triggered an interrupt. After managing to get the code to do about what I intended (sysfs has an extra directory level that I haven’t figured out), I connected two GPIO lines together, set one to be an input and one an output, and set the edge of the input to falling. There is nothing special about the falling edge for this test, but the edge had to be set to trigger the interrupt. Then I set the output to one, then zero, and checked the results.

I found that the timing showed 10 to 11μs would elapse between the output state change and running the GPIO interrupt handler when an X server is also running. Without X, I saw a latency of just under 9μs. The timer was configured to increment once every 4ns, so its precision should be more than adequate for these results. I suppose I could have added a significant digit. I’m surprised the times were so high; given the times on the consecutive calls to clock_gettime(), I was hoping for something better.

I know there are people who will blame Linux for the poor result, but this result is the system timing itself; it includes the hardware. What I saw in the BCM2835 documentation seemed to suggest the processor has an interrupt vector table with one entry, just like Microchip’s PIC16F84, an old 8-bit microcontroller. If so, that would suggest something else causes so much latency that there wasn’t a point in having a larger interrupt table. Even some of Atmel’s AVR 8-bit microcontrollers, like the ATtiny25, have several entries, so it isn’t expensive to do.

While BCM2835 offers poor interrupt response times, it does have nice graphics, runs Linux, and can run all the development tools needed for all this messing around in the kernel. No microcontroller is going to do that, unless it is part of a Rube Goldberg machine. I did build the kernel on my AMD64 deskunder computer, though. It’s much faster.

My biggest surprise doing all this is that it is possible to cause a segmentation fault in the kernel and not crash a single process. Do it a few times, though, and it might crash something. It logged me out once.

False Steps

The Space Race as it might have been

You Control The Action!

High Frontier

the space colony simulation game

Simple Climate

Straightforwardly explaining climate change, so you can read, react and then get on with your life.