The latest Raspberry Pi PoE HAT on a Pi 4 is awesome! One cable to the right switch and you’ve got power and internet. One runs Homebridge giving Apple Home access to Ubiquity cameras, the Nest, and a few other custom things. It’s a great combination, the only thing I need to do is put Homebridge into docker and put the configure script into GitHub in case things fail. But there is one glaring issue with the PoE HAT. The fan. It’s loud! Very very very loud. It sounds like a basketball mosquito every 30 seconds. At 104°F (40°C) the fan turns on until the temperature is 102.2°F (39°C). It. does. this. all. day. and. night. long.

The solution is fortunately simple:

1. Shutdown your Pi.
2. Mount the SD card.
3. Open the file: /boot/config.txt

4. At the beginning of the file add the following:

# PoE HAT Fan Speeds
dtparam=poe_fan_temp0=55000
dtparam=poe_fan_temp1=60000
dtparam=poe_fan_temp2=65000
dtparam=poe_fan_temp3=70000

5. Plug the SD card back into your Pi and enjoy

My fan goes on at 55°C, increases again at 60°C, again at 65°C and full speed at 70°C. You can use the command to check the temperature and tweak the values above according to your environment.

vcgencmd measure_temp

I do think I need a good heat sink and chances are you do as well. But most heat sinks use a sticker which acts as a thermal insulator. You want thermal paste but then it’s difficult to hold it to the Pi, but this will be a discussion for a future post.

I’m blamed for causing the Raspberry Pi shortage because I built the World’s Largest Raspberry Pi Cluster with 1050 Raspberry Pi 3B+. In my defense I didn’t, all Pi were purchased in February 2019, you can read all about it here. But in March 2020 I had some time to kill as most of us did and there were some deals on Pi 4 so I picked a bunch up. Not 1,000 of them, but a healthy stockpile.

So today, because there are a lot of people without and I have I am giving away one Raspberry Pi 4B+ with 4gb of RAM and one SD card. To enter the raffle, follow these steps and watch the video below:

1. Subscribe to this video
2. Like this video
3. Comment on this video with what you will do with the Pi
4. 4. Send an email to thegreatraspberrypigiveaway@gmail.com and in the email include the username you commented with so I can verify you are subscribed, liked the video and commented.

The drawing will end on noon Pacific Standard Time March 19th and a video will be posted on March 20th announcing the winner. You will receive an email to get your address and badabing badaboom, you get a Pi. The Pi and SD card are free to the person randomly picked that follows the directions above and shipping will be paid for to the lower 48 United States. If you are somewhere else on the planet you will pay shipping and customs. I’ll ask you to send me a shipping label.

Happy Pi Day!

This is the first of many new videos where I will build cool projects. For example, here is the last Christmas ornament I made.

A few years back I created a Death Star ornament which started a tradition of wanting to make an ornament each year. It’s been a few years but here is my second ornament in my collection, the World’s Smallest Raspberry Pi Cluster.

This mini Raspberry Pi cluster is the smallest Raspberry Pi cluster in the world. Also the most powerful ornament in the world. What’s it do, that’s a good question. Right now it runs the same software I ran on the World’s Largest Raspberry Pi Cluster so watch the video and find out and comment what I should run on it.

If you want to make your own, go get the STL files on Thingiverse.

If you are interested in the Death Star ornament here is a video or you can make it by getting the STL files on Thingiverse.

If you prefer you can read this blog post on GitHub here.

The Raspberry Pi Super Computer was originally built for Oracle Open World in October 2019. There are 1050 Raspberry Pi 3b+ in four server racks configured in a big square box reminiscent of a British police box popularized in a certain BBC TV series. Fast forward to today, and The Raspberry Pi Super Computer (Pi Cluster) was sent to e-waste, some parts stripped off it, and sat dormant for two years until May of this year, when it found its way to my garage for a complete overhaul.

For a temporal history of how 1050 Raspberry Pi came to be, you can read A Temporal History of The World’s Largest Raspberry Pi Cluster.

It begins with Gerald Venzl at Oracle Switzerland bringing the 12-node cluster to my attention, then we brainstormed a big cluster with Stephen Chin. Learn how the Pi Cluster went to e-waste during COVID lockdowns and the California fires and how Eric Sedlar rescued it, eventually storing it at Oracle Labs. If you find that too long, watch the original build video of The World’s Largest Raspberry Pi Cluster that we know of, this Building the world’s largest Raspberry Pi cluster by Gerald Venzl, and this video of the Big Pi Cluster In My Garage — Part I.

And by the way, if you’re reading this, there’s a high likelihood that you’d ‘be a great Luminary. What’s a Luminary? It’s our recently launched developer group that connects developers like you to exclusive technical content, free swag, and a community to help you build something as cool as this cluster, become a Luminary today.

Resurrection

When CloudWorld was announced we immediately proposed to resurrect The World’s Largest Raspberry Pi Super Computer (that we know of). Who doesn’t like a good resurrection story? The proposals went something like this:

1. Donate it to the Computer History Museum as a non-functional art piece for Pi-Day.
2. Raspberry Pi’s are valuable now. Raffle off a piece of the Pi to win a free Raspberry Pi 3B+ from one of the World’s Largest Raspberry Pi Clusters.
3. We have one opportunity to make history. We fix it for CloudWorld, add fans so it doesn’t overheat, and run it as an “on prem” and “edge” device showing off tech that is being built in the labs. We’ll include GraalPython, Java and Oracle Linux 9 running on every device on the Pi Cluster. It’s all connected to Oracle Cloud Infrastructure (OCI) through Site-to-Site (scroll to the bottom for directions on this) VPN for on prem and via micro-services, compute instances, Autonomous Database, Services Gateway, and Load Balancer. AR visualizations would be ideal, and we could run something cool on it — like when we ran SETI@home on the Raspberry Pi Mini Super Computer, an 84-Pi Cluster. I came up with the idea to set up a service so anyone in the world could send code to the cluster to run a workload, as we show off our Digital Twin AR/VR services and create blogs and videos to inspire developers and students. We can show people why developers and students are having a lot of fun learning and using Oracle’s Free Tier. Plus, we can get a Guinness Book world record.

We choose option three and the search for a new lab began. I spoke with the leadership of various product teams mentioned above, as well as leaders in the Raspberry Pi community like Jeff Geerling and Eben Upton, and laid out a plan. I can’t tell you about the entire plan because we’ve just set the foundation for it, but there’s a much more to come. This is just the story of getting the Pi Cluster to DevNucleus at CloudWorld and a brief mention of what happens after. It turns out a Guinness Book adjudication is really expensive!

The first step was to identify a budget and an estimate of the work to see if it was feasible. We knew we needed:

1. Fans. Lots of fans.
2. To replace any parts missing.
3. To test everything out.
4. To write new software.

Every Pi network boots. In 2019 I had Oracle Linux 7 running on the entire cluster, but did it still work? Did we have all the source code, MAC addresses, and everything needed to do it again?

The second step was to get a place to work on the Pi Cluster. Try finding a place with double doors, close to a freight elevator, with enough power and space to work on it, and a network that isn’t locked down tight — not easy! I looked at Oracle facilities around the world. The logistics of working on something like this remotely and all the physical work that would have to be put into it meant anywhere in the world would work only if certain requirements were met. I’d have to travel there, set everything up, and have a dozen people to help. We’d set it up for remote access but someone would have to be available in person when things didn’t work right. After a nice lunch with my amazing wife, we decided our garage worked the best, and that’s where #BigPiClusterInMyGarage started.

