Browsed by
Tag: Arduino

Sanntid hjemme: Følg Ruter hjemmefra med Arduino og Python

Sanntid hjemme: Følg Ruter hjemmefra med Arduino og Python

Sanntidsskjermene som Ruter har satt opp ved flere t-bane, trikk og bussholdeplasser har blitt et kjærkomment bidrag til informasjonen du som reisende får om avganger. Ikke bare kan du ha stålkontroll over hvilke avganger som går, og i hvilken rekkefølge, du blir også oppdatert om estimert ankomsttid slik at du vet at du mista bussen du løp for å rekke eller om bussen har blitt forsinka i rush-trafikken.

I tillegg til skjermene på holdeplassene som opplyser om sanntid, kan du få tak i app-er til mobiltelefonen og du kan også se dataene på forskjellige tredjepartsløsninger som f.eks på informasjonsskjermene ved Instiutt for informatikk ved Universitetet i Oslo. At dataene kan vises på mange forskjellige steder er mulig siden Ruter legger ut all ruteinformasjon til fri bruk (noen restriksjoner gjelder) på nettet. Det er dette vi kan benytte oss av når vi skal lage vårt eget sanntidssystem.

Informasjonsskjerm med sanntidsinformasjon

Vårt ferdige produkt vil være et sanntidssystem, ikke ulikt det man kan finne på holdeplassene. Selvsagt blir vårt produkt mindre robust og pålitelig, men i prototypings-fasen er dette helt greit. Skjermen skal vise hvilken linje neste avgang gjelder, hvilket navn det er på denne linjas endestasjon og hvor mange minutter det er til ankomst/avgang. For å få til dette benytter vi oss av en “dum” skjerm og av programvare som skriver teksten til denne. Skjermen vi bruker kobler vi til datamaskinen igjennom et Arduino grensesnitt. Vi bruker datamaskinen for å gjøre det meste av jobben, og vi legger mest mulig kompleksitet hit.

Informasjonsskjermen

Arduino er et veldig bra sted å begynne for å lære elektronikk, og hvordan vi kan kombinere dette med datamaskiner. Arduino har mange pedagogiske resursser tilgjengelig, og er laget for å være enkelt å komme igang med samt fleksibelt nok til å kunne skreddersys med egne komponenter.

Alle komponentene vi trenger følger med i Arduino innførings-pakke (Starter Kit). Vi tar utgangspunkt i oppgave 11, hvor vi skal lage en krystall-kule. Vi benytter oss av skjema-tegningene for å koble en LCD-skjerm til Arduino-brettet.

På Arduinobrettet laster vi opp følgende Sketch:

#include

LiquidCrystal lcd(12,11,5,4,3,2);

char a;

void setup() {
  Serial.begin(9600);
  lcd.begin(16,2);
  lcd.print("Ready for");
  lcd.setCursor(0,1);
  lcd.print("duty!");
}

void loop() {
  while (Serial.available() > 0 ){
    a = Serial.read();
    if (a == '!') {
      lcd.clear();
      lcd.setCursor(0,0);
    } else if (a == '?') {
      lcd.setCursor(0,1);
    } else {
      lcd.print(a);
    }
  }
}

 

 

Ardino-editor
Arduino-editoren

Vi benytter oss av LiquidCrystal biblioteket som følger med Arduino for å gjøre det enklere å skrive til brettet. Vi setter opp en Seriell-forbindelse og skriver en velkomstmelding til LCD-skjermen. Når LCD-skjermen er initialisert er det i hovedsak tre metoder vi benytter: print, clear og setCursor. Førstnevnte skriver en melding til skjermen, clear fjerner all tekst. setCursor benytter vi for å hoppe mellom skjermens to linjer. Metoden setCursor(0,0) setter skrivehodet øverst til venstre, og setCursor(0,1) setter skrivehodet til venstre i nedre rad.

