Below are examples of messages shown on the screen during operation

System Up (Unfortunately I didn’t get a picture of this message)

Shows the unit waiting to get a wi-fi connection and get given an IP address.

Unit goes to the HPR site and gets the number of days to free slot in the show queue. At the time when I took the picture the queue had a healthy 22 shows!

Links to three previous shows I did that mention the Blinkstick

Solving a problem I had with my Blinkstick

http://hackerpublicradio.org/eps.php?id=2089

Tracking the HPR queue using python and a Blinkstick

http://hackerpublicradio.org/eps.php?id=2340

Follow on to HPR2340 (Tracking the HPR queue in Python)

http://hackerpublicradio.org/eps.php?id=2344

Link to Moc, Music On Console

https://moc.daper.net/

Menu 0 Podcasts screens

0 [PODCASTS]

0 1 <|| PLAY/PAUSE (Toggles moc between play and Pause)

0 2 << INFORMATION(Displays information about the current track)

0 3 << (Move to previous track in playlist)

0 4 << (Move to next track in playlist)

0 5 LIGHT (Toggle back-light on LCD screen)

PUSH IN TOP TOGGLE BUTTON (Seek forward or back in current track)

Menu 1 Audiobooks screens

1 [AUDIOBOOKS]

1 1 <|| PLAY/PAUSE (Toggles moc between play and Pause)

1 2 << INFORMATION(Displays information about the current track)

1 3 << (Move to previous track in playlist)

1 4 << (Move to next track in playlist)

1 5 LIGHT (Toggle back-light on LCD screen)

PUSH IN TOP TOGGLE BUTTON (Seek forward or back in current track)

Menu 2 System screens

2 [SYSTEM]

2 1 Sys Information (System information)

2 2 WiFi (Displays WiFi inofrmation such SSID & signal strength)

2 3 HPR (Displays the number days to the next free slots on FPR que)

2 4 Not shown, (Not in use)

2 5 LIGHT (Toggle back-light on LCD screen)

PUSH IN TOP TOGGLE BUTTON (Shut-down the Raspberry Pi)

Infra-red Sensor

Example of my Samsung TV remote control

Lirc Article from Wikipedia

https://en.wikipedia.org/wiki/LIRC

Infra-red sensor turned on

Infra-red sensor turned off

This episode is Part 8 of the Stardrifter role-playing game playtest. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this part, the characters reevaluate their life choices, and decide that negotiation is the better part of valor!

Special thanks to my playtesters: Thaj, Mark (who was playing Brinn), and X1101!

In this episode, Dave and his family wander the paths of Sandall Beat Wood in Doncaster to participate in the game of Geocaching. During this time, which demonstrates an unusual level of failure in us playing the game, we try and explain what the game is all about.

No, not The Game...

As I explain at the beginning of the episode, this is a fairly long episode which hasn't been edited down much, so there are a lot of ambient pauses and heavy breathing to be enjoyed.

Recorded in the field on my Olympus DM-3 voice recorder.

Caches explored

Cache 1 - GC7F8ND - not found

Cache 2 - GC50TVW - not found

Cache 3 - GC7KRHH - found!

Links

Link to photos and screenshot

geocaching.com

Official Geocaching App: Google Play | App Store

c:geo Geocaching app: Google Play

MeWe is another platform that was advertised to users left high-and-dry by the closure of Google Plus. It is not federated, but does make strong claims of privacy protection, and is the slickest alternative I have seen to Google Plus. So when Google Plus disappeared, many people moved over to this platform. https://www.zwilnik.com/?page_id=1030

Links:

https://mewe.com/

https://mewepro.com/

https://mewe.com/store

https://mewe.com/#

https://www.zwilnik.com/?page_id=1030

#!/usr/bin/env python

import urllib.request

import json

import re

import subprocess

# see https://www.weather.gov/documentation/services-web-api

#where are we? GPS coordinates

lat = 39.275235

lon = -120.9199507

#what is the user agent string?

agent = "Jezra's fun lil script"

#minimum wind speed in mph?

min_speed = 9

def get_api_data(endpoint):

print(endpoint)

#prepare the connection with custom headers

request = urllib.request.Request(endpoint, headers={"User-Agent":agent})

#create a handler for the request

handler = urllib.request.urlopen(request)

#get the text

text = handler.read()

#parse the json text to a python object

obj = json.loads(text)

return obj

def wind_is_good(s):

#use regex to find the matches

matches = re.findall("[0-9]+",s)

for match in matches:

#convert string to int

m = int(match)

#is the speed good?

if(m>=min_speed):

return True

#if we get here, there is no match :(

return False

start_url = "https://api.weather.gov/points/{0},{1}".format(lat,lon)

#get the json response from the start_url as a python object

obj = get_api_data(start_url)

#get the forecast url from the returned data

forecast_url = obj['properties']['forecast']

# process the forecast url

forecast = get_api_data(forecast_url)

#loop through the forcast periods

for period in forecast['properties']['periods']:

#put name and windspeed into easier to handle variable names

name= period['name']

wind = period['windSpeed']

print (name, wind)

#check the wind speed

if wind_is_good(wind):

subprocess.call(["textjezra","{0}: {1}".format(name,wind)])

Intro

We’re going to have a look how to select random item from weighted list. There isn’t that much code this time, but it certainly took many tries to get it working and looking nice.

Analogy

Imagine stack of building blocks of different heights stacked on top of each other. Height of the each block is chance of how often it will be selected. Selection is done by chopping a stick so that its length at maximum is height of the stack. Place stick next to the stack and select the block that stick reaches at.