Adding Fans — Cooling the Raspberry Pi

Once it was delivered, I went to work ensuring our budget was accurate, then rectifying and testing things while ordering replacement parts (mostly fans). Lots of fans: 250 new fans to be exact. The cluster ended up with 257 fans and that isn’t counting the fans that are in each of the switches, the server, or the power supplies. This required that I disassemble the entire cluster and reassemble it. Not every bolt was removed, but all 21 Pi 2U banks were disassembled, every 5th Pi removed and replaced, which meant 250 new Pi caddies with brackets for fans had to be printed. You can learn about that here. Victor Agreda used his newly purchased Ultimaker S5 to print a few dozen of the fan version of the caddies. The fans all needed power, and many thanks to Eli Schilling for creating many of the wiring harnesses. In addition, we added some easter eggs. I know it isn’t much of an easter egg if I tell the world about it, but I’ll explain it in more detail in the Warble section below (because it’s too cool to not say anything). I have a few videos documenting some of the work that can be found in A Temporal History of The World’s Largest Raspberry Pi Cluster.

Operating System — The Smartest Operating System Around

I think a lot of us underestimate the value of a good operating system when building out infrastructure and hardware, and Oracle Linux is top notch. I go into more detail about the operating system in A Temporal History of The World’s Largest Raspberry Pi Cluster (and I have some other stuff I’m working on so you can set up network booting Pi at home). Because we had all that work to build upon, we had to upgrade from Oracle Linux 7 to Oracle Linux 9. I’ll tell you a secret: it wasn’t that simple. Nevertheless, the Oracle Linux team has been amazing to work with and really deserves all the credit for setting up the operating system for the Pi Cluster. Go check out Oracle Linux 9, it’s worth using or upgrading to. There were a few hiccups, such as the added layer of security which meant the root account no longer had SSH access by default.

It’s worth mentioning here how we boot the Pi. Every Pi in the cluster is network booting off a single, read-only NFS mount on the server, and we added a systemd service to run a bash script whenever the server or Pi boots up. This makes configuring what we run almost effortless.

Software and Cloud Services — GraalVM is Fast Running on Client or in the Cloud

All the software is open source and can be found here in our DevRel GitHub repository. There are some things coming from the labs and aren’t available even as a tech preview (I tried, they just weren’t ready) so those aren’t included. Be warned, most of that code was written quickly. What you find might not make a whole lot of sense, so let me explain.

First, there’s the software on the cluster. The server runs a Docker container comprised of GraalPython on top of GraalVM. That Dockerfile is undergoing continuous improvement so I don’t recommend copying it just yet. I’ve provided some bug reports, but as soon as the Graal environment variables and CTRL+C work (and maybe a new image for GraalPython is created) you’ll want to dive right in. Meanwhile, know that this is one way of doing it. I’ve seen about an 8x increase in performance when running pure Python code under GraalVM. That’s pretty impressive!

Every device on the cluster runs a web service. The server broadcasts a UDP message with its IP address and port for any device to listen to and communicates with the server for auto discovery. This is new from previous years where the server’s IP address was put into an environment variable. The IP address doesn’t change so we could hard code it, but there were two issues: Anyone working on this needs to run a test system with their desktop and a simulation of a Pi or a couple of Pis on their desk, and the environment variables are lost once you sudo. This actually solves a lot of issues! Once a Pi boots up it runs its web server, listens for the UDP message, registers its IP address and MAC address with the server, and listens for work. At intervals, the server will send a ping to each Pi as a health check to make sure they should be in the list of available Pi.

Every five seconds each Pi sends all its data (CPU, memory, temperature, etc.) to a REST endpoint on an Autonomous Database via the native ORDS support. The documenation can be found here. I put some code in where if the Pi fail to send their data, it waits a little longer the next time, scaling up to 60 seconds. It turns out to be a mountain of data which Autonomous Database handles effortlessly. I tried a few other databases that shall not be named and let’s just say they couldn’t handle it, sometimes resulting in delays greater than five seconds.

Digital Twin with AR/VR — Visualize your Data

I created a fairly detailed 3D model of the Pi Cluster that can be found here and opened in your favorite 3D program. Our AR/VR and cloud experts Wojciech Pluta, Victor Martin, Bogdan Farca and Stuart Coggins went to work building some amazing AR and VR experiences. They tuned databases, wrote APEX apps, and ran socket.io for streaming. They leveraged a Kubernettes cluster called OCI OKE so the 3D experiences can scale without falling over, which means anyone can put a Digital Twin of the Pi Cluster in their living room. We have iPads for AR and printed QR codes so the iPad can track the cluster with millimeter accuracy, enabling attendees to view the goings-on of the cluster interactively. The team also built a Meta VR version, the details of which will be revealed soon. There wasn’t enough power to run the entire cluster in my garage so we’ll be integrating this and testing it before the doors open at CloudWorld. It may work, it may fall over. Whatever happens, it will be a good story! I’ll add a link here when we have something written on AR/VR Digital Twin.

OCI Services — At the Center of Every Project is Cloud Infrastructure

In my garage, the Pi Cluster is setup as an “on prem” server. I created an isolated subnet on my Ubiquity Dream Machine Pro, configured a site-to-site VPN to OCI using a Bastion, and used a local jump box that has two network interfaces (one for the Pi Cluster subnet and one for the Pi Cluster). Thus, the Pi Cluster appears to the outside world as one IP address. Show up, plug in network power, and you’re good. I wish setup were that easy and I didn’t have to test everything — making sure cables didn’t bounce out of position — but let’s just say it’s that easy because it sounds more fun.

We won’t have control of the network at CloudWorld, so the Pi Cluster is an “edge device.” It uses cloud services such as Services Gateway, Load Balancer, and Domain Management. Yes, we have a domain. I’ll get to that in the next section.

The network looks like this:

If you have any questions about this head over to Oracle’s public Slack channel for developers. Ask any question you want. How to set it up, what services to use. You’ll find your answers there!

IoT — Specific Lightweight Tasks with Small Inexpensive Microcontrollers

We also have a pair of Arduinos running on the cluster. The first Arduino is an Arduino Mega with an Ethernet HAT. The original code can be found here. It runs a web service and turns on two solenoids for remote access to the physical reset and power buttons on the server. I’ve changed the software a bit compared to the repository and didn’t publish yet, so I left this older version up. The version I haven’t published registers itself and waits for a simple startup command when a developer SSHs into the Bastion.

The second Arduino is the same hardware but runs a REST server listening for a JSON payload and is connected to a dozen NeoPixels in the light at the top of the police box.

Warble — A Custom Programming Language Designed for the Pi Cluster

We’re hosting the domain https://warble.withoracle.cloud on OCI, backed by Domain Management, a Load Balancer, and a Compute Instance. The compute instance is running the same software that is running on the Pi Cluster: A Docker Container with GraalPython and a web service. This isn’t quite ready for prime time but check back here or on Twitter October 18th–20th because it will be live during CloudWorld, and I think it’ll be a lot of fun.

