Code

Generative Art

Posted by epsilon on February 4, 2019

Posted in: Art, Code. Tagged: elm-lang, generative art. Leave a comment

quad-blue-depth-11,q=247789png Of late I’ve been doing some experiments with generative art using Elm, the functional language by Evan Czaplicki. Above is one example. It is created by repeatedly subdividing a square into quadrilaterals, modifying the colors as one goes. A key factor is finding a proper balance between order and randomness. For more details, see these notes. The code is on GitHub.

The image above consists of 247,789 quadrilaterals obtained via 11 repeated subdivisions. One would expect 4^11 = 4,194,304 quadrilaterals. However, at each state there is a 20% chance for a quadrilateral to become inactive, and so not to be subdivided. This results both in more visual variety and fewer quadrilaterals.

BonsaiBot

Posted by epsilon on January 2, 2016

Posted in: Code, RPi-Arduino, Science. Tagged: arduino, bonsai, gardening. Leave a comment

BonsaiBot Mark IV (photos below) was put into service tonight after a week of development and testing. It measures and reports on soil moisture and waters the Bonsai when it is too dry. The code is at GitHub. No documentation or circuit diagrams yet, but that is coming.

The sensor is made of two nails, spaced about 2 cm apart, which are driven into the soil of the pot, one near the corner, the other near the trunk. Wires lead from the nails to an Arduino Uno, with connections to ground and analog pin 0. Using a voltage divider with the soil as one resistance, a 100 KOhm resistor as the other, the Arduino monitors the voltage drop between the junction of the two resistors and ground. A measure of “wetness” ranging from 0 to 100 is derived from this reading and displayed on an LCD. Using a knob, aka potentiometer the user can set a wetness level at which watering begins.

Watering is controlled by a relay connected to one of the digital output pins. The relay operates a valve connected to a water bottle whose bottom it about 10 cm above the top of the Bonsai’s soil level. When watering begins, it runs until the measured moisture level is “wet.” At the moment, watering is set to wetness 65, which is “dry’. (Between “wet” and “dry” is “moist”). Water is administered for one second every ten seconds so as to give plenty of time for it to be absorbed. Seems to work.

Nonsense words in Swift

Posted by epsilon on August 6, 2014

Posted in: Code. Tagged: nonsense words, Swift, Swift code. Leave a comment

I’ve posted some Swift code on github for generating nonsense words. The function patternedNonsense() generates pronounceable words like

1: hira-zansa 2: siqe-ratse 3: sifo-dassa 4: tixi-furse

The second, pureNonsense9() generates words like

1: gjoh-xkcri 2: xxgg-jjqfh 3: mxsv-tngwh 4: ftkm-aakif

Both functions use an extension to the String class that works like this

let alphabet = "abcdefghijklmnopqrstuvwxyz" let digits = "0123456789" alphabet.randString(4) + digits.randString(4) // "njtu4428"

The first function makes use of diagrams, e.g.,

dgvc = ['in', 'er', 'an', 'at', 'on', 'es', 'en', 'ed', 'it', 'is', 'or', 'as', 'et', 'of', 'al', 'ar', 'ur'] dgcv = ['he', 're', 'ha', 'to', 'hi', 'ti', 'te', 'de', 'se', 'se', 'sa', 'si', 've', 'ra']

as well as a generic function randElement which returns a
random element of an array.

Posting weather data on your web site

Posted by epsilon on January 26, 2014

Posted in: Code. Tagged: html, php, weather. Leave a comment

Being trapped inside by cold and snow gave me idle time to write PHP code for displaying the temperature and weather conditions in various cities, e.g. the below at 4:55 pm today. (Brrrr!)

Upper Arlington: -2 °C, 28 °F (Cloudy)

Chicago: -1 °C, 31 °F (Mostly Cloudy)

For the HTML and PHP code, see PHP code at vschool.herokuapp.com. The code was based on an example found at codingforums.com

RFduino + TMP36 temperature sensor

Posted by epsilon on November 19, 2013

Posted in: Code, RPi-Arduino. Tagged: arduino, rfduino, temperature sensor.. Leave a comment

