MADE BY NOVA ACADEMY · FOR ARDUINO

Name it. Tell it. Watch it move

Nova is our own beginner-friendly language for programming Arduino. Learners name the parts they wired, then tell them what to do in plain words. When they are ready, the same program opens as Arduino C++.

Try it now Bring Nova to your school

door_alarm.nova ● RUNNING

1  led status   = led pin 13
2  button door  = button pin 2
3  buzzer alarm = buzzer pin 6
4  
5  when door pressed:
6      status on
7      alarm tone 440 Hz
8      wait 500 ms
9      status off

NOVA LANG > THE IDEA

Three ideas, no jargon

01
Name your parts

Learners give every LED, button and motor they wired a name of their own: status, door, alarm. The code talks about the build, not about pin numbers.
```
led status = led pin 13
button door = button pin 2
```
02
Say what happens

Programs read like instructions to a friend. When the door is pressed, turn the status light on, sound the alarm, wait, turn it off.
```
when door pressed:
    status on
    wait 500 ms
```
03
Grow into C++

Nova sits between blocks and Arduino code. When learners are ready, the same program opens as Arduino C++, so nothing they wrote is thrown away.
```
// C++
if (digitalRead(DOOR) == LOW) {
  digitalWrite(STATUS, HIGH);
}
```

MADE BY NOVA ACADEMY

Meet Nova, the language our learners grow into.

Nova sits between blocks and Arduino code. Learners name the parts they wired, then tell them what to do in plain words. When they are ready, the same program opens as Arduino C++.

1  led status = led pin 13
2  button door = button pin 2
3  buzzer alarm = buzzer pin 6
4  
5  when door pressed:
6      status on
7      alarm tone 440 Hz
8      wait 500 ms
9      status off

NOVA LANG > A TOUR OF THE LANGUAGE

Five things Nova can say

Parts

Every program starts by naming the parts on the desk and the pins they are wired to.

```
led status = led pin 13
```
A light on pin 13, called status.
```
buzzer alarm = buzzer pin 6
```
A buzzer that can play tones.
```
servo shoulder = servo pin 9
```
A motor that turns to an angle.
```
sensor left = line sensor pin A0
```
Sees whether it is over a line.
```
sensor eyes = distance sensor pin 7
```
Measures how far away things are.
```
motors drive = motor pair pins 5 6
```
Two wheels driven together.

Events

Code that waits for something to happen in the world, then runs.

```
when door pressed:
    status on
```
Runs every time the button is pressed.

when start pressed:
    shoulder angle 30°

One button can set a whole machine moving.

Actions

Plain words that make parts do something, with units learners can see and hear.

```
status on
status off
```
Switch a light.
```
alarm tone 440 Hz
```
Play a note at a pitch.
```
wait 500 ms
```
Pause before the next step.
```
shoulder angle 90° over 2 s
```
Turn a servo, smoothly, over time.
```
drive forward 60 %
drive turn right
```
Move a robot car.
```
gripper close
```
Parts can have their own actions.

Loops

Machines keep working. A forever block repeats its steps for as long as the board has power.

forever:
    red on
    wait 3 s
    red off

The heart of a traffic light.

Decisions

Robots read their sensors and choose what to do next.

if left sees line:
    drive turn left
else if right sees line:
    drive turn right
else:
    drive forward 60 %

How a line-follower stays on the track.

if eyes reads under 20 cm:
    drive turn right

Turning away before it hits a wall.

▸ TRY NOVA · OUR OWN LANGUAGE

Press the button.
Watch the code run.

Nova lets learners name the parts they wired and tell them what to do in plain words. It's the bridge between blocks and Arduino code.

door_alarm.nova ● IDLE

1  led status = led pin 13
2  button door = button pin 2
3  buzzer alarm = buzzer pin 6
4  
5  when door pressed:
6      status on
7      alarm tone 440 Hz
8      wait 500 ms
9      status off

SERIAL

> uploaded to Arduino Uno
> waiting for door…

FIG. 02 — BREADBOARD

status · pin 13

alarm · pin 6

ALARM TONE440 Hz

Pressed 0 times · drag the slider, then press again

NOVA LANG > PROGRAMS FROM CLASS

Whole programs, start to finish

Smallest first ↓

traffic_light.nova AGES 09–12

1  led red   = led pin 4
2  led green = led pin 3
3  
4  forever:
5      red on
6      wait 3 s
7      red off
8      green on
9      wait 3 s
10     green off

Traffic light

First real circuit: two LEDs, one loop.

door_alarm.nova AGES 12–15

1  led status   = led pin 13
2  button door  = button pin 2
3  buzzer alarm = buzzer pin 6
4  
5  when door pressed:
6      status on
7      alarm tone 440 Hz
8      wait 500 ms
9      status off

Door alarm

Inputs and outputs: a press sets off a light and a sound.

line_follower.nova AGES 15–18

1  sensor left  = line sensor pin A0
2  sensor right = line sensor pin A1
3  motors drive = motor pair pins 5 6
4  
5  forever:
6      if left sees line:
7          drive turn left
8      else if right sees line:
9          drive turn right
10     else:
11         drive forward 60 %

Line follower

Two sensors and a decision keep the car on the tape.

avoid_car.nova AGES 15–18

1  sensor eyes  = distance sensor pin 7
2  motors drive = motor pair pins 5 6
3  
4  forever:
5      if eyes reads under 20 cm:
6          drive turn right
7      else:
8          drive forward 70 %

Obstacle-avoiding car

A team build: sense, decide, move on its own.

NOVA LANG > WHERE IT FITS

Blocks first, then Nova

05–08 LOWER PRIMARY Scratch
09–12 UPPER PRIMARY Scratch · Arduino
12–15 JHS Arduino · Nova ● NOVA STAGE
15–18 SHS Nova · Arduino C++ ● NOVA STAGE

See the full pathway

NOVA LANG > FAQ

About Nova

Want Nova in your school? Send us a message below.

Learners who have outgrown blocks. In our pathway, Nova comes in around JHS (ages 12–15), after Scratch, and carries through to SHS team builds.

Name it. Tell it. Watch it move

Three ideas, no jargon

Name your parts

Say what happens

Grow into C++