We’ve created a programming language designed for Twitter to be run on the Pi Cluster called Warble. Warble isn’t a full-featured programming language and I took a lot of shortcuts. It’s made to use as few characters as possible so you can post a Warble to Twitter and have it run on the Pi Cluster. I have a Python script running on a Computer Instance using the Twitter API to search for the hashtag #pi. If the next character is an open curly brace and the last character is a close curly brace, then we have a Warble and it’s stored into a database. For Example:

> #pi{PRINT(“hello cluster”)}
< hello cluster

When the server has a few spare cycles, it gets a batch of Warbles from the database, finds a Pi that has lower than 30% CPU utilization, and sends the Warble to that Pi for processing. Warble is written in Python and converts Warbles into Python, then executes them. Currently it uses Python3, but we have a version written in GraalPython using some cutting-edge tech not ready for the public. Right now, our research engineers Rodrigo Bruno and Serhii Ivanenko in Oracle Labs are getting it ready to run on the cluster. For now, the results from the Warble post to an Autonomous Database via a REST API that’s easy to set up. Stuart Coggins and Jeff Smith have been gracious enough to help with that and make sure it is rock solid. We’ll have an APEX app that will display the Warbles and their results, and I hope we can get a leader board for custom visualizations.

Wouldn’t it be cool to see who can calculate Pi to the most digits on one of the World’s Largest Raspberry Pi Clusters?

> #pi{PRINT(2*ROUND(ACOS(0.0),3))}
< 3.142

It’s close enough.

Twitter will be a lot of fun, though it throttles the API and this is why we have the hosted domain. I will provide a REST endpoint to post Warbles. Maybe someone will figure out how to calculate Pi with Bailey–Borwein–Plouffe_formula using Warble or some other way.

I’m not going to write a syntax grammar but I will give some examples.

Warble supports variables:

> #pi{x=0PRINT(x)}
< 0

Warble can handle complex expressions:

> #pi{x=1/16.0²*(4.0/(8*k+1)-2.0/(8*k+4)-1.0/(8*k+5)-1.0/(8*k+6)}
<

While loops:

> #pi{i=0;WHILE(i<10){PRINT(i);i++}}
< 0
< 1
< 2
< 3
< 4
< 5
< 6
< 7
< 8
< 9

For loops:

> #pi{FOR(i=0;i<10;i++){PRINT(i)}}
< 0
< 1
< 2
< 3
< 4
< 5
< 6
< 7
< 8
< 9

I’m exposing most of the math functions as well as SETPRECISION(x). It isn’t short on characters but that’s fine.

Plus, you can save values and load them again. They are user specific:

> #pi{SAVE(“pi”,1)}
<

and then follow it up with a load:

> #pi{x=LOAD(“pi”);x++;SAVE(“pi”,x);PRINT(x)}
< 2

Lastly, the easter eggs. Warble can play a sound. Yes, this is another IoT device hooked up to the cluster, but it’s a Pi with an amplifier! Unfortunately you can only hear it if you are standing in front of it. Makes you want to come to Las Vegas and attend CloudWorld, doesn’t it?

> #pi{PLAYSOUND(”http://downloads.bbc.co.uk/doctorwho/sounds/tardis.mp3");}
<

There are also lights. This turns the first light to red:

> #pi{LIGHTS(0,255,0,0)}
<

If you wanted to turn the last light green you’d do this:

> #pi{LIGHTS(23,0,255,0)}
<

If you wanted to change the color of a light with a delay between do this:

> #pi{LIGHTS(0,0,255,0);SLEEP(20);LIGHTS(0,0,255,0)}
<

Or combine a few of these:

> #pi{FOR(i=0;i<24;i++){LIGHTS(i,0,255,0)}SLEEP(20);FOR(i=0;i<24;i++){LIGHTS(i,0,0,255)}}
<

Setting up a Site-To-Site VPN with OCI

On the Ubiquity Dream Machine Pro, with the help of Tim Clegg, I created a new subnet. Here’s an outline of the steps we followed. I’m not going to provide specific screen captures or a video because the options on Ubiquity and Oracle Cloud will change. Instead, here are some highlights of what you need and what to do:

Under networks create a new network with a name, I choose “pi”.
VLAN ID: 3
Network Type: Standard

Create a Site-to-site VPN
Network Name: pivpn
Pre-shared Key: ***********************
Server Address: <IP Address of Router> (default should be fine)
Remote Gateway/Subnets: 10.0.0.0/24
Remote IP Address: <IP Address of remote VPN>
Advanced: Manual
IPsec Profile: Customized
Route Distance: 30
Key Exchange Version: IKEv1
Encryption: AES-256
Hash: SHA1
IKE DH Group: 5
ESP DH Group: 5
Perfect Forward Secrecy: enabled
Dynamic Routing: enabled

I created three firewall rules:

1. pi block 192.168.3.1 (gateway)

Type: LAN Local
Action: Drop
Source, Souce Type: Network
Source, Network: pi
Destination, Source Type: Network
Destination, Network: pi
Destination, Network Type: Gateway IP Address

2. Default accept to pi

Type: LAN In
Action: Accept
Source, Souce Type: Network
Source, Network: Default
Destination, Source Type: Network
Destination, Network: pi

3. pi block to Default

Type: LAN Out
Action: Drop
Source, Souce Type: Network
Destination, Network: pi
Destination, Source Type: Network
Source, Network: Default
Advanced: Manual
Check Match State New
Check Match State Invalid

4. In OCI go to Networking and Site-to-Site VPN
Create IPSec Connection.
Give it a name.
You’ll want this to get your public IP address.

dig -4 TXT +short o-o.myaddr.l.google.com @ns1.google.com

Enter it.

You’ll need to create two tunnels, so I set up both to point to the same VPN as OCI requires two and I only exposed one on my network. You’ll add this to the VPN.

5. Setup a Dynamic Routing Gateway
6. Setup a VCN, add an Ingress Rule with the CIDR that is your local subnet, for example mine is 192.168.3.0/24.

The Future

After going through the paces for DevNucleus at Oracle CloudWorld, the Pi Cluster is heading to Oracle Labs where… well, the next part is a bit of a secret for now. Potential uses include:
1. running additional tests for GraalVM and Java
2. Edge computing projects
3. Robots & Parallel Processing (i.e. neural networks)
5. Activities suggested to us by you, the developer

With Pi Day 2023 just around the corner, you will definitely want to stay tuned for the next stage of evolution for this incredible piece of tech. Who knows? A few of the Pi may even find their way out of the cluster and into your hands.

I want to thank everyone that has had a hand in the project. Read A Temporal History of The World’s Largest Raspberry Pi Cluster for how this crazy amazing project came to be.

The Raspberry Pi Super Computer at Java One 2022 was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you prefer you can read this blog post on GitHub here.

The Raspberry Pi Super Computer was originally built for Open World in October 2019. We have 1050 Raspberry Pi 3b+ in four server racks, configured in a big square box reminiscent of a British Police box, popularized in a certain British Television TV series. Fast forward to today, the Pi Cluster, “The Raspberry Pi Super Computer (Pi Cluster),” got sent to e-waste, some parts stripped off it, was dormant for 2 years, and then in May of this year found it’s way to my garage where it got a complete overhaul.

A Temporal History

2018