Here is an Rfduino mounted on a small breadboard with three circuits — with TMP36 temperature sensor, CdS photo resister, and LED (not visible). At the moment the Arduino sketch is wired to send temperature data, and the LED is turned off. The TMP36 circuit, from TMP36 to RFduino is: GND (left) to GND, middle pin to GPIO 1, right pin to AREF. Left is left when you face the flat side of the TMP36, opposite to what is shown in the picture.

I am impressed by the communication performance and reliability of RFduino. In my office about ten feet from the device, the bluetooth signal strength is about -57db. Forty feet around the corner and down the hall, the reading is -85 db but sometimes shows -125 db. But I can reliably connect and read the sensor. Twice as far away around another corner the connection is iffy — connection about half the time.

Another feature I like is that all the GPIO pins can be used for analogue read. You do not have to do anything special. Just make the declaration int sensor = 1; and then say float sensorReading = analogRead(sensor); in your loop to read sensor data from GPIO pin 1.

References:

rfduino.com/documentation

Adafruit tutorial on TMP36

RFduino @ github — source code for RFDuino’s temperature code (measures CPU temperature) and iPhone app code. My code based on this.

RFduino.com

Rfduino – read analogue sensor

Posted by epsilon on November 16, 2013

Posted in: Code. Tagged: analogue sensor, arduino, iphone app, rfduino. Leave a comment

rfduinoSensor — at github

Purpose: read data from any analogue sensor using RFDuino, display that data on iPhone. Communicaton is by bluetooth.

The iPhone app allows the user to set the minimum and maximum sensor values and the minimum and maximum scale values. For example, suppose that the minimum and maximum sensor value are set to 0 and 760, and the minimum and maximum scale values are set to 0 and 100, the a sensor reading of 380 will be displayed as a scale reading of 50. (See note on scale calibration below).

The rightmost blue button, with text “Normal” or “Reversed” is used to toggle the scale direction. For example, in normal mode, 760 gives a scale reading of 100, while in reversed mode, it gives a scale reading of 0.

This project consists of three parts:

1. The rfduino board (see http://www.rfduino.com) connected to an analogue sensor circut and to a power supply — five volts is best, but 3v works and so should 1.5v, although I have not tested that.

The basic circuit: GPIO pin 1 to sensor to resistor to GND. Optional: GPIO pin 2 to LED to resistor to GND — blinks to show that circuit is operational. Note that when using a light sensor at low light levels, the blinking LED affects the light readings.

2. A arduino sketch (Folder = Sensor_RFDuino) that you upload to the RFDuino.

3. An iPhone app that displays the sensor data. Communication with the rfduino is by Bluetooth.

Scale calibration. I used a cadmium sulfide photoresistor for this project with a 9.7 KOhm resistor. The circuit was GPIO pin 1 on RFDuino to photoresistor to resistor to GND. To calibrate, I first removed the photoresistor. This gave me the maximum sensor reading of 748. Then I attached a jumper to the pins where the photoresistor normally goes to short this part of the circuit. This gave me a minimum sensor reading of 66. I entered these values into the two “Sensor” fields on the app and pressed “Set”. Next, I set the scale mode to “Reversed”. This was so that bright light would read high on the scale, low light low.

NOTES: (1) at the moment, you need to put the folders containing the iphone code in the folder RFDuino/iPhone\ Apps so that it will see the rfduino library — RFDuino.h, etc. I will remedy this at a later date. For now, see https://github.com/RFduino/RFduino for the code needed.

(2) The code for this project is derived from Arduino sketch and iPhone code for the rfduinoTemperature project at https://github.com/RFduino/RFduino.

Quick2Wire Analogue Board – Connecting to Raspberry Pi

Posted by epsilon on May 21, 2013

Posted in: Code, RPi-Arduino. Tagged: analogue to digital, gadgets, python code, quick2wire, raspberry pi, technology. Leave a comment

This is a short report on how to connect Quick2Wire’s analogue board directly to a Raspberry Pi. The key is the pinout for for the six-pin boxed headers on the Q2W board. I ignored the 5V and Int lines, running lines only for 3.3V, GND, SCL, and SDA. I ran these to the corresponding pins on the Pi, then executed sudo python3 pcf8591read.py as before. Result? Success! I could read the potentiometer connected as in my previous post on the Q2W analogue board. See that code for comments on the Python code used to read the potentiometer.

Below is an improved set-up for connecting the Quick2Wire analogue board to the Raspberry Pi. I mounted the Q2W board on one end of a full-size breadboard with double-sided tape and inserted a Pi Cobbler on the other end. The analogue headers of the Q2W board face the inside of the breadboard.

I didn’t have the right kind of jumpers to connect the Q2W board to the breadboard, so I cut one end off of each of four female-to-female jumpers, soldered on a length of wire, and sealed the exposed connection with heat-shrink tubing. We don’t want any short circuits! With the female-to-male jumpers in had, it ws easy to set up the circuit.

Edit: On the first try, the RPi could not read data from the Q2W board. I then remembered that the left and right halves of the board are electrically separate, so I installed the red and blue jumpers you see in the center, bottom of the photo below. I also added the little LED circuit you see in the lower left, so that there is an LED to indicate whether the full board is receiving power.

Quick2Wire Analogue Board

Posted by epsilon on May 20, 2013

Posted in: Code, RPi-Arduino. Tagged: analogue to digital, python api, quick2wire, raspberry pi, tests and measurements. Leave a comment

Last night I assembled the Quick2Wire analogue board. The software setup took a little bit of fiddling, after which I was able to make the simple tests described at Quick2Wire and a measurement with a potentiometer. The source I found most useful was the post at www.miraculum.ch.

1. Set up ictools as described at adafruit.

2. Install the quick2wire-python-api in a directory /home/git as Miraculum recommends. (Make this directory if need be).

   $ cd git
   $ git clone https://github.com/quick2wire/quick2wire-python-api.git

3. Find the file pcf8591read:

   $ find /home /usr -name pcf8591read

Make a copy of this file in ~/git and rename it as pcf8591read.py. Then add the line indicated below to the code so that the head of the file looks like this:

   #! /usr/bin/env python3

   import sys
   sys.path.append(r'/home/pi/git/quick2wire-python-api/')  # add this
   from quick2wire.i2c import I2CMaster                     
   from quick2wire.parts.pcf8591 import *

As noted in Miraculum’s post, the added line ensures that the program finds the needed parts of the quick2wire-python-api.

4. On the Quick2Wire Analogue board, run a jumper from AIN0 to GND. Then say sudo python3 pcf8591read.py. You should see this:

pi@raspberrypi ~/git $ sudo python3 pcf8591read.py 
read: 1 : 0.0
read: 2 : 0.0
read: 3 : 0.0

5. Now run the jumper from AIN0 to VREF. You should see this:

pi@raspberrypi ~/git $ sudo python3 pcf8591read.py 
read: 1 : 1.0
read: 2 : 1.0
read: 3 : 1.0

6. Attach a potentiometer as follows: one outside lead to GND, the other to VREF, the middle lead to AIN0. Then test. You will get something like this as you rotate the potentiometer:

pi@raspberrypi ~/git $ sudo python3 pcf8591read.py 
read: 1 : 0.0
read: 2 : 0.0
read: 3 : 0.0
read: 4 : 0.06274509803921569
read: 5 : 0.14901960784313725
read: 6 : 0.20392156862745098
read: 7 : 0.2627450980392157
read: 8 : 0.3254901960784314
read: 9 : 0.39215686274509803
read: 10 : 0.47058823529411764
read: 11 : 0.5686274509803921
read: 12 : 0.6705882352941176
read: 13 : 0.796078431372549
read: 14 : 0.9686274509803922
read: 15 : 1.0
read: 16 : 1.0

RPi with Quick2Wire interface and analogue boads

Quick2Wire Interface Board – Assembly and Troubleshooting

Posted by epsilon on May 19, 2013

Posted in: Code, RPi-Arduino. Tagged: computer, gadgets, interface board, technology. Leave a comment

Last night I assembled the Quick2Wire interface board for the Raspberry Pi. Assembly was straightforward. To test the board, I downloaded gpi-admin using the instruction on MIRA/DEV’s blog. This blog has some very good information: hardware set-up for a circuit with one LED and one switch to test the RPi, installation of software, testing, etc. All good until I tried the commands

   sudo echo out > /sys/devices/virtual/gpio/gpio7/direction
   sudo echo 1 > /sys/devices/virtual/gpio/gpio7/value
   sudo echo 0 > /sys/devices/virtual/gpio/gpio7/value

At this point, I got “permission denied” errors — Hmmm. I also tried my previously tested program blink.py which used the RPi.GPIO library and GPIO.setmode(GPIO.BCM). The goal was to blink the green LED on the Quick2Wire board. Result, with various choices of output pin numbers: nada.

I wasn’t sure that the board was working, since this is the second one I’ve made. To troubleshoot, I first rigged up the little test circuit you see in the photo below and in the schematic above. It is an LED with a current-limiting resistor and a polarity-protecting diode, the free ends attached to two female headers. (continued below)

TESTS

(1) On the Quick2Wire boards there is a 3-pin male header with pins for 5V, 3.3V, GND. I attached the test circuit to 5V and GND — it glowed as it should. Same for 3.3V and GND. So I decided that the board was probably working.

(2) I left the black lead of the tester attached to GND, inserted a length of wire bared at each end into the other lead, and then into GPIO pin on the board labeled p0 on the board. This pin is one of a set of ten, labeled GND, p0, p1, …, p7, 3v3. Result with blink.py again: nada.

(3) I realized that I was confused about the various systems of pin numbering — GPIO, BOARD, Wiring Pi. So I modified blinktest.py to give the option of using any of the three systems:

   $ sudo python blinktest.py -g 18    # Blink LED on GPIO pin 18
   $ sudo python blinktest.py -w 1     # Blink LED on Wiring Pi pin 1
   $ sudo python blinktest.py -b 12    # Blink LED on RPi board pin 12

The code for blinktest.py is at github.

With the blinktest.py and the test circuit in hand, I discovered that (a) the Quick2Wire board uses GPIO numbering on the Python side but Wiring Pi on the labels of the GPIO pins; (b) The jumper LED_ENABLE determines whether Wiring Pi pin 1 or LED is active. (c) I could not get Wiring Pi pin 2 to blink the test circuit. I’ll try swapping out the RPi later to see if it is at fault.

Charts and info on GPIO pins: Raspberry Pi Spy

Mio for Raspberry Pi

Posted by epsilon on May 17, 2013

Posted in: Code, RPi-Arduino. Tagged: computer, gadgets, GPIO, project with one LED and one switch, python, raspberry pi, technology. Leave a comment

mio.py is “my” io library for Raspberry Pi. At present it is a kind of “hello world” program that demonstrates how work with one digital input, e.g., a switch, and one digital output, e.g., an LED. Below are (a) a photo of the Raspberry rigged up with a circuit managed by miO, (b) a description of the package, (c) some output on the command line, (d) a circuit diagram.

The (Python) code is at github.

(a) MIO RUNNING ON PI

(b) MIO: COMMAND SUMMARY

Suppose that LED is pin 17 and SWITCH is pin 23:

blink(LED, 0.1, 0.3) — blink LED, on for 0.1 second, off for 0.3 seconds
read(SWTICH) — read SWITCH: print 1 ON the first time it is closed, then the time it was held closed when it opens, then print 2 ON when it is closed the second time, etc.
control(LED, SWITCH) — control LED with SWITCH. This function is like read, except that the LED blinks when the switch is closed.

These functions can be invoked fromt the command line: (a) sudo python mio.py blink, (b) sudo python mio.py read, (c) sudo python mio.py control.

pi@raspberrypi ~/gpio $ sudo python3 mio.py read
    1 ON
      1.09
    2 ON
      1.75
    3 ON
      0.13
    4 ON
      0.11

(d) CIRCUIT DIAGRAM

Let the switch have terminals A and B.

   A --- 3.3V

              |--- 1K resistor --- Pin 23
   B --- T ---|
              |--- 10K resistor ---GND

   Pin 17 --- LED --- 330 Ohm resistor --- GND

Circle and Square

Art, Code, Music, Mathematics