Watch your houseplant’s growth really take off in this Saturn V planter

via Arduino Blog

As first reported by Technabob, almost two years after he made a rather stunning Saturn V lamp, SimonRob decided to create something a bit different in the form of his Saturn V planter.

The device is based on the lower section portion of a 3D-printable rocket model, which is modified and sealed to hold dirt and water. A succulent now pops out where the rest of the rocket should be, and when combined with a 30mm thick wood plank, gives it a very unique and polished look.

A switch on the front lights up the printed flame assemblies emanating from the engines, using a trio of SMD LEDs on each exhaust. These LEDs are controlled by an Arduino Nano nestled inside the wooden base to produce random lighting effects when an activation button is pressed.

Touchless light show with the Qwiic Dual Solid State Relay

via SparkFun: Commerce Blog

Last week we released the SparkFun Qwiic Dual Solid State Relay, and as is usually the case, I was tasked with learning about it, then scripting and filming a video to tell all of you about it. This happens pretty much every week, and while the varying technologies of each new product come with their own learning curves, recent wrinkles like supply chain issues and the limited time I can spend at SparkFun (for employee safety) have added new wrinkles into the timeline of releasing a new product.

SparkFun Qwiic Dual Solid State Relay

SparkFun Qwiic Dual Solid State Relay

COM-16810
$149.95

Naturally we keep a schedule of what products we’re expecting to release in the coming weeks. I pore over datasheets, read through the libraries our engineers are building, and try to come up with ideas that might make for an interesting demo build. Of course, working from home is not the same as heading into SFHQ every day. The ideas that race through my mind haven’t changed, but the inventory on hand certainly has. There have been times over the past six months when I have come up with a build idea, only to have my dreams dashed when I dig through my parts drawer and find that I don’t possess the component around which I was planning my build. This week was a good example of that. I knew that I had multiple VL53L1X Distance Sensors on hand, but knowing that they have a hardware defined I2C address, I knew that I would need a Qwiic MUX Breakout to use more than one of these sensors. And it turned out that I didn't have a MUX on hand. So I pulled the Qwiic VCNL4040 Proximity Sensor off of a previous project, and proceeded forward.

Proximity sensors
VL53L1X Proximity sensors aplenty, but without a MUX, I'm limited to using only one

Sometimes this theoretical portion of my work week ("this should work...theoretically") leads me right up the moment when I have to start filming the new video. Such was the case this week. I didn’t get my hands on the Qwiic Dual SSR until I arrived at SFHQ to do the filming. Luckily I had completed the outline for the video, as well as the sketch for the demo build, so I figured it would be as simple as connecting the relay board via its Qwiic connector, wiring the load side and watching it work.

That’s not exactly how it happened.

alt text
Even though the ranges of the two sensors differ, for this build they were both perfectly suited

I connected everything together and powered it up, and nothing happened. Since I had written and tested the sketch on a different Qwiic relay board, I figured that since our Qwiic Relay Library for Arduino is universal across all of our Qwiic Relay boards, all I’d need to do would be to change the I2C address, and everything would work perfectly – but it didn’t. I checked all of the connections, examined my sketch, looked at the library to make sure I was using the correct I2C address for the new Dual Solid State Relay board, and all of it checked out.

I ran an I2C sniffer, and voila! Even though the board powered up, and I got the status light, I was not receiving an I2C address from the board. With the timeline we impose on ourselves for many of our boards, there will be times when a board will come up to the Marketing department hot off the reflow oven so that our (amazing) photographer Juan can get images of the component and get them to the folks who are putting together the product web page. Sometimes in the process, the components accidentally bypass the firmware flash stage. I simply took the board down to production, they flashed it, I plugged it back into my setup, and everything was Jake!

The code for the project was just a very basic amalgamation of the first examples of each of the VL53L1X distance sensor, the VCNL4040 Proximity Sensor, and the Qwiic Dual Solid State Relay. I added a delay in the void loop so I could watch the proximity digits for each sensor, then used those to set the limits to trigger each of the two relays.