In early 2018, a small group of enthusiastic pre-sales engineers from Oracle Switzerland presented their 12-node Raspberry Pi cluster at the Hackzurich hackathon, mimicking an Oracle Cloud data center with 3 availability domains. It ran a fully-operational Kubernetes cluster and could demo node and availability domain fail-overs. Gerald Venzl wrote about this in Building the world’s largest Raspberry Pi cluster. Fast forward to Open World 2018 in October: Stephen Chin and Gerald Venzl presented me with this cluster and the concept of doing a LOT of small ones that could come together and become a really big one. Gerald thought 1,000 Pi would be cool. I told him “That is a terrible number. You need 1024”. Gerald and Stephen got big smiles on their faces and the seed of the Pi Cluster was planted. Over the coming months Jasper Potts and I brainstormed how to make this happen and started making spreadsheets of parts, and I reached out to our suppliers to get quotes for all of them.

2019

The idea spread around the company and garnered support from the leads of all the teams from which we would showcase technology. Approvals for purchases started happen. I went shopping for a lab because we were going to need a lot of space. We needed a lab for the other experiences we built like Bullet Time or the Escape Rooms, so it was a necessity. I kitted it out with soldering irons, oscilloscope, 3D printers, 4 legged desks, and everything else you could need for a real Maker’s space. We considered using the Pi Compute modules — and there were some really cool 4-Pi boards — but 250 of them would be too expensive. We thought about custom boards, but that would take too much time. That’s when we decided to use off-the-shelf hardware that anyone can buy, and just use a regular Raspberry Pi 3B+. The Pi 4 wasn’t available yet. The Pi arrived February 2019 before I had my lab, and got stored in other labs until June when the Developer Marketing Hacker Lab was finally opened.

Between February and April I did a lot of traveling to support the existing experiences, ordering parts. and brainstorming and research on how to build this cluster. Jasper Potts and I would talk almost daily, trying to make sure we had every possibly part we needed, to make sure each piece of the project was going to be possible, and contingency plans in case things didn’t work out. The four problems at this point were:

1. Power
2. Networking
3. SD Cards
4. Software
5. What would it look like

I eventually found a 60-port USB power supply, ordered one to test. It worked, so I ordered 30 of them. It’s always good to have backups. After some initial network tests with an 8 Pi Cluster with standard home routers and gateways, we realized a standard home network wasn’t going to work. If we built a lot of tiny Pi Clusters there were the problems of cost for all the routers and gateways, then when the cluster came together as one, each cluster would a “cluster of clusters” a couple times in a tree configuration, where each node is either a single Pi or a a tiny cluster. It would have to be a cluster of clusters, or be “reconfigurable”. Any way you do it, configuring and maintaining this would be a lot of work. But with over 255 devices to be a single cluster we had to go with Class B, and that’s when serious networking equipment is needed.

In May Stephen Chin and I sat down with a list of problems. We had power solved, at least for the Pi. We would have to readdress this for the entire cluster. We went with Ubiquity networking. It‘s the least expensive of the serious networking hardware, and has all the features that we would need. We decided to not order SD cards and try for network booting. This would come back to bite us later, but SD cards for every Pi would take too much time and cost $16,000. Network booting would solve a lot of problems, but I’ll dig into this later. Writing software for anything like this is challenging and people get their doctorates and spend entire careers coming up with algorithms that can be split across multiple threads or compute modules. We decided to bring in Johan Vos and José Pereda of GLUON and do this as a Java community project. They brought in Gerrit Grunwald and a few other people I wasn’t even aware were doing work.

The last piece of the puzzle was what would it look like. I had started prototyping and researching different ways to hold the Pi, but it started to look like this thing would be about 8–12 server racks if I went with the typical density I was seeing on the internet. I sat down with a dozen Pi, a couple Ubiquity switches, and mounted them in a small server rack. I then held the Pi next to one another in different configurations. In a 1U, they’d have to all lay flat — I could only get 4 to fit. But if I put them in vertically, it would be a 2U but a lot more could be stacked.

Over coffee — then lunch — at the dining room table, we discussed putting it into an old VAX or Cray CS6400 with seats. A big rainbow arch that people can walk under. We even thought about a tree where the Pi grew on it like fruit. I showed him some of the prototype work. We realized that for logistics it needed to be a box. We did the math and thought we could cram it all into 4 racks. Maybe. It was going to be tight. But if we could, then a telephone booth would be cool. Superman had a cool telephone booth. Maybe a red British one. Or…a blue British Police Box. We both got a bit smile went to work with some renderings, slide decks, and more prototyping. But Jasper Potts rendering is the one that we started using.

I was trying to get the highest density I could by cramming at least 20 Pi into a 2U. The problem was that this left us with about 50 extra Pi, so it wouldn’t fit. It’s kind of like the rocket equation: the more Pi you have, the more infrastructure you need, thus the more space and power. At first I 3D-printed a huge print where the Pi just slid into place and were held in with another print. Unfortunately, my printer wouldn’t print a full rack that size, and if it could, it took 24 hours. I tried a lot of things. That’s when I got the idea to use an 18" 1"x1/2" piece of 80/20 with the end milled off by 16.35mm, then tap the hols in the ends, print 21 Pi caddies and two ends, and that was the solution. I should back up at this point and mention that we did consider POE for all the Pi. We tried this, but the POE hat was mutually exclusive because it required some firmware changes to network booting, then all the switches would have to have all POE ports. I had difficulty finding more than 16-port POE switches and the density would have been half of what we were able to get.

Everything was moved to the Developer Marketing Hacker Lab in June and a few people, like Blaine Carter, flew out to help set it up. I decided to bring in my camera and tripod and record what was going on, giving the camera little attention besides making sure it was pointed in the general direction. This video would later become Pi Cluster Video on March 14th 2020. World’s Largest Raspberry Pi Cluster (that we know of):

I did record a few choice moments. At this point in time I had discovered Casey Neistat and thought his videos were interesting.

I was trying to document everything as I went, knowing full well it’s nearly impossible to document after the fact. Here are the blogs from that time describing the caddies and how they came to be.

• Very Large Raspberry Pi Cluster Part 1
• Very Large Raspberry Pi Cluster Part 2
• Very Large Raspberry Pi Cluster Part 3
• Very Large Raspberry Pi Cluster Part 4
• Very Large Raspberry Pi Cluster Part 5
• Very Large Raspberry Pi Cluster Part 6
• 3D Printed Parts

During this project, I started actually posting to Twitter. I took this video while heading home at midnight, edited the video with iMovie on my phone while waiting for the elevator doors to open, and while walking to my car. By the time I got to my car, I had posted it.

I was actively recruiting. We still had a lot of unknowns, but one of the big ones was the time it would take. If something takes 1 minute and you have 1,000 of them, then that’s over 16 hours. Blaine Carter and I were busy printing 1,000 caddies, the end brackets, and everything else that we needed that was custom from a total of — get this — twelve 3D printers. The brackets took 45 minutes — after optimizations. There were months of 3D printing, but we had to be sure they were perfect. 3D printing is amazing and can print a thing out of nowhere in a short period of time, but if you need 1,000 of them, it’s going to take a long time. Yolande Poirier knew of some students at 42 Silicon Valley who came by and started helping. I bought them pizza offered to mentor them. They came back the next day with friends. Some students would change, but a core group who I remain friends with today came day after day. We set up assembly lines for removing the Pi from their packaging, lining them up for install into caddies, and assembling them into a 2U rack of 21 Pi. We ended up with 50 2U caddies. Actually, the plan was to build two 84 Pi Mini Clusters so we made 9 more for a total of 59. One was extra, but it turned out we needed this one. I’ll explain later.

