A quick adaptation of Nebri’s straightforward blog post is to first shortlist rain related codes into 15 of them and changing from forecast to latest measurement instead. Bridging Nebri and my smartwatch are Twitter and IFTTT recipe–the watch merely mirrored my phone, you don’t need it actually. Why (again) Twitter? Well, rather than the “then that” side–the watch enabler, the “if this” side of IFTTT for Twitter recipes is quite powerful given so many tweet filtering options.

Key-value pairs as trigger for event driven Nebri OS workflow

Many things already taken care by Nebri, hence unseasoned programmer should easily cope with writing simple Python rule and focus on the automation, nevertheless complex rule should also be accommodated. I was having trouble on using previous KVP from different PID though–moved them to comment in the script, but they seem to be working on it. Check their YWeather blog post on how the basics work and compare what I did in Github. I embed an example tweet from @twithujan below. Yahoo! Weather frequency of measurement and accuracy are of different topic by the way.

Bogor is Light Rain with temperature at 23 °C. Taken at Thu, 28 May 2015 7:00 pm WIT

— Twit Hujan (@twithujan) May 28, 2015

PS: “hujan” means “rain” in Indonesian

A matrix keypad instance is defined by:

1. Actual GPIO pins used forming the row and column of the m x n matrix
2. Individual character in-use as symbol for each button

Hence, I instantiate and call method like

...
QPad  = matrixQPi(keyPad=keyPad,row=row,col=col)
print QPad.scanQ()

to print the character being pressed. Some examples pushed to my github explains how the above keyPad, row, and col are defined to scan-read pressed button of 2×2, 2×3, and 4×3 matrix keypads (or have it 3×4 matrix keypads in other words).

Illustration of any m-by-n matrix: 4x3, 2x2, and 2x3 keypad with different button symbols & GPIO combinations

I used deprecated Wiring-Pi Python (they already moved to 2.x version) without problem. However, you’ll fail building from latest commit and must use combination of older commits as described by my updated part of an old-post. By the way, there’s I/O expander support for WiringPi2-Python which is good, considering:

GPIO is expensive and for the sake of a keypad, you should not spend all.

(A friend told me that once)

Updated: for those who fail to build using deprecated WiringPi-Python, check this updated post to know which commit that build without error. There is now also a Python class for matrix keypad.

My idea of having the keypad is to make alternative input available under no keyboard presence nor shell access. List of things I can think of for instances, pressed key “0″ will make the Raspberry Pi (RPi) dial GPRS to a specific ISP and act as router to the USB WiFi stick, pressed key “7″ will convert it to a router that will bridge the ethernet to WiFi, etc. In short, those key readings will invoke subsequent scripts to run inside RPi.

The physical connection schematic drawings and code are gitified (visit v1.2 of the project on gitHub). A nice animated image on how the buttons connect pins forming a matrix can be found in hackyourmind.org.

Matrix keypad: alternative quick input for Raspberry Pi to start certain command

Some remarks over what the code does:

• It only read one pressed key at a time.
• It uses no interrupt. To read input it must wait and scan (this waiting experience is by far negligible to human sense).
• Debouncing doesn’t seem necessary as WiringPi already provided this by software (I suppose this timing method on their gitHub deals with debounce).

How it works? RPi forum thread gives a general idea that applies in my case:

1. Divide the 3×4 matrix as columns and rows. 4 GPIO pins as rows are pulled-up with 10k resistors and initialized as input.
2. Other 3 GPIO pins as columns are initialized as output low.
3. First loop will scan for one pressed key being read as one of the rows pulled-low
4. After the loop breaks, all columns are set as input, then the row pin found in the loop is set as output-high
5. Second loop will scan for column being pulled-high by that row pin. Between both loops, it is assumed that the key press is still in effect. In reality, normal human act of pressing this key elapses long enough for the software to run the scans in two loops.
6. Bingo! The code reads row-column combination of the pressed key.

Example of the code’s output by calling from shell:

$ while true; do /usr/local/bin/matrixQPi.py -i; done
3
6
9
8
#
*

(In the above example ^C will throw Python KeyboardInterrupt messages before breaking the bash loop)

GPIO pin logic state (meaning voltage) are both programmable and driven by physical-connection. I choose wiringPi for practical reasons: availability of its Python wrapper and its simple syntax (glancing it at first sight). WiringPi has an option of using its own pin numbering to address it in the code instead of the original GPIO numbering (there are board revisions to watch for in some cases of usage, not mine). Every pin can be initialized as input or output.

Updated: Wiring-Pi Python is deprecated and moving to 2.x version that supports I/O expander. However, you can still find this combination of commits that will work and build without error message:

- main module: WiringPi-Python@9c77bde
- submodule: WiringPi@89bbe97

(Check how to build on my README)

Using an analog multitester, here are behavioral findings:

• GPIO pin voltage swings to high logic after reboot (the meter’s needle is rocking for a second or so). It is in low voltage afterward until being programmed or physically pulled-up.
• Two pins, wiringPi pin 8 and 9, remain in high logic voltage after reboot. They are SDA0 and SCL0 to be used as an I²C, however they can be used to read button as well. (eLinux Wiki: “there are 1.8 k pulls up resistors on the board for these pins”)
• I did short the high logic to ground accidentally, it invoked reboot. (I don’t know how many times or how long of this will brick the Raspberry Pi)

Prior to trying the push-button switch, I didn’t have proper circuitry and working with wires as probes, prone to accident that was. I found an advice to insulate the +5V pin voltage so I could worry less.

Insulate the +5V pin of Raspberry Pi

A 10k pull-up resistor and a button are enough to test the following. Go to interactive Python shell and run line by line until the button push is read as low logic (GPIO7 in this example):

