rfcomm

rfcomm is used to set up, maintain, and inspect the RFCOMM configuration of the Bluetooth subsystem in the Linux kernel. First of all, create /etc/bluetooth/rfcomm.conf

1
2
3
4
5
6
7
8
9

# /etc/bluetooth/rfcomm.conf
rfcomm0 {
bind yes;
# Replace the device address with the address of your bluetooth serial device
device 20:13:10:25:40:43;
# channel 1 is VERY IMPORTANT
channel 1;
comment "Bluetooth Serial";
}

1

rfcomm bind 0

Comparing regex performance between MongoDB, MySQL and PostgreSQL

MongoDB has a very rich regular expression (regex) interface. Regex is available in many of the places that ordinary character strings are accepted. While convenient to use, I had some questions about how MongoDB regex performance stacks up to regex performance in other (SQL) Databases.

To run the examples in this post, clone the github repository at https://github.com/dwilkins/mongoregexp and follow the instructions in the README.md file

Simplicity

MongoDB regexes are simple to use. Instead of using double quotes, use forward slashes to delimit strings to match:

1
2

db.loglines.find( { logline: "66.249.65.20" ,$comment: "No Regex"}).count();
db.loglines.find( { logline: /^66\.249\.65\.20/ ,$comment: "Using Regex"}).count();

The difference is, double quotes require a full, exact string match. Forward slash (regex) will match rows where the string matches the pattern given. If no special regex characters are given columns that contain the search string anywhere in the column are considered positive matches.

The first query will only find rows that exactly match the IP Address of "66.249.65.20" The second query will find rows that match that IP address at the beginning of the line and with any (or none) characters following. The "^" character is an anchor which means that it helps the regex engine restrict the search to the beginning of a string.

MySQL and PostgreSQL regexes are just as simple to use:

1

select count(1) into @rows from loglines where logline regexp '^66\.249\.65\.20';

1

select 'bolanchor' as Query,count(1) from loglines where logline ~ '^66\.249\.65\.20';

Notice that MySQL uses regexp instead of = . PostgreSQL uses the ~ (tilde) character instead of =

Tested Queries

I tested three different queries for performance on MongoDB, MySQL and PostgreSQL:

• bolanchor - Regex Query with a beginning of line anchor - only matches at the beginning of the line
• msiecount - Regex Query to select lines with matching characters in the middle of the line
• bolanchor - Regex Query with a end of line anchor - only matches at the end of the line

Results:

¹ MongoDB wins on the second execution, once it caches some of the data in memory. MongoDB doesn’t have a query cache like MySQL, so you can’t get instant results for the exact same query.

So, MongoDB wins handily in two cases. PostgreSQL makes a mostly respectable showing, but MySQL (MariaDB in this test) brings up a distant third place.

mkduino is a small ruby script for building a GNU Automake environment for your Arduino development.

A couple of years ago I grew tired of using the Arduino IDE. I realized that there was nothing special about a “sketch” - it was just regular C/C++ code. Having written C++ code professionally for several years, I had arrived at an environment that worked for me. This Arduino IDE bore no resemblance to that environment. Everything about it seemed to cause me problems

I started doing all of my Arduino development using the avr-g++ with my own hand crafted Makefile. The problem was that it was hard to give these to any of my friends. I started working on a rvm-like system to download all of the Arduino requirements, build them and then use that for development. That took hours (literally) to compile and seemed a little much for the typical Arduino hacker.

So, I quickly hacked together this ruby script to spit out the required files for a barebones gnu automake system.

Usage

1
2
3
4
5
6

./path/to/mkduino.rb
./autogen.sh
./configure --host=avr
make
# upload to your device
make upload

mkduino will overwrite your code if you already have a Makefile.am or any of the files it generates. You probably wouldn’t be running this utility if you already had a makefile or any of the files it generates.

Go ahead, use emacs or vi to do development for arduino. These tools have evolved over time to provide professional developers with the power they need to get stuff done.