Det er veldig lite kompleksitet på dette nivået, det eneste vi ønsker å gjøre er å kunne skrive, flytte mellom linjene og fjerne all tekst fra skjermen. Så lenge det er data i seriell-bufferet leser vi et tegn, og skriver dette til skjerm med mindre det er et spesialtegn. For dette programmet er “!” og “?” definert til å ha spesielle funksjoner. Utropstegnet fjerner all tekst og resetter skrivehodet til øvre venstre posisjon, spørsmålstegnet flytter skrivehodet til nedre venstre posisjon.

Skrive til skjerm

Når LCD-skjermen er satt opp og Arduino-koden er lastet opp kan man skrive til skjermen. Bruk CoolTerm (kan lastes ned her) og koble denne til Arduinobrettet (la brettet være koblet til via USB porten). Nå kan du skrive tekst som dukker opp på skjermen, samt kontrollere at spesialtegnene fungerer. Fungerer det? Kult, la oss koble oss opp mot Trafikanten/Ruter.

Trafikkdata fra Ruter

Ruter har offentliggjort mye av sin reiseinformasjon, og de har lagt ut sanntidsinformasjonen i tillegg til reiseplanleggeren, avvik og mye annet snasent. Les mer på Ruter sine API-sider

Vi skal benytte oss av to datasett fra Ruter, først må vi finne vår stasjons-ID ved hjelp av en kommaseparert fil med oversikt over alle stasjonene. Denne semi-statiske filen har meta-data som vi trenger for å kunne finne riktig stasjon fra REST JSON sanntids-APIet.

Finne stasjons-ID

For å finne riktig stasjon gjorde jeg en pragmatisk avgjøre om å ikke parse CSV-fila med alle stasjons-IDene. Jeg bare åpnet fila i TextMate (som jeg benytter for å redigere kode), og søkte etter Blindern T som ligger i nærheten av både jobb og hjem. Jeg fant ut Blindern T sin stasjons-ID er: 3010360

Hente og parse trafikkinformasjon

Oversiktlig, men maskinlesbar JSON strøm. Alle data vi trenger
Oversiktlig, men maskinlesbar JSON strøm. Alle data vi trenger

Ved å gå til datapunktet for sanntidsinformasjon ved denne IDen får jeg en JSON strøm/fil tilbake med alle avanger fra denne stasjonen: Blindern datapunkt.

I denne strømmen får vi mange objekter med avganger, og alle avganger har masse data vi kan bruke. JSON strømmen er ikke lett å lese og forstå, men så er den heller ikke laget for mennesker. Jeg benytter programmet VisualJSON for å lese JSON-filer.

Visual JSON is a handy tool for getting a more human readable representation of the data in the JSON stream
Visual JSON er et praktisk verktøy for å gjøre JSON-strømmer mer menneskevennlige

I VisualJSON kan vi se hvilke verdier i hver oppføring vi ønsker å ta vare på. DestinationDisplay inneholder navnet på endestasjonen, og LineRef inneholder linjenummeret. Praktisk å ta vare på disse. I tillegg trenger vi å lese ExpectedArrivalTime som har et noe merkelig tidsformat: “/Date(1378070709000+0200)/”.

Se hele implentasjonen? Mot slutten av siden finner du scriptet som henter, bearbeider, mellomlagrer og sender dataene skjermen.

Bearbeiding av datoene

De fleste dataene for hvert avgangsobjekt er klare for visning, men når det gjelder datoene trenger vi å gjøre noen endringer. Formatet vi fikk disse i er vanskelig å forstå for mennesker. Datamaskiner kan enkelt regne ut hvor mange sekunder som har passert siden torsdag 1 January 1970 (tidsformatet Epoch time), men for mennesker er dette vanskeligere. Vi parser derfor epoch formatet til datetime, og i fra dette formatet finder vi time delta (tidsdifferansen) mellom når avgangen er forventet og nå. Når vi tar denne tidsdifferansen og gjør den om til minutter har vi antall minutter til avgangen som vises.

Mellomlagring av data