Slowly the Pi Cluster took shape. The printers were running 24–7. I started working 7 days a week, and at least 15 hours a day. It wasn’t healthy, but everyone working on it was having a great time. Great people. I made sure we always had food and cool toys — that’s all an engineer needs besides a little bit of sleep. The students were learning a lot, and they were smart, so things got done.

One of the parallel tasks was the software, and for any software project you need a good operating system. The idea had been presented to Wim Coekaerts and the Oracle Linux team, and they were 100% on board to give the Pi Cluster a custom version of Oracle Linux 7. A good friend of mine, Roy Feague, had some time on his hands and was enjoying the challenge of network booting the Pi. The Pi is designed to network boot, but we found that the firmware had a bug. When the Pi boots up to communicate with the DHCP server to get an IP address, it doesn’t do a correct lease, release, and bind. It renews the IP but stops there. So multiple Pi get the same IP. So we had to get the MAC address of every single Pi and hard code it into the dhcpd.conf. It seems backwards to use DHCP only to have static IP addresses, but there you have it. Roy started off with Ubuntu and Raspbian so we could use an NFS mount shared by all the Pi and use an overlay file system so none of them did a write-back. Here’s a good article on Raspberry Pi PXE Boot — Network booting a Pi 4 without an SD card that didn’t exist back then. The net boot process works like this:

1. Power on the Pi, NIC firmware sends DHCP request
2. DHCP server responds with a lease and server options
3. Pi configures network and requests bootstrap files
4. Server sends files to client via TFTP
5. Pi boots kernel and boostrap image then complets OS boot.

The Oracle Linux team got Oracle Linux 7 working with a small 8-Pi cluster, and we had the rest of the cluster coming together, so we tested booting, but we had to boot 42 Pi at a time. This is where Ubuntu fell over. Oracle Linux 7 was tuned and worked great. Not perfect — even to this day with Oracle Linux 9 it doesn’t work perfectly. We think it’s because of network hiccups or Pi firmware glitches. Most of the time, when we boot 42 Pi they all boot. But once in a while only 37 will boot, and occasionally less than that. The process is to shut down and try again.

At this point, it’s early October 2019 the Pi cluster is nearly all assembled, the operating system is mostly working, we can boot most of the Pi, and it’s time to ship the cluster to Moscone for Open World San Francisco 2019. The design of the cluster was to bolt plywood to it and it would become the crate. The casters installed on it weren’t good for rolling, so we used a pallet jack. We actually had to remove a railing from the freight elevator to get it in, but we got it on the truck with a GoPro mounted in place so we could get transportation video. Turned out the battery died — I didn’t set it to time-lapse. I’m not a big fan of single button interfaces.

Once at Open World we set it up, installed the Java community project and managed to boot 980 Pi. The day after the Pi Cluster debuted, 42 news outlets, including Tom’s Hardware and Slashdot were reporting on the cluster. There were a few random Pi that wouldn’t boot, and a bank of 42 that I couldn’t reach which had become unplugged. But the heat was too high to leave it on for any extended period. We had 7 large fans, and had some experts come look to give us their opinion on cooling, but the common response was “well, it might work…”. The top half did. The bottom half, especially those under the server that went clear across, blocked the flow of air and those Pi overheated.

After Open World the Pi Cluster went back to the Developer Marketing Hacker Lab for upgrades and repairs and a trip around the world. It was going to London, Milan, Berlin, and New York City. But after talking with the events teams at each of these locations, the earlier requirements — 200amps of power and double doors — were difficult to satisfy. We went around and around. Finally, I decided to build one of the 84 Pi Mini Clusters I had plans for, and on December 20th 2019, it shipped out for Open World Dubai in January of 2020.

Here is a parts list for the 84 Raspberry Pi Mini Cluster.

2020

I met up with the cluster at Open World London in February 2020 and instead of a Java community project, I ran SETI@home.

This was the beginning of the pandemic, and all future events were canceled and lots of internal shuffling ensued. One big shuffle was that everything was going virtual. I realized I had a lot of video footage of building the Pi Cluster, and Pi Day was coming up, so I spent a few days editing a video trying to tell a fun story. The result was this viral video, thanks in big part to Jim Grisanzio.

At this point, I proposed a few other virtual experiences. The most notable was the LEGO© Inspired Race Car, which started the partnership between Oracle and Red Bull.

As part of the internal shuffling, there was the closing of the Developer Marketing Hacker Lab. We transferred tools and items to other labs and other storage options where possible. I transferred my lab to Oracle Labs as one of their labs, and left the Pi Cluster there with signs to save: Do Not Trash. We had the Santa Cruz fires the same week the lab was being cleared out, and I got a call that the Pi Cluster was in e-waste. When the lab was cleaned out, they cleared it out — everything that wasn’t nailed down. I drove into the office and pushed the Pi Cluster back into the lab, but a couple switches, two Pi 2U racks, and a 60-port USB power supply had been removed. There wasn’t much I could do about it — or some of the other stuff that got tossed into e-waste that had “save” written on it. After all, I was living out of a suitcase for a couple weeks after the fire evacuation. But the Pi Cluster sat like that for another year and a half. Fortunately it had two smaller 84 Pi Mini Clusters for company. In November of 2020 I recorded a video building the 2nd 84 Pi Mini Cluster in my garage and posted it to YouTube.

2022

The Pi Cluster had come up a few times in conversation but due to its unknown status and no physical conferences, it collected dust. Finally, in February of 2022, the conversations got serious. This is when the Pi Cluster came to visit me and my family at home, where it’s stayed for the past 6 months.

If you are interested in other posts, I created a blog post to include all Pi Cluster-related posts here. It has since gotten out of date but it includes everything up through 2020.

A Temporal History of The World’s Largest Raspberry Pi Cluster (that we know of) was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you prefer you can read this blog post on GitHub here.

This article may seem obvious to some, but others need to know how to get started. Having a server running in a container is the beginning of so many great things.

Prerequisites

1. Install Docker.
2. Read Create a Simple Python Web Server because we will use this Web Server but put it into a Docker container.

Build a Web Server

1. Create a folder and put all the files we are going to create into that folder.
2. Create index.html:
   
   <!DOCTYPE html>
   <html>
   <body>
   Hello World
   </body>
   </html>
3. Create server.py:

 
 #!/usr/bin/python3
 from http.server import BaseHTTPRequestHandler, HTTPServer
 import time
 import json
 from socketserver import ThreadingMixIn
 import threading

hostName = “0.0.0.0”
 serverPort = 80

class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 # curl http://<ServerIP>/index.html
 if self.path == “/”:
 # Respond with the file contents.
 self.send_response(200)
 self.send_header(“Content-type”, “text/html”)
 self.end_headers()
 content = open(‘index.html’, ‘rb’).read()
 self.wfile.write(content)

else:
 self.send_response(404)

return

class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
 “””Handle requests in a separate thread.”””