/*
 * Dual Solid State Relay Demo
 * Rob Reynolds, SparkFun Electronics, September 2020
 * Using two separate sensors, this demo
 * toggles the two relays of the SparkFun Qwiic
 * Dual Solid State Relay on and off as you
 * hold your hands over the sensors.
 * 
 * SparkFun labored with love to create this code. Feel like supporting open source hardware?
 * Buy a board or two from SparkFun!
 * SparkFun Qwiic Dual Solid State Relay - (https://www.sparkfun.com/products/16810)
 * SparkFun Distance Sensor Breakout VL53L1X - (https://www.sparkfun.com/products/14722)
 * SparkFun Proximity Sensor Breakout VCNL4040 - (https://www.sparkfun.com/products/15177)
 * 
 * License: This code is public domain but you buy me a beer if you use 
 * this and we meet someday (Beerware license).
 */

#include <Wire.h>

//**********VCNL4040 Setup here***************
//Click here to get the library: http://librarymanager/All#SparkFun_VCNL4040
#include "SparkFun_VCNL4040_Arduino_Library.h"
VCNL4040 proximitySensor;

//*********VL53L1X Setup here***************
#include <ComponentObject.h>
#include <RangeSensor.h>
#include <SparkFun_VL53L1X.h>
#include <vl53l1x_class.h>
#include <vl53l1_error_codes.h>
#include "SparkFun_VL53L1X.h" //Click here to get the library: http://librarymanager/All#SparkFun_VL53L1X

SFEVL53L1X distanceSensor;

//************Here's the Dual SSR section***********
#include "SparkFun_Qwiic_Relay.h"
#define RELAY_ADDR 0x0A // Alternate address 0x6C
Qwiic_Relay dualRelay(RELAY_ADDR); 

void setup()
{
  Serial.begin(115200);
  Serial.println("SparkFun VCNL4040 Example");

  Wire.begin(); //Join i2c bus

  if (proximitySensor.begin() == false)
  {
    Serial.println("Device not found. Please check wiring.");
    while (1); //Freeze!
  }

  if(!dualRelay.begin())
    Serial.println("Check connections to Qwiic Relay.");
  else
    Serial.println("Dual Relay Light Show!!");

  Serial.println("VL53L1X Qwiic Test");

  if (distanceSensor.begin() != 0) //Begin returns 0 on a good init
  {
    Serial.println("Sensor failed to begin. Please check wiring. Freezing...");
    while (1)
      ;
  }
  Serial.println("Sensor online!");

  dualRelay.turnAllRelaysOff();

  delay(1000);
}

void loop()
{
  //Get proximity value. The value ranges from 0 to 65535
  //so we need an unsigned integer or a long.
  unsigned int proxValue = proximitySensor.getProximity(); 

  Serial.print("Proximity Value: ");
  Serial.print(proxValue);
  Serial.println();

  delay(10);

  if (proxValue > 12){
    dualRelay.turnRelayOn(1);
    delay(50);
  }

  else if (proxValue < 12){
    dualRelay.turnRelayOff(1);
    delay(50);
}

  //********VL53L1X section*************
  distanceSensor.startRanging(); //Write configuration bytes to initiate measurement
  while (!distanceSensor.checkForDataReady())
  {
    delay(1);
  }

  int distance = distanceSensor.getDistance(); //Get the result of the measurement from the sensor
  distanceSensor.clearInterrupt();
  distanceSensor.stopRanging();

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println();

  if (distance < 400){
    dualRelay.turnRelayOn(2);
    Serial.println("Relay 4 is hot.");
    delay(50);
  }

  else if (distance > 400){
    dualRelay.turnRelayOff(2);
    delay(50);
  }

  //delay(500); //uncomment this delay for testing
}

Again, when working on the high voltage side, make sure that you are knowledgeable and comfortable with that level of potentially lethal voltage. Even though we have built safety measures into this board, like ground isolation between the relay and control circuitry and a milled out area isolating each side of the AC, without proper attention to detail this can be a dangerous product. If you're not quite ready to wire up your own AC lines, the IoT Power Relay is a good solution while you increase your knowledge of high voltage circuits.