Jeg har valgt å lage en klasse som inneholder de nødvendige dataene for hver avgang. Objektene vi oppretter av denne klassen legger jeg inn i en liste, hvor jeg henter ut ett og ett element. Når lista er tom går jeg til nett-tjenesten for å hente nye data. Det er fint å slippe å gå til tjenesten hele tiden for å hente data, samtidig må vi også bli oppdatert på eventuelle forsinkelser eller dersom antatt ankomsttid skulle flyttes framover i tid. Jeg syntes at å lagre alle avgangene i en kø for så å hente nye data når denne er tømt er en god løsning på denne utfordringen.

Formatere data for LCD-skjerm

For at dataene skal vises riktig må vi formatere de. Måten jeg har valgt å gjøre dette på er ved å lage setninger for hver linje. Altså først sende en melding om at skjermen må tømmes og resettes, deretter øverste linje med linjenummer og endestasjonsnavn. Når dette er sendt, venter jeg 0.2 sekund før jeg sender linjeskift-kommandoen (“?”), og linje nummer to. Jeg venter 0.2 sekunder mellom hver melding for å ikke mate skjermen med for mye informasjon samtidig. Når all tekst vises lar jeg denne stå i 4 sekunder før jeg går videre til neste avreise.

Implementasjon av programvaren

Nedenfor finner du hele scriptet som henter data fra Ruter, og som sender dette til Arduinobrettet

import urllib2, json, datetime, re, serial, time
from pprint import pprint

class TrafficInfo:
  def __init__(self, line_ref, destination, arrival_minutes, monitored, platform):
    self.line_ref = line_ref
    self.destination = destination
    self.arrival_minutes = arrival_minutes
    self.monitored = monitored
    self.platform = platform


def days_hours_minutes(td):
  return td.days, td.seconds//3600, (td.seconds//60)%60

def fetchTrafficFromStation(station_id):
  url_loc = "http://reis.trafikanten.no/reisrest/realtime/getrealtimedata/%s" % station_id
  response = urllib2.urlopen(url_loc)
  data = response.read()
  return data

station_id = "3010360"
ser = serial.Serial("/dev/tty.usbmodemfa131", 9600)
arr = []

while(True):
  if len(arr) == 0:
    print "Fetching new data"
  data = json.loads(fetchTrafficFromStation(station_id))

  for el in data:
    timecode = el["ExpectedArrivalTime"]
  m = re.split("(\d{13})\+(\d{4})",timecode)
  dt = datetime.datetime.fromtimestamp(float(m[1])/1000)
  tn = datetime.datetime.now()
  d = dt - tn
  td_human = days_hours_minutes(d)
  minutes = False
  if (d.seconds < (3600 - 1)): minutes = td_human[2]
    ti = TrafficInfo(el["LineRef"], el["DestinationDisplay"], minutes, el["Monitored"], el["DeparturePlatformName"])
  arr.append(ti)

  time.sleep(1)
  ar = arr.pop(0)
  time.sleep(1)
  ser.write("!")
  time.sleep(0.3)
  over_str = "%s : %s" % (ar.line_ref,ar.destination)
  ser.write(over_str)
  time.sleep(0.3)
  ser.write("?")
  time.sleep(0.3)
  under_str = "%s %s" % (str(ar.arrival_minutes), "Minutes")
  ser.write(under_str)
  time.sleep(4)

 

 

Du trenger ikke nødvendigvis en LCD-skjerm for å hente trafikkdata fra Ruter, og du trenger ikke nødvendigvis å vise trafikkdata dersom du har en LCD-skjerm. Det er bare fantasien som setter grenser. Hva med for eksempel værdata fra yr.no, eller temperaturen i kjøleskapet? Arduino er et flott sett for å leke med noen av mulighetene elektronikk og informatikk gir deg.

Appropos Arduino: I forrige uke var jeg med på en workshop med Tom Igoe, som har skrevet boken Making things Talk. Jeg har selv ikke lest denne boka, men har hørt at den er en god kilde til kunnskap og inspirasjon. Check it out!

Workshop Weekend: Timelapse

Workshop Weekend: Timelapse

A month ago I had a little workshop weekend where I built an electronic camera controller using a relay and an Arduino, this weekend it was about time to try it out.