# python
Python 2.7.3rc2 (default, May  6 2012, 20:02:25) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import wiringpi
>>> import time
>>> INPUT=0
>>> OUTPUT=1
>>> HIGH=1
>>> LOW=0
>>> SETUP=wiringpi.wiringPiSetup()
>>> print SETUP
0
>>> wiringpi.pinMode(7,INPUT)
>>> RESULT=wiringpi.digitalRead(7)
>>> print RESULT
1
>>> RESULT=wiringpi.digitalRead(7)
>>> print RESULT
1
>>> RESULT=wiringpi.digitalRead(7)
>>> print RESULT
0
>>>

These basics convince me to go ahead with my goal of having a membrane (matrix) keypad as input for Raspberry Pi to run some script (see next post).

(Check also RPi common USB problems post)

..you’ll always have love-hate relationship with the tools you work with.. blindly turning yourself into devoted-fanatic is another thing..

Enough bragging (let’s spare that). First we need to have /dev/tap0, /dev/tap1, etc., available using TunTap kernel extension.

I modify the small script from this post to have it available on background instead of keeping a shell open all the time:

I saved it as /usr/local/bin/setup-tap1.py

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

#!/usr/bin/python
 
import os
while 1:
	try:
		file_path = '/dev/tap1'
		dev_file = os.open(file_path, os.O_RDWR)
		interface = 'tap1'
		while 1:
			pass
	except:
		print "tap interface is closing"
		exit()
		break

Let the shell takes care of putting it to background (daemon):

[root]$ /usr/local/bin/setup-tap1.py &

and there you have one working tap interface:

VirtualBox tap interface in Mac OSX Lion 10.7

[Moving-in would probably be easier if I started life with FreeBSD. More posts to come]

Snapshot of uploaded contact data from calendar (skycure.com)

There is not other way but to check my password against the combo_not.txt found via Filestube. People already posted howto check this, the easiest way is doing a single line in the shell:

$ printf bandito | openssl sha1 | cut -c10- | grep -f - combo_not.txt
00000d40df69b72328229d2425714f40d7d9a7a3

Bingo! a match there for the password “bandito” (I choose this randomly expecting some person out there is using it). Another way (for comparison as I’m no security expert) is by this short python script (slightly altered from Phobos Technology blog post):

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

"""
Save this file as linkedin_hash.py and ensure it's
in the same folder as combo_not.txt
Usage: python linkedin_hash.py hunter2
"""
from hashlib import sha1
import sys
password = sys.argv[1]
hsh = sha1(password).hexdigest()
print "SHA-1: %s" % hsh
x = 0
for line in open('combo_not.txt','r'):
    if hsh == line.strip():
        x += 1
    elif "00000" + hsh[5:] == line.strip():
        x += 1
        print "Matching line: %s" % line
print "Number of matches: %d" % x

My verdict is: my password is on the list and I’m considering a leap of faith from devoted conspiracy believer.

PS: I don’t find that “password” or “123456″ as common passwords used by many people.
PPS: A side story: Indonesians are found to be using weakest passwords (as research over Yahoo ID revealed)

When the goal is to acknowledge a specific event, the JSON call is however limited to some basic responses. It means that you can’t query a single RPC request for i.e. the following combination: list of acknowledged events with “problem” status and trigger ID 500 (500 is merely an example).

However, combination in a single request do exist i.e. I’ve tried: list of acknowledged events with “problem” status as the following GET request:

{
"params": {"acknowledged": [1], "value": [1]}, "jsonrpc": "2.0",
"method": "event.get",
"auth": "some-hash-authentication",
"id": some-RPC-sequence-integer
}

(Note: value=1 means status is “problem”)

For the basic example above, find the script in my fork of Gescheit API.

Back to our goal of acknowledging events, our API can make the following RPCs:

ack_list=zapi.event.get({"acknowledged":[1]})
problem_list=zapi.event.get({"value":[1]})
event_trigger_list=zapi.event.get({"triggerids":[trigger_id]})

Yes, they are three requests. We can then filter out a single event to be acknowledged by intersecting the three results. The first intersection is between event_trigger_list, problem_list, and ack_list as illustrated below:

Intersection of problem list, event list with specific trigger ID, and acknowledged event list

After we opt-out those intersections, we can then get the event with problem status and choose the latest event only to be acknowledged. Check the code on my github.

Installing RPMs from Geekymedia seems to be the easiest. I only need the following to make it work:

1. python26-2.6-geekymedia1.i386.rpm
2. python26-libs-2.6-geekymedia1.i386.rpm

Close the socket. All future operations on the socket object will fail. The remote end will receive no more data (after queued data is flushed). Sockets are automatically closed when they are garbage-collected.

I implemented this low level networking interface for a server listening to remote command. The complete code can be found on Github, the following lines are just part to show when to close socket:

43
44
45
46

        clientSocket,address =s.accept()
        data = clientSocket.recv(1024)
        print "Receive command:"+data
        clientSocket.close()

What happened with the TCP state when the socket wasn’t closed: it stayed in CLOSE_WAIT state. The screenshot below shows a clip of the TCP conversation in Wireshark sniff and the netstat output:

Listening port state of a socket server written in Python

Inside hijra-0.1.18 run $ sudo python setup.py install

It’d fail as it couldn’t find HijriApplet. Rename HijriApplet.py to HijriApplet to make it work. Now, it is in path (/usr/bin/) and can be called by HijriApplet command. We can copy hijra-autostart.desktop description to i.e. ~/.gnome2/panel2.d/default/launchers for shortcut launcher.

python-gnome2-extras must be installed or else it’d fail to launch saying can’t find egg.trayicon