If you are planning on creating your own light show, or any other relay-driven project, don't forget that you're not limited to a pair of relays on a single board. Since the ATTiny84A on the Dual Solid State Relay is software configurable, and communicates over I2C, you can daisy-chain over one hundred boards together, allowing you to create an entire light wall that you control by waving your arms around. Yeah, now who's DJ GOAT?!

Evil genius at work

Choosing the proper music is paramount to feeling like you might actually be able to take over the world

comments | comment feed

“Tinkering is an equity issue” | Hello World #14

via Raspberry Pi

In the brand-new issue of Hello World magazine, Shuchi Grover tells us about the limits of constructionism, the value of formative assessment, and why programming can be a source of both joy and angst.

How much open-ended exploration should there be in computing lessons?

This is a question at the heart of computer science education and one which Shuchi Grover is delicately diplomatic about in the preface to her new book, Computer Science in K-12: An A-to-Z Handbook on Teaching Programming. The book’s chapters are written by 40 teachers and researchers in computing pedagogy, and Grover openly acknowledges the varying views around discovery-based learning among her diverse range of international authors.

“I wonder if I want to wade there,” she laughs. “The act of creating a program is in itself an act of creation. So there is hands-on learning quite naturally in the computer science classroom, and mistakes are made quite naturally. There are some things that are so great about computer science education. It lends itself so easily to being hands-on and to celebrating mistakes; debugging is par for the course, and that’s not the way it is in other subjects. The kids can actually develop some very nice mindsets that they can take to other classrooms.”

Shuchi Grover showing children something on a laptop screen

Grover is a software engineer by training, turned researcher in computer science education. She holds a PhD in learning sciences and technology design from Stanford University, where she remains a visiting scholar. She explains how the beginning of her research career coincided with the advent of the block-based programming language Scratch, now widely used as an introductory programming language for children.

“Almost two decades ago, I went to Harvard to study for a master’s called technology innovation and education, and it was around that time that I volunteered for robotics workshops at the MIT Media Lab and MIT Museum. Those were pretty transformative for me: I started after-school clubs and facilitated robotics and digital storytelling clubs. In the early 2000s, I was an educational technology consultant, working with teachers on integrating technology. Then Scratch came out, and I started working with teachers on integrating Scratch into languages, arts, and science, all the things that we are doing today.”

A girl with her Scratch project
Student Joyce codes in Scratch at her Code Club in Nunavut

Do her formative experiences at MIT, the birthplace of constructionist theory of student-centred, discovery-based learning, lead her to lean one way or another in the tinkering versus direct instruction debate? “The learning in informal spaces is, of course, very interest-driven. There is no measurement. Children are invited to a space to spend some time after school and do whatever they feel like. There would be kids who would be chatting away while a couple of them designed a robot, and then they would hand over the robot to some others and say, ‘OK, now you go ahead and program it,’ and there were some kids who would just like to hang about.

“When it comes to formal education, there needs to be more accountability, you want to do right by every child. You have to be more intentional. I do feel that while tinkering and constructionism was a great way to introduce interest-driven projects for informal learning, and there’s a lot to learn from there and bring to the formal learning context, I don’t think it can only be tinkering.”

“There needs to be more accountability to do right by every child.”

“Everybody knows that engagement is very important for learning — and this is something that we are learning more about: it’s not just interest, it’s also culture, communities, and backgrounds — but all of this is to say that there is a personal element to the learning process and so engagement is necessary, but it’s not a sufficient condition. You have to go beyond engagement, to also make sure that they are also engaging with the concepts. You want at some point for students to engage with the concept in a way that reveals what their misconceptions might be, and then they end up learning and understanding these things more deeply.

“You want a robust foundation — after all, our goal for teaching children anything at school is to build a foundation on which they build their college education and career and anything beyond that. If we take programming as a skill, you want them to have a good understanding of it, and so the personal connections are important, but so is the scaffolding.