There’s more information on mkduino over on the Github Page

The Intel Sandybridge i7-2620M processor is capable of overheating Linux

I’ve been plagued for the last few months with problems with my Intel Graphics on my Lenovo T420. I originally bought this laptop specifically because of traditionally great Linux support for Thinkpad hardware. I had the option of Intel vs Nvidia graphics, and I chose Intel because Gnome3 was reputed to work better with the Intel graphics.

This laptop has pretty impressive specs An excerpt from /proc/cpuinfo on Linux

I’ve also got plenty of ram (excerpt from /proc/meminfo:

My problems were:

• Overheating
• Poor performance when overheating
• Overheating

Frequently the temperature as reported by system monitor would register around 95C degrees, which is uncomfortably warm to both the lap and hands. I did a lot of probing around and eventually wrote a script to just detect when the graphics card was in a wierd state

After a lot of mailing list and Google research (months, not days or hours) I finally stumbled on this tidbit on the ArchWiki

Link: https://wiki.archlinux.org/index.php/Intel_Graphics#Choose_acceleration_method File to create: /etc/X11/xorg.conf.d/20-intel.conf

Cubieboard-1 - powered by the Allwinner A10 Arm SOC

When I received my first Allwinner A10 board it lacked support for hardware PWM. Without a driver for hardware PWM it’s very hard to use this very powerful SOC for controlling motors

This article describes the design of one such hardware pwm driver interface.

The Arduino has a simple to use PWM interface and other implementations should strive to have a similarly developer friendly interface. The “analogWrite” Arduino interface is both easy to understand and implement. For instance the following code implements a 50% duty cycle on digital pin 5:

1
2

pinMode(5,OUTPUT);    // Declare pin 5 as output
analogWrite(5,128);   // Output a valud between 0 (off) and 255 (full on)

One problem with the Arduino interface is the learning curve required to venture beyond the primary interface. For instance, the above code doesn’t specify the PWM period. Many motors (servos..) function best within a specific PWM period.

This implementation doesn’t allow specification of the signal polarity either. If the hardware interface requires an inverted signal, then duty will have to be computed as 1/duty manually.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void TimerOne::setPeriod(long microseconds)             // AR modified for atomic access
{

  long cycles = (F_CPU / 2000000) * microseconds;                                // the counter runs backwards after TOP, interrupt is at BOTTOM so divide microseconds by 2
  if(cycles < RESOLUTION)              clockSelectBits = _BV(CS10);              // no prescale, full xtal
  else if((cycles >>= 3) < RESOLUTION) clockSelectBits = _BV(CS11);              // prescale by /8
  else if((cycles >>= 3) < RESOLUTION) clockSelectBits = _BV(CS11) | _BV(CS10);  // prescale by /64
  else if((cycles >>= 2) < RESOLUTION) clockSelectBits = _BV(CS12);              // prescale by /256
  else if((cycles >>= 2) < RESOLUTION) clockSelectBits = _BV(CS12) | _BV(CS10);  // prescale by /1024
  else        cycles = RESOLUTION - 1, clockSelectBits = _BV(CS12) | _BV(CS10);  // request was out of bounds, set as maximum

  oldSREG = SREG;
  cli();                                                        // Disable interrupts for 16 bit register access
  ICR1 = pwmPeriod = cycles;                                          // ICR1 is TOP in p & f correct pwm mode
  SREG = oldSREG;

  TCCR1B &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
  TCCR1B |= clockSelectBits;                                          // reset clock select register, and starts the clock
}

*example code from Timer One Library for Arduino

The Linux OS and expanded ram of the cubieboard make possible a much more rich interface than the arduino affords. File based programming interfaces are available to extend the PWM control to many more languages. One possible implementation might include the following interface (examples in shell script):

• /sys/class/pwm-sunxi/pwmX

  This is the sysfs directory that contains the PWM interface. X is the PWM channel. The Allwinner A10 has 2

  • period (r/w)

    period that makes up a cycle. Can be expressed as hz, khz, ms, or us. Whole numbers only. Examples: echo 10hz > /sys/class/pwm-sunxi/pwm0/period
echo 1khz > /sys/class/pwm-sunxi/pwm0/period
echo 100ms > /sys/class/pwm-sunxi/pwm0/period
echo 100us > /sys/class/pwm-sunxi/pwm0/period
echo 150khz > /sys/class/pwm-sunxi/pwm0/period
    

  • duty (r/w)

    portion of the period above that is “active” or on. Same units as duty.
    echo 100ms > /sys/class/pwm-sunxi/pwm0/period # Period is 100 milliseconds
    echo 25ms > /sys/class/pwm-sunxi/pwm0/duty # 25% duty
    echo 50ms > /sys/class/pwm-sunxi/pwm0/duty # 50% duty
    echo 75ms > /sys/class/pwm-sunxi/pwm0/duty # 75% duty
    

  • duty_percent (r/w)

    duty expressed as a percentage. Whole numbers only
    echo 100ms > /sys/class/pwm-sunxi/pwm0/period # Period is 100 milliseconds
    echo 25 > /sys/class/pwm-sunxi/pwm0/duty_percent # 25% duty
    echo 50 > /sys/class/pwm-sunxi/pwm0/duty_percent # 50% duty
    echo 75 > /sys/class/pwm-sunxi/pwm0/duty_percent # 75% duty
    

  • polarity (r/w)

    Polarity of the pin during the duty portion. Note that the opposite state will be for the non-duty portion.
    1 = high, 0 = low

• pulse (r/w)

  Output one pulse at the specified period and duty
  echo 1 > /sys/class/pwm-sunxi/pwm0/puls # Output 1 pulse when run is 1
  

• pin (r/o)

  Name of the A10 pin this pwm outputs on. This is hardwired and informational only. Example:
  cat /sys/class/pwm-sunxi/pwm0/pin # output: PB2
  

• run (r/w)

  Enable the PWM with the previously set parameters. Example:
  echo 1 > /sys/class/pwm-sunxi/pwm0/run # Start the pwm interface
  echo 0 > /sys/class/pwm-sunxi/pwm0/run # Stop the pwm interface
  

So, the above interface as a Linux kernel module can implement a 50% duty cycle hardware pwm with the following code:

1
2

echo 50 > /sys/class/pwm-sunxi/pwm0/duty_percent
echo 1 > /sys/class/pwm-sunxi/pwm0/run

Or a 25% duty cycle at 250hz with the following code:

1
2
3

echo 250hz > /sys/class/pwm-sunxi/pwm0/period
echo 50 > /sys/class/pwm-sunxi/pwm0/duty_percent
echo 1 > /sys/class/pwm-sunxi/pwm0/run

Or a 25% duty cycle at 500hz with negative polarity with the following code:

1
2
3
4

echo 500hz > /sys/class/pwm-sunxi/pwm0/period
echo 50 > /sys/class/pwm-sunxi/pwm0/duty\_percent
echo 0 > /sys/class/pwm-sunxi/pwm0/polarity
echo 1 > /sys/class/pwm-sunxi/pwm0/run

So, the design goal of a simple interface is achieved, with incremental functionality requiring only incremental amounts of additional code.

Next article – developing the pwm-sunxi pwm module

A Mini PC with Arduino type Interface powered by ARM Pro Spec

I recently purchased a pcDuino because of it’s plenitude of I/O (5v) GPIO pins. My Raspberry Pi was an interesting board, but it lacked the GPIO and Analog to Digital inputs that make the Arduino so useful. The Arduino, while imminently useful, lacks the power to handle images and other high-bandwith tasks so it’s relegated to motor control and simple I/O.

The pcDuino comes well-outfitted compared to both the Raspberry Pi and the Arduino:

Once I saw the horrid version of Lubuntu that came pre-installed on the device, I started looking for a Fedora port. Luckily Hans de Goede has published a Fedora port for the Allwinner 10 chip. Loading this was simple and straightforward – just follow the README

Then came the task of accessing the GPIO. The Lubuntu image that came with the device exposed some GPIO pins at /sys/devices/virtual/misc/gpio, but Fedora did not show any pins there. After a couple of days of probing the Internet for the source, I stumbled across the amazing GPIO sysfs capabilities of Linux.

After following the guide on elinux.org, I was still unable to access *any* GPIO. Then I remembered that I chose “cubieboard” when I loaded the port by Hans. More hunting revealed uboot, sunxi-tools and the script.bin file. Following are the rough instructions on how to get access to the GPIO on your pcDunio in Fedora…

Start with the Fedora port by Hans de Goede.

• In step 6 when it asks you to select a board with:
  sh <uboot-part-mount>/select-board.sh
  
• Select the cubieboard
• Clone the linux-sunxi/sunxi-tools on your Linux box (not the pcDunio)
• Compile by typing make Don’t worry if it doesn’t compile everything. The two commands we need – bin2fex and fex2bin will be compiled in that directory
• Mount your microSD card and grab the script.bin file from the pcDuino (/boot/uboot/script.bin)
• Convert it to fex format bin2fex script.bin > myboard.fex
• Grab the pcDuino fex file from linux-sunxi / sunxi-boards
• Copy the lines from section [gpio_para] into your myboard.fex file at about the same place they were in the pcduino.fex file
• Convert it back to bin format with fex2bin myboard.fex > script.bin
• Move it back into place as /boot/uboot/script.bin

• Unmount your sdcard from your Linux box and boot your pcDuino – it’s got new superpowers now.
• Follow the guide at elinux.org
• PROFIT

Bash shell script that blinks the LED

Pic or it didn’t happen

I had a heck of a time getting a Rails + Unicorn + nginx deployment going on Fedora 17. The problem was, I could get it running using TCP sockets but not using unix sockets. I loosely followed these instructions for deploying a Rails 3.2 app but kept having problems with the unix sockets.

The Solution:

Don’t put the socket file in the /tmp directory.

The Why:

Fedora has this in /etc/systemd/system/multi-user.target.wants/nginx.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[Unit]
Description=The nginx HTTP and reverse proxy server
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true
[Install]
WantedBy=multi-user.target

And if you look over on the Unicorn site, you’ll see this as the documentation for the listen method / configuration setting

Adds an address to the existing listener set. May be specified more than once. address may be an Integer port number for a TCP port, an “IP_ADDRESS:PORT” for TCP listeners or a pathname for UNIX domain sockets.

1
2
3
4

listen 3000 # listen to port 3000 on all TCP interfaces
listen "127.0.0.1:3000"  # listen to port 3000 on the loopback interface
<strong>listen "/tmp/.unicorn.sock" # listen on the given Unix domain socket</strong>
listen "[::1]:3000" # listen to port 3000 on the IPv6 loopback interface

Which encourages folks to put the socket in the /tmp directory. This is going to cause trouble for every Fedora user that tries to use Unicorn.

While debugging this I got the infamous “502 Bad Gateway” page from nginx. I checked out the error_log, and this message was there:

1
2
3
4
5
6

2013/04/05 12:25:58 [crit] 2906#0: *29 connect() to unix:/tmp/my_project_name.socket failed
                    (2: No such file or directory) while connecting to upstream,
                    client: 192.168.10.234, server: my_project_name.railsit.com,
                    request: "GET / HTTP/1.1",
                    upstream: "http://unix:/tmp/my_project_name.socket:/",
                    host: "my_project_name.railsit.com:8081"

So, after a couple of hours of head scratching and WTF’ing, I remembered that systemd did some crazy shenanigans to mysql, preventing me from setting the file limit higher. As soon as I saw the PrivateTmp=true line in the nginx.service file, I knew that systemd was the culprit.

Hope this helps someone.