Previously I wrote about using a Raspberry Pi to receive 433MHz signals from a WH1080 weather station. This is the mess of wiring I came up with:
This worked fine until it stopped. I probably didn’t crimp a wire properly and too many knocks resulted in unreliable operation. To solve this I designed a PCB that connects the radio receiver, pressure sensor and an antenna to a Raspberry Pi:
The design is very simple:
It accepts a surface-mount version of the RMF01 module (the version with a black resin blob). This is easily soldered onto the PCB by hand.
A female through-hole SMA connector is used for the antenna connection. This allows a range of off-the-shelf antennas to be used. The one I purchased from eBay didn’t work so I modified it as can be seen in the pictures. Alternatively a wire can be directly soldered to the board.
Finally a six pin BMP085 module is connected to a header. The pinout of the BMP085 module used is:
- Pin 1 = 3.3V
- Pin 2 = SDA
- Pin 3 = SCL
- Pin 4 = No connection
- Pin 5 = No connection
- Pin 6 = Ground
Here is how the PCB looks when populated:
Download the schematic diagram (15MB).
I have some spare boards, so if you would like one to experiment with please contact me.
Update: All the spare boards are gone. I hope everyone who received one has a lot of fun with them!
Here are the gerber files, suitable for submitting to a PCB house. The license is CC-BY-NC SA. I.e. for personal non-commercial use only. Sorry, but I am unable to provide support for these files.
Sometimes it is useful to cover vias with solder mask. Here is how to do it in DesignSpark PCB. First the solder mask with the vias exposed:
1. Choose Design Technology… from the Settings menu
2. Click on the Solder Mask row and then the Edit… button
3. Uncheck the Vias setting and click on OK.
4. Click on OK to close the dialog window.
At this point the solder mask should automatically update to show the vias are now covered. If it doesn’t deselect the layer and reselect it to force a refresh.
This tutorial demonstrates how to create a library of parts in a CAD neutral format based on a single template part. It takes advantage of parameterization in Geomagic Design.
We will start by creating the base part that we will use to create the library. This will be a simple cap head bolt.
Next we will use WizoScript to generate a library of 10 bolts of different lengths.
This type of task is ideally suited to scripting because it handles the tedious repetitive operations needed. While the part demonstrated in this tutorial is simple the same principles can easily be used for complex parts with multiple parameters.
Creating the Template Part
In Geomagic Design create a new part and then a sketch on the XY-Plane. On this sketch draw a circle centered on the origin with a diameter of 4mm and then extrude into a cylinder with a length of 10mm.
Under the Viewing and Analysis tab click on the Equation Editor button.
Double-click on “D2” and enter “Length” to give the length of the bolt a useful name then close the equation editor window.
Create the bolt head by adding a sketch to the end of the cylinder on the XY-Plane, setting the diameter to 8mm and extruding 4mm.
Create a new sketch on the top of the bolt head, draw a hexagon with an inside diameter of 4mm and then extrude cut 2mm.
Create a new folder called “PartLibrary” and save as TemplatePart.AD_PRT. Keep the part open in Geomagic to continue with the tutorial.
Writing a Basic Script
Start WizoScript 1.70 or later. When it runs it automatically creates an empty script that we can start using right away.
First we need to tell the script about our template part. For this tutorial the part must be open in Geomagic when the script runs, however it is possible to use a saved part that is not currently open. Please see the WizoScript reference manual for further details.
The following script line tells WizoScript “I have a part open and I want you to use it”:
TemplatePart = Part(“TemplatePart”, False)
Next we need to get access to the length parameter that we have already created it. Once we have access to it we can change its value
Length = TemplatePart.GetParameter("Length")
The default units for a script are millimeters, so if we enter the following:
Length.Value = 10
Then we are setting the length of the bolt to 10mm. Enter this into the script.
Now that we have set the length of the bolt we need to export it in a CAD-neutral formal so it can be shared with others. Here is how to do it:
This is what you should have so far:
Save the script and click on the Run button. If there are any errors correct them in the script and try again. If the script is successful you should now have a M4-Bolt-10.stp file.
Generating Multiple Parts
So far it’s not very interesting. We’ve generated a single STEP part that we could have easily created directly in Geomagic Design without needing scripting. Now we will look at generating multiple parts in one go.
The first step is to create a function that is given a length and creates a STEP file. A function is a way of grouping parts of a script together so they can be run over and over again. Edit your script to look like the following:
def GenerateBolt(NewLength): Length.Value = NewLength TemplatePart.ExportSTEP214("C:\Users\Andy\Desktop\M4-Bolt-"+str(NewLength)) TemplatePart = Part("TemplatePart", False) Length = TemplatePart.GetParameter("Length") GenerateBolt(10) GenerateBolt(12)
We now have a function called GenerateBolt that takes a length and creates a STEP file. The function has to be defined before it is used so put it at the start of the script.
Another key change is that the name of the STEP file contains the length, whatever that may be. This is achieved by appending “M4-Bolt-“ with the length value.
Run the script. It will call GenerateBolt twice and create two STEP files containing a 10mm bolt and a 12mm bolt.
The final step is to create a loop that goes from a minimum length to a maximum length creating bolts. Replace the two calls to GenerateBolt with the following:
MinimumLength = 10 MaximumLength = 20 for NewLength in range(MinimumLength, MaximumLength + 1): GenerateBolt(NewLength)
Run the script and it will generate bolts with lengths from 10mm to 20mm.
Here is the final script with comments added to explain:
# Takes a template bolt and creates a library of bolts of different lengths in # a CAD neutral format # Creates a bolt of a specific length. NewLength = desired length of bolt in mm # Saves the bolt to the desktop as a STEP file def GenerateBolt(NewLength): Length.Value = NewLength TemplatePart.ExportSTEP214("C:\Users\Andy\Desktop\M4-Bolt-" + str(NewLength)) # Get access to currently opened part that we will used as a template TemplatePart = Part("TemplatePart", False) # The template part has a Length parameter defined which we will control Length = TemplatePart.GetParameter("Length") # Create bolts from 10mm to 20mm MinimumLength = 10 MaximumLength = 20 for NewLength in range(MinimumLength, MaximumLength + 1): GenerateBolt(NewLength)
The Cooke Triplet is a system of three lenses designed in the 19th century to reduce distortion. In 1950 a specific triplet was invented and patented by Eastman Kodak (EF=100mm, f/1.9) and we will look at how to recreate it in Geomagic Design using scripting. We will create a script that can generate any type of thick lens, including how to solve the lensmaker’s equation. Hopefully the techniques demonstrated here will be useful to others solving and creating mathematical shapes in Geomagic Design.
Download, install and run WizoScript 1.70 or later. Start Geomagic Design. This script was tested with version 220.127.116.1190.
First we must enable a couple of useful libraries and make sure our script is using millimeters to match the values in the patent.
import sympy from sympy import * import math Units.Current = UnitTypes.Millimeters
We are going to generate three lens parts and save them so we need to specify a location to save to. Change this to make your PC.
OutputFolder = "P:\\temp"
The patent completely describes the three lenses but we are going to make it a bit more interesting by calculating the radius of the back of the lens from the focal length. To do that we need to use the lensmaker’s equation.
In the formula the radius of the back of the lens is R2. This appears in two locations in the formula. We could rearrange it to give us R2 = … but that is a bit tedious. Instead we can leave WizoScript to worry about it instead. Here is how we enter the equation into the script using ‘rb’ to represent the radius of the back of the lens.
# calculates the back radius of a lens based on the other parameters # uses the lensmaker's equation def GetBackRadius(FrontRadius, Thickness, RefractiveIndex, FocalLength): rb = Symbol('rb') Equation = Eq((RefractiveIndex-1)*((1/FrontRadius)-(1/rb)+(((RefractiveIndex-1)*Thickness)/(RefractiveIndex*FrontRadius*rb))),(1/FocalLength)) # we don't bother rearranging the equation, instead we let the sympy module do that for us BackRadius = solve(Equation) return BackRadius
WizoScript rearranges the equation and calculates the value we need using the single line:
BackRadius = solve(Equation)
The equation is placed into a function called ‘GetBackRadius’ which calculates the value when given a set of parameters, such as the thickness of the lens, refractive index of the material, etc. We can call the function repeatedly for different parameters.
Now we need to start creating a part for a single lens. First we tell Geomagic Design to create a part. We are going to do that in a new function.
# creates a part representing a lens based on a set of parameters def GenerateLens(Name, Folder, FrontRadius, Thickness, RefractiveIndex, FocalLength, Diameter): # get missing parameter BackRadius = GetBackRadius(FrontRadius, Thickness, RefractiveIndex, FocalLength) # check diameter is small enough if Diameter > abs(FrontRadius): print "%s diameter is larger than the front radius %f" % (Name, FrontRadius) return if Diameter > abs(BackRadius): print "%s diameter is larger than the back radius %f" % (Name, BackRadius) return # create new part Lens = Part(Name)
The general approach we will take is to draw a 2D profile of half of the lens on the XY plane and then create a revolve boss around the X axis. The X axis is the optical axis (i.e. the center of rotation for the lens).
# start creating the 2d sketch representing the shape of the lens Profile = Lens.AddSketch("Profile", Lens.GetPlane("XY-Plane")) LensRadius = Diameter / 2.0
First we will draw the front of the lens. There are three possibilities, the front is flat (infinite radius), bulging out aka convex (positive radius) or indented aka concave (negative radius). We treat each case individually. Simple trigonometry is used to calculate the end points of the front. Note that infinity is represented in the script by ‘oo’.
# draw shape of the front of the lens, it can be flat, convex or concave if FrontRadius == oo: FEndX = 0 Profile.AddLine(0, 0, FEndX, LensRadius, False) elif FrontRadius > 0: Angle = asin(LensRadius / FrontRadius) FEndX = FrontRadius - (cos(Angle) * FrontRadius) Profile.AddArcCenterStartEnd(FrontRadius, 0, FEndX, LensRadius, 0, 0, False) else: FrontRadius = -FrontRadius Angle = asin(LensRadius / FrontRadius) FEndX = (cos(Angle) * FrontRadius) - FrontRadius Profile.AddArcCenterStartEnd(-FrontRadius, 0, 0, 0, FEndX, LensRadius, False)
The back of the lens is treated in the same way except the sign of the radius is reversed. This means that a convex shape is a negative radius and a concave shape is a positive radius.
# draw shape of the back of the lens, it can be flat, convex or concave if BackRadius == oo: BEndX = Thickness Profile.AddLine(Thickness, 0, BEndX, LensRadius, False) elif BackRadius < 0: BackRadius = -BackRadius Angle = asin(LensRadius / BackRadius) BEndX = (cos(Angle) * BackRadius) - BackRadius + Thickness Profile.AddArcCenterStartEnd(Thickness - BackRadius, 0, Thickness, 0, BEndX, LensRadius, False) else: Angle = asin(LensRadius / BackRadius) BEndX = -(cos(Angle) * BackRadius) + BackRadius + Thickness Profile.AddArcCenterStartEnd(Thickness + BackRadius, 0, BEndX, LensRadius, Thickness, 0, False)
Before we can add the revolve boss we must make sure the sketch is closed by drawing the line for the outside of the lens and the line along the optical axis
# check diameter of lens again if FEndX > BEndX: print "%s diameter is too large" % Name return # if this is not a "thin" lens then draw top of profile if FEndX != BEndX: Profile.AddLine(FEndX, LensRadius, BEndX, LensRadius, False) # draw line of profile along x axis (optical axis) Profile.AddLine(0, 0, Thickness, 0, False)
Now for the revolve boss.
# create lens by revolving sketch around x axis Lens.AddRevolveBoss("Lens", Profile, Lens.GetAxis("X-Axis"), 360.0)
Creating two reference planes for the front and back of the lens will help with aligning them to create the triplet. Finally we save and close the part.
# add reference planes to aid in aligning this lens with others Lens.AddPlane("Front", Lens.GetPlane("YZ-Plane"), 0); Lens.AddPlane("Back", Lens.GetPlane("YZ-Plane"), Thickness); # save and close Lens.Save(Folder) Lens.Close()
The last step is to generate the three lenses needed for the triplet using the values from the patent along with the focal length.
# lens 1 GenerateLens("Lens1", OutputFolder, 62.63, 25.56, 1.745, 73.2, 40.0) # lens 2 GenerateLens("Lens2", OutputFolder, -66.47, 4.51, 1.647, -37.74, 36.0) # lens 3 GenerateLens("Lens3", OutputFolder, 119.5, 19.92, 1.697, 54.88, 30.0)
The complete script can be obtained from the script library. Running it will generate three part files, one for each lens.
Create a new assembly and add the three lenses in the order lens1, lens2 and lens3. Align the X axis of all three lenses. Align the front plane of lens2 7.89mm from the back plane of lens1. Align the front plane of lens3 14.14mm from the back plane of lens2.
This mini tutorial shows how to generate custom Mobius strips with minimum effort. It demonstrates that python scripting can be used to ask the user for information and then apply it to a part the user is already working on. Hopefully that will be useful to some people when solving problems.
1. Download and install WizoScript 1.70 or later and start it.
2. Start Geomagic Design V16 hotfix 1 (18.104.22.16890) or later.
3. Create a new part and set the units to millimeters.
4. Create a new sketch on the XY plane.
5. Draw a triangle centered on the X axis and set the size of the reference circle to 10mm.
6. Set the center of the triangle 30mm from the origin and exit sketch editing mode.
7. Go to the WizoScript script library and copy the Interactive Mobius Strip Generator. Paste it into WizoScript. Hint: double-clicking on the script in the web-page selects the entire script.
8. Run the script.
9. You will be asked for the name of the part. Assuming you haven’t saved it enter “New Part (1)”. Then you will be asked for the name of the sketch. Enter “Sketch<1>”.
10. Next you will be asked the rotation point along the X axis. Enter “30″. This puts the rotation point at the center of the triangle.
11. You will be asked for the number of rotations. This is the number of times the mobius strip will completely rotate. Enter “3″.
12. Finally you will be asked to enter the number of steps. Enter “30″.
Now the mobius strip will be generated. Be patient as this can take several minutes. Here is what you should have:
Now it’s time to experiment! You can change the shape of the sketch to create different effects. Setting the rotation point closer or further away from the origin will create a “corkscrew” effect. You can increase or decrease the number of rotations. Reducing the number of steps will make the part faster to create but you might have to manually add a guide curve to get a true mobius strip.
Using this script it is possible to run it multiple times on the same part. For example create two sketches, run it on the first sketch and then run it on the second sketch to create two Mobius strips that are intertwined.
I think the jury is still out on the wind vane that comes with WH1080 weather stations (e.g. Fine Offset, Mapin). Some people claim it works fine when placed high up away from any buildings, trees or other obstructions. Many people complain that it is just not reliable regardless. It doesn’t help that the weather stations come with a short pole.
From watching the vane it seems one of the issues is when the wind is gusty. I’ve noticed that when a gust ends the vane becomes destabilized and simply spins around and around.
For me it is simply not feasible to locate the vane on the chimney so I wondered if adding software filtering to my weather station code might work.
pywws already contains wind direction averaging for hourly summaries so I thought it would give that a try. Here is how the wind direction data looked a few days ago before adding averaging to the code:
Here is the wind direction data today after adding the averaging:
Much better. It is clear the wind was coming out of the west. While the above data was being captured I could see the vane swinging from north to south all the time, so it is pretty nice that the averaging was able to pick out the correct wind direction.
As previously mentioned the algorithm was taken from pywws, but with a couple of changes added. It works as follows:
- When the receiver starts it collects a new wind vector every 48 seconds. The vector consists of the wind direction and average speed. This comes directly from the weather station transmitter.
- While the receiver is collecting the first 16 wind vectors it reports the current wind direction to Weather Underground. So for the first 12.8 minutes (16 x 48 seconds) after reset the wind direction is not averaged.
- Once 16 wind vectors have been collected the receiver starts averaging the wind direction and reporting the average to Weather Underground. Every 48 seconds when new data is received the oldest wind vector is overwritten. So the receiver always has the last 16 wind vectors to work with.
- The latest 16 wind vectors are converted into weighted vectors. There is one vector for each compass point direction and the size of each vector is the sum of the average wind speeds measured coming from that direction. This method ensures the result favors directions where stronger winds came from.
- Using some trigonometry the average wind direction is calculated.
- In the situation where there is no wind for all 16 wind vectors (so no wind for 12.8 minutes) then the last average wind direction is used.
The code can be obtained from github.
A couple of years ago I bought a WH1080 weather station (e.g. Fine Offset, Mapin). It’s available under many brands from many outlets all over the world and is very common. Here are pictures of what this cheap weather station looks like:
I had the touchscreen connected to a Linux sever via USB and used pywws to upload to Weather Underground. This worked well until USB broke so I had to look for a new solution.
Kevin Sangeelee had developed some code that allowed a Raspberry Pi to receive the 433MHz radio signals and decode them. It also had support for a pressure sensor. Perfect. The code can be found here: http://www.susa.net/wordpress/2012/08/raspberry-pi-reading-wh1081-weather-sensors-using-an-rfm01-and-rfm12b/
The RFM01 was obtained from Maplin for about £4 and was trivially connected to the RPi. Kevin’s article gives the connections. Note: I didn’t use any resistors.
The BMP085 was also easily connected. Purchased from eBay for about £6 it connects directly to the I2C pins. Again, no resistors needed.
The first step was up update Kevin’s code for revision 2 of the RPi. This is required because a GPIO pin has changed and the second I2C bus is now used.
Now I ran into a stumbling block – how to get the data into pywws. I hoped that this problem had already been solved but unfortunately I would have to start writing custom python modules. After thinking about it for a while I decided that all I needed was to upload data to Weather Underground. I didn’t need the other features of pywws. Fortunately Weather Underground has a simple way of uploading using a HTTP GET request. The data just needed to be massaged into the correct format. While I was at it I decided to use the rapid-fire updating. This means that Weather Underground displays new data from your station roughly every 48 seconds – you can watch it continually update.
You can get the code from GitHub here: https://github.com/ajayre/WH1080-Weather-Underground.
Create a text file in the same folder as the executable called wunderground_creds.txt. On the first line enter the name of your weather station ID, for example IWESTYORKS30. On the second line enter your Weather Underground password.
Compile, run and follow Kevin’s instructions for setting up and tuning. Don’t forget to enable the SPI and I2C modules on the RPi. Also make sure you run:
sudo dpkg-reconfigure tzdata
to set the timezone.
Make sure the path to the credentials file in wunderground.c is set correctly. To start the program on boot I used the following in a boot script:
sudo screen -d -m /home/pi/weather/wh1080_rf
- loosen the screws holding the servo and move it back slightly so the gears are still meshing but there is no sideways pressure on the servo shaft.
- make sure the pivot servo is not near the limit of it’s range at any point. When near the limit it will attempt continuous rotation and will lose it’s position.
- check the hub retainer is not touching the lower bearing.
- move the gear housing away from the servo and make sure it rotates freely.
- rotate the in tray outwards slightly and update the in tray position in config.xml. This will move the center of the in tray slightly further from the center of the pivot.
- make sure y axis is vertical (see item 6).
- rotate the out tray outwards slightly and update the out tray position in config.xml. This will move the center of the out tray slightly further from the center of the pivot.
- make sure y axis is vertical (see item 6).
- make sure both sides of the grabber are vertical.
- raise the toolhead microswitch so that more of the grabber is lowered into the hole in the center of the disc.
- make sure that the y axis is exactly horizontal.
- make sure that the y axis is exactly horizontal.
- check that the Y axis is vertical (see item 6).
- make sure that both sides of the grabber are vertical.
- make sure the hub retainer is close to, but not touching, the lower bearing.
- loosen the nuts holding the gear housing to the threaded rod and re-tighten while pressing down on the rear of the gear housing.
- check the y axis is securely attached to the threaded rod.
- adjust the two M8 nuts on the threaded rod at the hub to shorten/lengthen the arm from the pivot to y axis. Make sure the grabber is exactly over the center of the disc.
- tweak the drive tray position in config.xml
2. Ideas for Improvements
- Increase DVD capacity for faster PCs.
- Redesign main gear housing to use less plastic.
- Sugru veneers for grippers.
- Eliminate Raspberry Pi.
- merge BotServer into JacktheRipperBot.exe
- PC communicates directly with Pololu Maestro
- PC farm for faster ripping
- use Raspberry Pi to create image of discs which are then put into a queue. A farm of PCs work on encoding the queue.
- Cable management on top of support ring to keep wires away from gears.
- Stack two or three DVD drives vertically so the robot can load and unload into all of them.
- Add support for ripping “profiles” to JacktheRipperBot.exe, allowing different Handbrake settings to be used for specific discs in the in tray.
Install the Pololu Maestro software and then connect the Maestro to your PC and start the software.
The microswitches should already be displaying their status. Press the switches and make sure they are working.
Enable the three servo channels and manually move each servo to make sure it works.
Use the software to position the arm over the in tray, DVD drive and out tray. Make a note of the servo position values. Be careful not to go near the limits of the servo as it turns into a continuous rotation servo and loses position.
Use the software to work out a slow speed for raising and lowering the toolhead and also the value to make it stop without the servo making a buzzing sound. Make a note of these values.
Finally use the software to determine the servo values for the grippers being fully open and fully closed. Make a note of these values.
Open the DVD tray and put a DVD into it.
Use the two M8 nuts next to the hub to adjust the length of the arm so that the grippers are directly above the hole in the DVD.
Swing the arm over the in tray and check if the grippers are positioned over the center. If not swing the tray outwards slightly or add M8 washers as spacers between the tray and the tray anchor. If you move the tray then you will need to check again the servo value need for the in tray position.
Repeat this for the out tray.
3. Raspberry Pi Setup
Copy to the Raspberry Pi (RPi) the following:
Edit config.xml in a text editor and insert the servo values you have worked out.
Mono needs to be installed on the RPi but the version in the repositories does not work. Instead use the version found here.
Run the server with:
mono ./BotServer.exe config.xml
Open the DVD tray and put a DVD into the in tray.
Load a disc by visiting: http://192.168.1.70/botapi/?command=loaddisc
Replace the IP address with the address of your RPi. The disc should be loaded into the tray.
You may have to adjust the YAxisLowertoDriveTime in config.xml which is given in 1/1000th of a second and governs the time spent lowering the toolhead before dropping the disc into the drive tray.
Once the load disc function is working test the unloading with: http://192.168.1.70/botapi/?command=unloaddisc
The YAxisLowertoOutTrayDropTime in config.xml governs the time spent lowering the toolhead before dropping the disc into the out tray. It has to drop from low enough that it consistently goes into the tray, but high enough that when the stack in the out tray is full there is space to drop the last disc.
4. PC Setup
Copy the following files to your PC:
Make sure the full .NET Framework 4.0 is installed. If you need to install it then reboot before running JacktheRipperBot.exe.
Install DVDFab Passkey or AnyDVD. Both applications have the option to execute a command when scanning of a disc has completed. Set this up to run ScanningFinished.bat.
Install Handbrake and check the correct path to HandbrakeCLI.exe is used in Rip.bat.
Start JacktheRipperBot.exe and enter the IP address of your RPi.
Go to the advanced tab and try the various operations individually.
Once you are happy everything is working enter the number of discs in the in tray and click on Start to start ripping!
The following block diagram shows the arrangement of the electronics.
For wifi connect a USB wifi interface to the Raspberry Pi (RPi). Connect a USB cable from the RPi to the Maestro. I connect to the RPi via SSH and I have configured my router to always assign the same IP address.
The Maestro requires a separate 5V power supply for the servos.
Connect the servos to the Maestro as follows:
- Channel 0 = Core servo for pivoting
- Channel 1 = Y axis servo
- Channel 2 = Toolhead servo
Use the servo extension cables for the Y axis and toolhead servo.
Wire the microswitches as shown in this diagram. I used servo extension cables and the colors mentioned reflect that. Note that the signal wire could also be white.
The 5V connection to the Maestro is not the one on the servo connectors. There is a separate 5V and GND along the top edge. See this section of the Maestro user’s guide for details.
Solder a two pin header onto the pads for the 5V and GND. Use the two way molex connector and 0.1 inch pins to create a connector to plug onto the header. Note that the ground pin is not used, instead the ground on the servo connectors is used.