“How much scaffolding needs to be done varies from context to context. Even in the same classroom, children may need different levels of scaffolding. It’s a sweet spot; within a classroom a teacher has to juggle so much. And therein lies the challenge of teaching: 30 kids at a time, and every child is different and every child is unique.

“It’s an equity issue. Some children don’t have the prior experience that sets them up to tinker constructively. After all, tinkering is meant to be purposeful exploration. And so it becomes an issue of who are you privileging with the pedagogy.”

She points out that each chapter in her book that comes from a more constructionist viewpoint clearly speaks of the need for scaffolding. And conversely, the chapters that take a more structured approach to computing education include elements of student engagement and children creating their own programs. “Frameworks such as Use-Modify-Create and PRIMM just push that open-ended creation a little farther down, making sure that the initial experiences have more guide rails.”

Approaches to assessment

Grover is a senior research scientist at Looking Glass Ventures, which in 2018 received a National Science Foundation grant to create Edfinity, a tool to enable affordable access to high-quality assessments for schools and universities.

In her book, she argues that asking students to write programs as a means of formative assessment has several pitfalls. It is time-consuming for both students and teachers, scoring is subjective, and it’s difficult to get a picture of how much understanding a student has of their code. Did they get their program to work through trial and error? Did they lift code from another student?

“Formative assessments that give quick feedback are much better. They focus on aspects of the conceptual learning that you want children to have. Multiple-choice questions on code force both the teachers and the children to experience code reading and code comprehension, which are just so important. Just giving children a snippet of code and saying: ‘What does this do? What will be the value of the variable? How many times will this be executed?’ — it goes down to the idea of code tracing and program comprehension.

“Research has also shown that anything you do in a classroom, the children take as a signal. Going back to the constructionist thing, when you foreground personal interest, there’s a different kind of environment in the classroom, where they’re able to have a voice, they have agency. That’s one of the good things about constructionism.

“Formative assessment signals to the student what it is that you’re valuing in the learning process. They don’t always understand what it is that they’re expected to learn in programming. Is the goal creating a program that runs? Or is it something else? And so when you administer these little check-ins, they bring more alignment between a teacher’s goals for the learners and the learners’ understanding of those goals. That alignment is important and it can get lost.”

Grover will present her latest research into assessment at our research seminar series next Tuesday 6 October — sign up to attend and join the discussion.

The joy and angst of programming

The title of Grover’s book, which could be thought to imply that computer science education consists solely of teaching students to program, may cause some raised eyebrows.

What about building robots or devices that interact with the world, computing topics like binary, or the societal impacts of technology? “I completely agree with the statement and the belief that computer science is not just about programming. I myself have been a proponent of this. But in this book I wanted to focus on programming for a couple of reasons. Programming is a central part of the computer science curriculum, at least here in the US, and it is also the part that teachers struggle with the most.

“I want to show where children struggle and how to help them.”

“As topics go, programming carries a lot of joy and angst. There is joy in computing, joy when you get it. But when a teacher is encountering this topic for the first time there is a lot of angst, because they themselves may not be understanding things, and they don’t know what it is that the children are not understanding. And there is this entire body of research on novice programming. There are the concepts, the practices, the pedagogies, and the issues of assessment. So I wanted to give the teachers all of that: everything we know about children and programming, the topics to be learnt, where they struggle, how to help them.”

Computer Science in K-12: An A-to-Z Handbook on Teaching Programming (reviewed in this issue of Hello World) is edited by Shuchi Grover and available now.

Hear more from Shuchi Grover, and subscribe to Hello World

We will host Grover at our next research seminar, Tuesday 6 October at 17:00–18:30 BST, where she will present her work on formative assessment.

Hello World is our magazine about all things computing education. It is free to download in PDF format, or you can subscribe and we will send you each new issue straight to your home.

In issue 14 of Hello World, we have gathered some inspiring stories to help your learners connect with nature. From counting penguins in Antarctica to orienteering with a GPS twist, great things can happen when young people get creative with technology outdoors. You’ll find all this and more in the new issue!