What do you need to make a time lapse? Well, the most important thing is the camera. No camera, no pictures, no time-lapse. In addition you should find somewhere (location) with an OK view and a motive where some changes are bound to occur over a longer amount of time than normally. One of the reasons to do a time lapse shoot is to convey a temporal understanding which cannot be understood through a 1:1 time frame. On one hand we can see the tiny details making up a whole macro movement when we shoot a video in extreme slow motion (the opposite of time-lapse), or we can see things which normally occur over a long time span in a shorter presentation. Both these changing of time is one aspect discussed after the introduction of photography and cinematography. No longer were the possibility to document the present limited to painting canvas, it was moved to the domain of mechanical reproduction. Utilizing this we could learn more about the world. The photography did not just change the temporal realm, also the spacial changed: Tiny thing could be viewed as large (electron microscope), big thing could be viewed as small (as in satellite photos). To exemplify the temporal realm exposed to video I’ve added two different movies below. The upper video presents a short amount of time in a long time span, and the other video shows the opposite: A long amount of time presented in a short amount of time

[vimeo]http://vimeo.com/19819283[/vimeo]
[vimeo]http://vimeo.com/18792120[/vimeo]

Pretty cool, right! Well, the first video is shoot on a Phantom Flex which is a pretty amazing camera able to do an impressive amount of exposures each second, but unless you have lots of money to spend on one of those you have to be happy with something which shoots at one third of the Flex’s speed or less. The good news is that making a video like the second can be done with more affordable equipment, so it may be no surprise that I went for the time-lapse function. Here is the result:

[vimeo]http://www.vimeo.com/20725917[/vimeo]

This video is shoot between 5ish and until around 7.30 from the School of Informatics’ offices in the top floor of Appleton Tower in Edinburgh. The presentation lasts from 23 seconds, and shows the view toward McEwan Hall with the old town and the castle in the background. The movement in the frame was unintended, but happened as my tripod (which is 5 cm high) was gaffed to a metal pole close to the window and probably the result of a weak construction with force created by the shutter. In the beginning I shot a picture every 30th, then every 20th and then finally every 10th second. The latter is the frequency which most of the movie is shot, and only a couple of frames are in 30 and 20 second intervals. If you go for a 10 second exposure you will get 360 pictures per hour.

Creating many pictures is not enough; they have to be compiled together into a video file. I did this in a two-step procedure, first by resizing and renaming the files. This was done by a Python script you can find beneath the article. The second thing to do was to make the pictures into a video. As you probably know, the illusion of motion picture is nothing more than still pictures in an ordered sequence running at a higher speed than the absorbance rate of the eyes (and the rest of the cognitive apparatus). The video frame rate here is around 20 pictures per second. The frame rate and the commands to the mencoder encoder are fixed with a shell script from Mario Valle (mencoder.sh) with some modifications to fit the name structure generated by the Python script.

Well, it was very fun setting up the equipment, and the photography process is done without the help from human hand and the result is done almost by itself, so I hope to get more videos of Edinburgh running at a high pace.

The resizing Code

#!/usr/bin/python
import os
import sys
import Image
import re
# You need to create a folder called zepics a subfolder to the executive folder of this script
# The pictures you want to transform has to be in same folder as the script
width = 1290
height = 864
ext = ".jpg"
counter = 0
path = os.getcwd()
dirList=os.listdir(path)
dirList.sort()
for fname in dirList:
if (re.search(".JPG", fname)):
print("Resizing image: "+fname)
im1=Image.open(fname)
im2 = im1.resize((width, height))
tempcounter = 100000 + counter
im2.save("zepics/img"+str(tempcounter) + ext)
counter = counter + 1
else:
print "I could not resize: "+fname

The Arduino Code

int ledPin = 2;
void setup() // run once, when the sketch starts
{
pinMode(ledPin, OUTPUT);
}
void loop()
{
digitalWrite(ledPin, HIGH);
delay(500);
digitalWrite(ledPin, LOW);
delay(10000);
}

The remote controller:

The prototyping board:

Update 21. March