if __name__ == “__main__”:
 webServer = ThreadedHTTPServer((hostName, serverPort), Handler)
 print(“Server started http://%s:%s" % (hostName, serverPort))

try:
 webServer.serve_forever()
 except KeyboardInterrupt:
 pass

webServer.server_close()
 print(“Server stopped.”)
 ```

Put Everything into a Docker Container

1. Create Dockerfile:
   
   FROM python:3
   ADD index.html index.html
   ADD server.py server.py
   EXPOSE 8000
   ENTRYPOINT [“python3”, “server.py”]
2. cd into the folder you created.
3. Run docker build -f Dockerfile . -t web-server-test
4. Run docker run -rm -p 8000:80 — name web-server-test web-server-test

There you have it! Enjoy your web server in a Docker container. The nice thing about doing this is as a developer you can run and debug things inside a container just as if they are on your local computer but the only thing that is installed on your local system is Docker.

Create a Simple Docker Container with a Python Web Server was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

Back in the good old days GitHub allowed anonymous downloads. Now it requires username/password or ssh key. That’s no good when the Pi is out of your control. Thus, introducing the Chris Bensen Poor Man’s Auto Update. Whatever you do, do not do this at home, I am a professional and understand the security vulnerabilities.

The scenario is this: you have a script that runs on your Raspberry Pi and you need to update it. Let’s assume your script is setup to run on boot as a chron job. You can read about setting up a chron job on a Raspberry Pi here.

Steps

1. Create the local directory structure on the Pi where ‘file.py’ is your script.

/updater
├── repo
│ ├── file.py
├── file.py
├── updater.py

2. Copy this bash script.

updater.sh

#!/bin/bash

curl -X GET \
  <UrlToFile> \
  -o file.py

file1=”/users/pi/updater/repo/file.py”
file2=”/users/pi/updater/file.py”

if cmp -s “$file1” “$file2”; then
  # same, do nothing
  echo “same”
else
  # different
  echo “different”
  cp $file1 $file2

  reboot
fi

3. Create a Oracle Cloud Object Store bucket.
4. Make that bucket public.
5. Copy your file to the bucket.
6. Edit the script by changing the <UrlToFile>. Get the URL from the Object Details and remove the file name from the end so you just have the following parts of the URL: {accountRestEndpointURL}/{containerName}/{objectName}
7. Edit the script so the paths are correct.
8. Setup a chron job to run `updater.py` as often as you want to check for updates. Every 5 minutes might be overkill but let’s start with that. You can read about setting up a chron job on a Raspberry Pi here.

You can read the documentation about the downloading a file from Object Store here.

Overview

The file updater/repo/file.py is the one that gets copied down. The script then compares it to the one in the updater directory. If they are different the updater directory is updated with the new one. updater/file.py is the one you want a symlink pointed to.

The reboot in updater.py will reboot the Pi which starts the updated file.py script. I know this is not the absolute best way to do this but it works and is fairly foolproof.

So there you have it, a poor man’s auto update.

Conclusion

Now I do know with OCI Object Store you can use an API for a pre-authenticated request. If you use a REST call from the Pi, you can keep the Object Store Private. However, that is additional work and I’m going to leave that for an excersise for the user, or a future post!

Meanwhile, you can chat about this on our public Slack, or sign up for Free Tier and try it yourself.

Poor Man’s Auto Update was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you prefer you can read this blog post on GitHub here.

From the experts of binary management, JFrog, comes Pyrsia. Pyrsia is a solution to the open source software supply chain like nothing you’ve seen before. You can read a little about it here, here and here.

My high level synopsis is: It’s crazy we install open source software from builds that are not verified. Sure it’s convenient, but you might as well leave your front door open.

Pyrsia is a work in progress, but it solves all of this. Trusted entities run a Pyrsia node that builds the source and everything lives in a blockchain. This is not a blockchain to make wealth or one that will use up power plants to mine coins, this is a blockchain with a purpose. The source-to-binary transition (software supply chain) hashes are all verified and authenticated so when you download something you know a binary was built from a specific source. Take this a step further, and any security audit done will be given back to the community — so big or small companies will benefit and the entire sofware supply chain is much better off.

This is a war to protect all CPU cycles against bad actors. I guarantee we are all running trojan horses in packages or libraries we’ve installed via some package manager at one point or another. It’s impossible to protect against. Pyrsia solves this. This is why Oracle is getting involved.

If you have any questions or for interactive support and community check out Oracle’s public Slack channel for developers.

Introducing Pyrsia was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you prefer you can read this blog post on GitHub here.

Rockets are cool, so why not create a cloud connected rocket? I’m calling this one Kessel Run. Happy May the 4th be with you! This is an IoT rocket.

The flight computer is an Arduino + LoRa trasceiver + GPS + Acceleromiter broadcasting to a base station running a Raspberry Pi + LoRa transceiver connected to my cell phone’s hotspot to the internet, and sending everything to the Oracle Cloud.

Prerequisites

To build one you will need a few things.

1. You have an OCI account or a Free Tier Account.

1. Get the parts from here.

2. Download the 3D printable files from Thingiverse.

Building the Rocket

Assembly is fairly stright forward. Download the 3D printable files and the fins. If you have access to a laser cutter it’s super simple, otherwise print out the rocketfins.pdf, place it over some thing balsawood and use a craft knife to cut out three wings as stabilizers.

The nose cone comes in two pieces. To print those, I used a .4mm nozzle. If you add electronics you can also print out the battery holder, or if you use a different battery you’ll want to customize it. An easy hack is to attach the wires to the ends of the battery using electrical tape.

Flight Computer

For this step you’ll need the following items from the prerequisites above:

• Lora Transeiver
• Arduino Micro
• GPS
• Accelerometer

Wiring of the Flight Computer

Arduino Micro -> LoRa
MISO-pin 50 ->LoRa MISO
MOSI-pin 51 ->LoRa MOSI
SCK- Pin 52 ->LoRa SCK
Pin 9 ->LoRa CS
Pin 8 ->LoRa RST
Pin 7 ->LoRa G0
3.3v ->LoRa 3.3v
GND ->Lora GND

Arduino Micro -> GPS
Pin 3 -> ADXL313 SCL
Pin 2 -> ADXL313 SDA
3.3v ->ADXL313 3.3v
GND ->ADXL313 GND

Arduino Micro -> GPS
Pin 6 -> GPS TX
Pin 5 -> GPS RX
3.3v ->GPS 3.3v
GND ->GPS GND

I used the 433 MHz LoRa transeiver and it needs an antenna. For the 433 MHz band the wavelength is 299.792.458 / 433.000.000 = 69,24 cm. A quarter is 17,31 cm which is a good length so I cut a wire that length and soldered it to the antenna of both the trasmitter and receiver.

Prototype Breadboard of Flight Computer

The flight computer needed to be shrunk down, so I soldered on some headers and wired up a prototype breadboard.

Base Station

The base station is a Raspbery Pi connected to a LoRa transeiver which is connected to a phone via the phones mobile hotspot. The transceiver must be the same as the one installed in the flight computer.

Lora Transceiver
Any Pi 3 or Pi 4 will work.

Pi -> LoRa
Pi Pin MOSI -> LoRa MOSI
Pi Pin MISO -> LoRa MISO
Pi Pin SCK -> LoRa SCK
Pi Pin 25 -> LoRa CS
Pi Pin 5 -> LoRa RST
Pi Pin CE1 -> LoRa G0
Pi Pin 3.3v -> LoRa VIN
Pi Pin GND -> LoRa GND

May The Source Be With You

Upload the following sketch to the Arduino. Note that you will also need the files lora.h and lora.cpp.

cloudrocket.ino

//Board: Arduino Mega 2560
//Processor: ATMega 2560

// LoRa
// https://www.adafruit.com/product/3073
// ATMega2650 ->LoRa
// MISO-pin 50 ->LoRa MISO
// MOSI-pin 51 ->LoRa MOSI
// SCK- Pin 52 ->LoRa SCK
// Pin 7 ->LoRa CS
// Pin 6 ->LoRa RST
// Pin 2 ->LoRa G0
// SS- pin 53 //N/A
//
// Arduino Micro ->LoRa
// MISO-pin 50 ->LoRa MISO
// MOSI-pin 51 ->LoRa MOSI
// SCK- Pin 52 ->LoRa SCK
// Pin 9 ->LoRa CS
// Pin 8 ->LoRa RST
// Pin 7 ->LoRa G0
// 3.3v ->LoRa 3.3v
// GND ->Lora GND
#include <SPI.h>
#include “LoRa.h”

const int csPin = 9; // LoRa radio chip select
const int resetPin = 8; // LoRa radio reset
const int irqPin = 7; // interrupt request pin

const byte localAddress = 0xBB;
const byte destinationAddress = 0xFF;
const byte syncWord = 0xB4; // Sync word (network ID)
const byte spreadingFactor = 7; //spreading factor (6–12)

// Accelerometer
// https://learn.sparkfun.com/tutorials/sparkfun-qwiic-3-axis-accelerometer-adxl313-hookup-guide?_ga=2.60797357.1096858093.1651183108-2026033215.1651006494
// Arduino Micro -> Accelerometer
// Pin 3 -> ADXL313 SCL
// Pin 2 -> ADXL313 SDA
// 3.3v ->ADXL313 3.3v
// GND ->ADXL313 GND
#include <Wire.h>
#include <SparkFunADXL313.h>
ADXL313 myAdxl;
const int accelerometerIC2Address = 0x1D;

// GPS
// https://www.adafruit.com/product/746
// Arduino Micro -> GPS
// Pin 6 -> GPS TX
// Pin 5 -> GPS RX
// 3.3v ->GPS 3.3v
// GND ->GPS GND
#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>

SoftwareSerial GPSSerial(6, 5);
Adafruit_GPS GPS(&GPSSerial);
uint32_t timer = millis();

void setup() {
 Serial.begin(115200); // initialize serial

// — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — 
 // Initialize LoRa
 Serial.println(“LoRa Duplex Init”);
 LoRa.setPins(csPin, resetPin, irqPin); // set CS, reset, IRQ pin

if (!LoRa.begin(433E6)) { // 915E6)) { // initialize ratio at 915 MHz
 Serial.println(“Error LoRa init failed”);
 while (true);
 }

LoRa.setSyncWord(syncWord);
 LoRa.setSpreadingFactor(spreadingFactor);
 LoRa.setTxPower(20, true);
 LoRa.setTimeout(10); //set Stream timeout of 10ms
 Serial.println(“LoRa init succeeded”); //set the I/O pin modes:

// — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
 // Initialize Accelerometer
 Serial.println(“Accelerometer Init”);
 Wire.begin(accelerometerIC2Address);

//Begin communication over I2C
 if (myAdxl.begin() == false) {
 Serial.println(“Error accelerometer init failed”);
 while(1);
 }

Serial.print(“Accelerometer init succeeded”);
 myAdxl.measureModeOn(); // wakes up the sensor from standby and put it into measurement mode

// — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — 
 // Initialize GPS
 Serial.println(“GPS Software Serial”);
 GPS.begin(9600);
 // uncomment this line to turn on RMC (recommended minimum) and GGA (fix data) including altitude
 GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
 // uncomment this line to turn on only the “minimum recommended” data
 //GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
 // For parsing data, we don’t suggest using anything but either RMC only or RMC+GGA since
 // the parser doesn’t care about other sentences at this time

// Set the update rate
 GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate
 // For the parsing code to work nicely and have time to sort thru the data, and
 // print it out we don’t suggest using anything higher than 1 Hz

// Request updates on antenna status, comment out to keep quiet
 GPS.sendCommand(PGCMD_ANTENNA);

delay(1000);
 // Ask for firmware version
 GPSSerial.println(PMTK_Q_RELEASE);

Serial.println(“Setup Complete”);
 Serial.flush();
}

int counter = 0;

void sendData(String name, String value) {
 String packet = “,” + name + “,” + value;
 Serial.print(packet);
 LoRa.print(packet);
}

void loop() {
 char c = GPS.read();

if ©
 Serial.write(c);

// if a sentence is received, we can check the checksum, parse it…
 if (GPS.newNMEAreceived()) {
 // a tricky thing here is if we print the NMEA sentence, or data
 // we end up not listening and catching other sentences!
 // so be very wary if using OUTPUT_ALLDATA and trytng to print out data
 //Serial.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false

if (!GPS.parse(GPS.lastNMEA())) { // this also sets the newNMEAreceived() flag to false
 Serial.println(“GPS FAILED”);
 return; // we can fail to parse a sentence in which case we should just wait for another
 }
 }

if (!myAdxl.dataReady()) {// check data ready interrupt, note, this clears all other int bits in INT_SOURCE reg
 Serial.println(“Waiting for dataReady.”);
 }
 else {
 myAdxl.readAccel();

// send packet
 LoRa.beginPacket();
 LoRa.print(“BEGIN,”);
 sendData(“id”, String(counter));
 sendData(“src”, String(localAddress));
 sendData(“dest”, String(destinationAddress));
 sendData(“x”, String(myAdxl.x));
 sendData(“y”, String(myAdxl.y));
 sendData(“z”, String(myAdxl.z));
 sendData(“day”, String(GPS.day, DEC));
 sendData(“month”, String(GPS.month, DEC));
 sendData(“year”, String(GPS.year, DEC));
 sendData(“fix”, String((int)GPS.fix));
 sendData(“quality”, String((int)GPS.fixquality));

if (GPS.fix) {
 sendData(“latitude”, String(GPS.latitude, 4));
 sendData(“lat”, String(GPS.lat));
 sendData(“longitude”, String(GPS.longitude, 4));
 sendData(“long”, String(GPS.lon));
 sendData(“knots”, String(GPS.speed));
 sendData(“angle”, String(GPS.angle));
 sendData(“altitude”, String(GPS.altitude));
 sendData(“satellites”, String((int)GPS.satellites));
 }
 LoRa.print(“,END”);
 Serial.println();
 LoRa.endPacket();
 }

counter++;
 delay(50);
}

lora.py

import time
import busio
from digitalio import DigitalInOut, Direction, Pull
import board
import adafruit_rfm9x
import requests
import os
import json

URL = os.getenv(‘URL’)
print(URL)

if (URL is None):
 print(“URL environment variable not found”)

flight_file = open(“lora.log”, “a+”)

# Configure LoRa Radio
CS = DigitalInOut(board.CE1)
RESET = DigitalInOut(board.D25)
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, 433.0)#915.0)
rfm9x.tx_power = 23

def get_val(data, name):
 index = data.index(name)

if index != None:
 return data[index + 1]

return None

def make_json(data, fields):
 result = {}

for i in range(len(fields)):
 name = fields[i]
 result[name] = get_val(data, name)

return result

while True:
 packet = None
 rssi = rfm9x.last_rssi

# check for packet rx
 packet = rfm9x.receive(with_header=True)
 if packet is None:
 print(“waiting”)
 else:
 try:
 print(packet)
 packet_text = str(packet, “ascii”)
 print(packet_text)
 data = packet_text.split(“,”)
 print(data)

print(get_val(data, “x”), get_val(data, “y”), get_val(data, “z”))

fields = [‘id’, ‘x’, ‘y’, ‘z’]
 j = make_json(data, fields)
 j[“signal”] = “{0} dB”.format(rssi)

if (URL is not None):
 response = requests.post(URL, json = j)

flight_file.write(json.dumps(j))
 flight_file.write(“,\n”)
 except:
 print(“except”)

Copy lora.py to your Pi.

Cloud

Run with python3 lora.py. If you create the environment variable export URL=<endpoint> all the data will be streamed to the REST endoint. This requires an Oracle Cloud account. You can get one here: Free Tier Account.

Stay tuned for future directions how to set up the cloud for streaming.

Project Kessel Run was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you prefer you can read this blog post on Medium here.

Have you ever wanted to share a file with someone, but it contained sensitive information? Many people think email is secure, but it isn’t. There are services, like DropBox and Google Drive, but who knows what happens with that file after you delete itm as you really don’t have full control. Here is a mechanism that I personally use that is security through serious obscurity and it is a one-time download. Let’s get started!

Prerequisites

1. Set up a web server.

Find out more about Compute and other Oracle Cloud documentation here. For interactive support and community check out Oracle’s public Slack channel for developers.

Set up File Drop

1. Now that you have all the prerequisites set up for a web server, instead of running server.py we’re going to use filedrop.py. Copy filedrop.py to your Compute instance:

scp filedrop.py opc@${INSTANCE_IP}:/home/opc

filedrop.py

# Python 3 file drop example
    # Run: python3 server.py
    from http.server import BaseHTTPRequestHandler, HTTPServer
    import time
    import os
    import argparse

parser = argparse.ArgumentParser(description="File drop.")
    parser.add_argument("ip", type=str)
    parser.add_argument("port", type=int, default=2022)
    parser.add_argument("filename", type=str)
    parser.add_argument("droppath", type=string)
    parser.add_argument("dropname", type=string)
    parser.add_argument("dropvalue", type=string)
    args = parser.parse_args()

address = (args.ip, args.port)
    filename = args.filename
    droppath = args.droppath
    dropname = args.dropname
    dropvalue = args.dropvalue

print("IP=" + args.ip)
    print("Port=" + str(args.port))
    if os.path.exists(filename):
  print("Filename=" + filename)
    print("Path=" + droppath)
    print("Name=" + dropname)
    print("Value=" + dropvalue)

class MyServer(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header("Content-type", "application/octet-stream")
        self.send_header("Content-Disposition", "attachment; filename=" + filename)
        self.end_headers()

path = self.path
        name = ""
        value = ""

if '?' in path:
          path, args = path.split('?', 1)
          name, value = args.split('=', 1)

if path == "/" + droppath and name == dropname and value == dropvalue:
            fo = open(filename, "rb")
            self.wfile.write(fo.read())
            fo.close()
            print("success")

os.remove(filename)

print(path, name, value)
        return

if __name__ == "__main__":
    webServer = HTTPServer(address, MyServer)
    print("Server started http://%s:%s" % address)

try:
        webServer.serve_forever()
    except KeyboardInterrupt:
        pass

webServer.server_close()
    print("Server stopped.")

parser = argparse.ArgumentParser(description=”File drop.”)
 parser.add_argument(“ip”, type=str)
 parser.add_argument(“port”, type=int, default=2022)
 parser.add_argument(“filename”, type=str)
 parser.add_argument(“droppath”, type=string)
 parser.add_argument(“dropname”, type=string)
 parser.add_argument(“dropvalue”, type=string)
 args = parser.parse_args()

address = (args.ip, args.port)
 filename = args.filename
 droppath = args.droppath
 dropname = args.dropname
 dropvalue = args.dropvalue

print(“IP=” + args.ip)
 print(“Port=” + str(args.port))
 if os.path.exists(filename):
 print(“Filename=” + filename)
 print(“Path=” + droppath)
 print(“Name=” + dropname)
 print(“Value=” + dropvalue)

class MyServer(BaseHTTPRequestHandler):
 def do_GET(self):
 self.send_response(200)
 self.send_header(“Content-type”, “application/octet-stream”)
 self.send_header(“Content-Disposition”, “attachment; filename=” + filename)
 self.end_headers()

path = self.path
 name = “”
 value = “”

if ‘?’ in path:
 path, args = path.split(‘?’, 1)
 name, value = args.split(‘=’, 1)

if path == “/” + droppath and name == dropname and value == dropvalue:
 fo = open(filename, “rb”)
 self.wfile.write(fo.read())
 fo.close()
 print(“success”)

os.remove(filename)

print(path, name, value)
 return

if __name__ == “__main__”:
 webServer = HTTPServer(address, MyServer)
 print(“Server started http://%s:%s" % address)

try:
 webServer.serve_forever()
 except KeyboardInterrupt:
 pass

webServer.server_close()
print(“Server stopped.”)

1. Collect a few variables:

**INSTANCE_IP** — You have this from the web server prerequisite earlier.
**Port** — You have this from the web server prerequisite earlier.
**Filename** — This is the file that you want to share.
**PathToFile** — This is where the file is located on the compute instance.
**Name** — This is just a random string that you will come up with.
**Value** — Same as Name above.
**PrivateIP** — This is the private IP address of your server.

1. Copy your file to the compute instance:
scp -i ~/.ssh/oci_id_rsa foo.zip opc@${INSTANCE_IP}:/home/opc

1. run the server
sudo python3 filedrop.py <PrivateIP> <Port> <Filename> <PathToFile> <Name> <Value> &

For example:
scp foo.zip ocp@1.2.3.4:/home/pi
sudo python3 filedrop.py 1.2.3.4 8100 foo.zip chris knockknock whothat &

1. From any computer use a web browser and access the url http://<YourPublicIP>:<Port>/PathToFile?Name=Value to download the file.

For Example:
http://<YourPublicIP>:8100/chris/foo.zip?knockknock=whothat

The file will be downloaded, and then deleted from the VM. If any attempt to access the wrong URL occurs the file will be deleted. Share this URL with whomever you want to download the file.

What I find gratifying: I can send the URL in pieces and the other person must assemble it correctly, but if they fail the file will be deleted. This can be a pain, so I usually have a phone call if I choose this option. I trust “security through obscurity” in this limited case, but I prefer for it to be as real-time as possible. It’s your choice, but thought I’d share because sending confidiential information over email is not a good idea.

If you have any questions or for interactive support and community check out Oracle’s public Slack channel for developers.