Educators based in the UK can subscribe to receive print copies for free!

The post “Tinkering is an equity issue” | Hello World #14 appeared first on Raspberry Pi.

This interactive screen slides smoothly from side to side

via Arduino Blog

When you need to grab someone’s attention at an event, an interactive screen is a good idea. MakerMan, however, went several steps beyond this, creating an installation with a bank of static screens that depict the Moscow skyline. In front of this, a single touch-enabled display moves back and forth automatically to present information on various points of interest.

Sliding action is handled by a large stepper motor, which pulls the screen along on a carriage assembly. The motor, in turn, is controlled via an Arduino Uno and a stepper driver. All of these electronics are hidden behind a nicely painted wooden facade, letting the technology driving it fade elegantly into the background.

This Arduino-controlled soft robot gets around like an earthworm

via Arduino Blog

After studying the way a worm wiggles, Nicholas Lauer decided to create his own soft robotic version. What he came up with uses an Arduino Uno for control, inflating six 3D-printed segments sequentially to order to generate peristaltic motion for forward movement.

The robotic worm uses a 12V mini diaphragm pump to provide inflation air, while a series of transistors and solenoid valves directly regulate the airflow into the chambers.

The build looks pretty wild in the video below, and per Lauer’s write-up, you’re encouraged to experiment to see what kind of timing produces the most expedient motion. Code, STLs, and a detailed BOM are available on GitHub.

Raspberry Pi High Quality Camera takes photos through thousands of straws

via Raspberry Pi

Adrian Hanft is our favourite kind of maker: weird. He’s also the guy who invented the Lego camera, 16 years ago. This time, he spent more than a year creating what he describes as “one of the strangest cameras you may ever hear about.”

What? Looks normal from here. Massive, but normal

What’s with all the straws?

OK, here’s why it’s weird: it takes photos with a Raspberry Pi High Quality Camera through a ‘lens’ of tiny drinking straws packed together. 23,248 straws, to be exact, are inside the wooden box-shaped bit of the machine above. The camera itself sits at the slim end of the black and white part. The Raspberry Pi, power bank, and controller all sit on top of the wooden box full of straws.

Here’s what an image of Yoda looks like, photographed through that many straws:

Mosaic, but make it techy

Ground glass lenses

The concept isn’t as easy as it may look. As you can see from the images below, if you hold up a load of straws, you can only see the light through a few of them. Adrian turned to older technology for a solution, taking a viewfinder from an old camera which had ground glass (which ‘collects’ light) on the surface.

Left: looking through straws at light with the naked eye
Right: the same straws viewed through a ground glass lens

Even though Adrian was completely new to both Raspberry Pi and Python, it only took him a week of evenings and weekends to code the software needed to control the Raspberry Pi High Quality Camera.

Long story short, on the left is the final camera, with all the prototypes queued up behind it

An original Nintendo controller runs the show and connects to the Raspberry Pi with a USB adapter. The buttons are mapped to the functions of Adrian’s software.

A super satisfying time-lapse of the straws being loaded

What does the Nintendo controller do?

In his original post, Adrian explains what all the buttons on the controller do in order to create images:

“The Start button launches a preview of what the camera is seeing. The A button takes a picture. The Up and Down buttons increase or decrease the exposure time by 1 second. The Select button launches a gallery of photos so I can see the last photo I took. The Right and Left buttons cycle between photos in the gallery. I am saving the B button for something else in the future. Maybe I will use it for uploading to Dropbox, I haven’t decided yet.”

Adrian made a Lego mount for the Raspberry Pi camera
The Lego mount makes it easy to switch between cameras and lenses

A mobile phone serves as a wireless display so he can keep an eye on what’s going on. The phone communicates with the Raspberry Pi connected to the camera via a VPN app.

One of the prototypes in action

Follow Adrian on Instagram to keep up with all the photography captured using the final camera, as well as the prototypes that came before it.

The post Raspberry Pi High Quality Camera takes photos through thousands of straws appeared first on Raspberry Pi.