Explanation of algorithm

We have list of items and associated weight, defined as Frequency a = Frequency Int a.

Total is sum of all the weights and we select a random number n between 1 and total.

pick function has signature of [Frequency a] -> n -> Maybe a. Empty list will result Nothing. When picking item, if n is equal or less than weight of the first item, return that item. Otherwise, drop the first item, subtract weight of that first item from n and try again. Eventually we either arrive to item which weight is greater than n or to empty list.

Quick detour on random number generators

Haskell functions are pure, meaning that with same input, you are guaranteed to get the same output (safe for some specific cases). Which makes concept of random numbers at first glance to be impossible. This is solved by passing in a random number generator, which can supply you a random value a new random number generator. Using this new random number generator to generate a value yields you a yet another value and yet another random number generator.

Passing these random number generators around in code gets tedious, but there’s different solution: MonadRandom. Using it will thread along generators automatically behind the scenes, ensuring that you always have access to a fresh generator. There’s several functions that can be used to generate random values, but we’re using this one: getRandomR :: Random a => (a, a) -> m a. Given a lower and upper bound, it will return you a random value wrapped in context that carries that new random number generator.

In the end, we need to take our computation (that can be complex and use multiple calls to random number generator) and turn that m a into a. This is done with runRand :: RandomGen g => Rand g a -> g -> (a, g). We give it our computation and a RandomGen g that can generate random values and receive (a, g) where a is our result and g new random number generator. In cases where we aren’t going to use the new generator, we can use evalRand :: RandomGen g => Rand g a -> g -> a, which discards it and returns just a.

Actual implementation with explanation

First, Frequency for expressing weight of individual item. It’s parametrized, so can be used with any data.

data Frequency a = Frequency Int a

deriving (Show, Read, Eq)

Next, determining which item to choose, based on stack and measuring stick. In case a value outside of valid range has been selected, we end up with Nothing, otherwise with Just a. First case is for empty list (either we called this originally with empty list or picked number that is greater than total sum of weights), second one either picks the first item of list or recursive calls itself removing first item.

pick :: [Frequency a] -> Int -> Maybe a

pick [] _ = Nothing

pick (Frequency x item:xs) i

| i <= x = Just item

| ot

This episode is Part 7 of the Stardrifter role-playing game playtest. The series is composed of two playtest sessions, held earlier this year. They were recorded and chopped into manageable bites, then edited down into separate episodes.

This series is meant to give listeners some insight into the RPG construction process. Playtesting is not the final step, but rather, just another stage. The construction of an RPG can be convoluted, and feedback from players is absolutely vital.

In this part, the characters make some new friends who show them their guns! Bonus Fun: I make tons of mistakes reading my own rules!

Special thanks to my playtesters: Thaj, Mark (who was playing Brinn), and X1101!

table td.shrink {

white-space:nowrap

}

New hosts

There were no new hosts this month.

Last Month's Shows

Id

Day

Date

Title

Host

2891

Mon

2019-09-02

HPR Community News for August 2019

HPR Volunteers

2892

Tue

2019-09-03

Stardrifter RPG Playtest Part 02

lostnbronx

2893

Wed

2019-09-04

Whats in the box! Part 2

NYbill

2894

Thu

2019-09-05

Repairing a Musical Instrument Case

Jon Kulp

2895

Fri

2019-09-06

The work of fire fighters, part 2

Jeroen Baten

2896

Mon

2019-09-09

Orange PI Zero LTS version

JWP

2897

Tue

2019-09-10

Stardrifter RPG Playtest Part 03

lostnbronx

2898

Wed

2019-09-11

Modeling people in space game

tuturto

2899

Thu

2019-09-12

Endeavour OS

Tony Hughes AKA TonyH1212

2900

Fri

2019-09-13

Better Social Media 01

I discuss loading Fedora on various bits of older hardware and devise a plan to turn one of those bits of older hardware into a dedicated headless audio processor using its firewire port to keep yet another older piece of hardware alive: a Yamaha GO46 audio interface.

Having done that and finding that it all performs admirably, I illogically decide to replace it with newer (but not new) hardware and buy yet another different model firewire audio interface: a Focusrite Saffire Pro 24.

I record the end of the show on audio interface #3: a USB based Steinberg UR22mkII, which one could argue that I should have been using all along, leaving the firewire gear in the last decade where it belongs (?).

PiFace Control and Display

http://www.piface.org.uk/products/piface_control_and_display/

How to fit, setup and install the required software for your Raspberry Pi running the Raspbian Operating system

http://www.piface.org.uk/guides/setting_up_pifacecad/fitting_PiFace_Control_and_Display/

Pictures 01, 02 and 03 show how the PiFace Control and Display board and raspberry pi fit into the case

Pictures 04 and 05 shows the piece of plastic used to transfer the light from the LED’s on the Pi board to the holes in the casing. This is supposed to allow you to monitor the PI LED’s. I held it in place using a piece of Blu Tack.

Wikipedia article about Blu Tack

https://en.wikipedia.org/wiki/Blu_Tack

Picture 6 shows the completed box

Pictures 7 and 8 show the project in operation and mounted on a spare Anker tablet stand that I had lying about.

This is an example of the Anker stand I used. I use it to hold my project at a 45 degree angle so I can see it from around the room, it is intended to be used as a tablet stand.

Anker stand for my Nexus 7, pictures, links