Here is another time lapse video shot from the top of the Appleton Tower, this time the skies are documented. Interestingly did we not see much movement of the skies in chronological clock time, but with a shot taken each 7th second, the movement are clearly visible

[vimeo]http://www.vimeo.com/21238949[/vimeo]

Electronic Workshop Weekend: Arduino

Electronic Workshop Weekend: Arduino

After an inspiring lecture on circuit bending and electronics held by Edinburgh based digital artist Yann Seznec last week I decided to try something new. In this lecture we looked at some interesting possibility in using electronics separately and in combination with computers. This seemed like an interesting domain to check out, so I ordered some electronic components and an Arduino to play with the ideas from the lecture to learn more about it.

Perhaps the most interesting part is that electronics offer us to work at a lower abstraction level than the computer. Another advantage is the alternative inputs and outputs you can use in combination with projects in everything from low level C to high level Max MSP.  Hearing a relay click or to see some simple LEDs blinking gives a feeling of mastery on the same level as sorting algorithms and searching through huge databases, and by getting it to communicate with the computer you can experiment beyond the limits of the sandbox provided in the computer. Why not let a variable in the program be dependent on the temperature in the room, or on the amount of light? Or you can turn it around and let the result of your last budget result in a green or a red lamp blinking. Or maybe you want the number of visitors of your webpage be represented by the frequency of a tune from a speaker. Maybe you want to combine it together with the power of the Internet to take a picture each time your alarm clock goes off and publish this using Twitter or surveillance the toaster through its own blog where it will put a new post as the toast reach for the sky? Well, you have the opportunity.

The most obvious difference from playing around with computers is that the electronic components are physically alterable and the real deal; no surprise, but it has implications. If you simulate a higher voltage than expected or connect something the wrong way in a computer program the worst thing that would happen is that the program prompt a catched error or maybe an infamous null pointer exception. Dealing with real voltages and circuits, the components can bust, but if you make sure not to use anything really powerful and read the instructions when you use more complicated components such as micro controllers you should be OK.  The set I bought contained several components, and endless opportunities. In the beginning I tried to get a LED to flash and to gather input from the photo sensor, but with time and training I was able to do some more advance stuff, and in the end of a long day I managed to controll the time between each exposure on my DSLR (great for time lapse).

The interface between the computer and the components is the Ardurino. This is a little blue board with some analog ports, some digital ports, an USB connector and a power inlet. It is running on open source software downloadable from the homepage. The program is very similar to Processing, and has the opportunity to compile and upload the code, and to receive messages sent from the board. The board can run alone with software uploaded and using the ports on the board you can make small programs, meaing that you don’t need to have it hooked up to the computer to play around. If you want to use wireless technology or controll the board using Ethernet there are shields supporting Bluetooth and RJ45 Ethernet connections available. You can also get smaller components with Ardurino loader if you want to bring with you the logic programmed away from the little blue board.

There is a wide variety of components, and they all have their distinctive features and functions.Measuring temperature, light, radon level, speed, direction, proximity, RFID tags, taking pictures, well you find all kinds of components to hook up, and if you don’t want to buy new, you can always reuse your old toys, as in this video.

As we know from electric and electronic theory, the whole play is about getting the electricity from plus to minus and in between the polarities we can play around. The electricity will find the shortest path in terms of resistance, and the circuiut has to be complete to work. One of the easiest circuits are made by connecting an outlet from one of the digital ports through a LED, further through a resistor and then to ground. The lamp will be switched on when the port is set to high, and accordingly switched off when the port is set to low. This can be realized using the digital port (0 or 1, off or on), but using the analog ports the Arduino can address the lamp with a signal between 0 and 255 (a byte instead of a bit), which makes it possible to dim or to set it to a value in between the 0 and the 1. The repspective ports can be set at both input and output, and this is done really easy through methods in the Arduino “language”, there are also many libraries to do everyting from utilizing advance components with the board to sending messages to different software.

I have created a folder here, where I will put up some source code as I try out different things. I will also see if I can get up some sketches of the components as well. Until further, here are some pictures taken while playing around.