How to craft picaxe microcontroller projects efficiently

Programming PICAXE: Syntax, Commands, and Basic Logic

Syntax Fundamentals: Data Types and Variable Declarations

- Byte (8-bit): Stores integer values from 0 to 255. Used for single-byte variables, digital I/O states, or small numeric operations.

Variables are declared using the `VAR` keyword, followed by the data type and name. Scope is limited to the current program or subroutine unless explicitly shared. Best Practice: Prefer `byte` for most applications to conserve memory; use `word` only when necessary for calculations exceeding 255.

Example Variable Declarations:

VAR byte counter, sensorValue
VAR word totalSum
VAR bcd displayValue

Core Programming Commands: Categorized by Function

### Input/Output Control
Commands for digital and analog I/O, PWM generation, and pin state manipulation.

1. Digital I/O Setup and Control
   
2. `HI pin`: Sets a specified pin as HIGH (output mode, logic 1).
3. `LO pin`: Sets a specified pin as LOW (output mode, logic 0).
4. `DIRS pin_list`: Configures pins as input (0) or output (1) using a bitmask.
5. `INPUT pin`: Reads a digital input (returns 0 or 1).

Example: Blinking an LED (Pin 0)

HI 0 'Initialize Pin 0 as output (implicit in HI/LO)
main:
HI 0 'Turn LED on
PAUSE 500
LO 0 'Turn LED off
PAUSE 500
GOTO main


6. PWM and Pulse Generation
   
7. `PULSOUT pin, duration`: Outputs a single pulse of specified microsecond duration.
8. `PWM pin, duty_cycle`: Enables PWM on a pin with a 0–255 duty cycle (0% to 100%).

Example: Servo Motor Control (Pulse Width 1–2 ms)

PULSOUT 0, 1500 '1.5 ms pulse (center position)


9. Analog Input/Output
   
10. `READAD pin`: Reads 10-bit ADC value (0–1023) from an analog input.
11. `SEROUT pin, N2400, (value)`: Transmits analog data via serial (e.g., for DACs).

Example: Reading a Potentiometer

READAD 0, value 'Store ADC reading in variable 'value'

Timing and Delays

1. Blocking Delays
   
2. `PAUSE ms`: Halts execution for milliseconds (1–255 ms).
3. `PAUSEus us`: Halts execution for microseconds (1–255 µs).

Example: Non-blocking Debounce (Using Timer)

IF PIN0 = 1 AND timer < 50 THEN 'Debounce delay
timer = timer + 1
ELSE
'Proceed with action
ENDIF


4. Timers and Counters
   
5. `TIMER = 0`: Resets the internal 16-bit timer.
6. `IF TIMER > threshold THEN ...`: Checks elapsed time (overflows every ~65.5 ms).

Example: Watchdog Timer Reset

TIMER = 0
main:
'Main loop
IF TIMER > 100 THEN 'Reset if loop takes >100 ms
RESET
ENDIF
GOTO main

Mathematical Operations

1. Arithmetic
   
2. `variable = expression`: Supports `+`, `-`, `*`, `/`, and `MOD` (modulus).
3. Note: Division truncates toward zero; use `MOD` for remainders.

Example: Moving Average Filter

VAR byte samples(5), sum, index
sum = 0
FOR index = 0 TO 4
READAD 0, samples(index)
sum = sum + samples(index)
NEXT
average = sum / 5 'Integer division


4. Bitwise Operations
   
5. `AND`, `OR`, `XOR`, `NOT`: Operate on bytes or words.
6. Use Case: Masking bits for hardware registers (e.g., `PORTB = PORTB AND %00001111`).

Example: Toggle a Bit Without Affecting Others

PORTB = PORTB XOR %00001000 'Toggle bit 3

Control Flow and Logic

1. Conditionals
   
2. `IF condition THEN ... ENDIF`: Supports `=`, `<>`, `<`, `>`, `<=`, `>=`.
3. `ELSEIF` and `ELSE` for multi-condition checks.

Example: Hysteresis Control for a Thermistor

READAD 0, temp
IF temp > 800 THEN
HI 1 'Fan ON
ELSEIF temp < 700 THEN
LO 1 'Fan OFF
ENDIF


4. Loops
   
5. `FOR counter = start TO end ... NEXT`: Count-controlled loops.
6. `DO ... LOOP`: Post-test loops (executes at least once).
7. Optimization: Replace `FOR` with `WHILE` for dynamic iterations to save memory.

Example: Efficient Dimming Loop (PWM)

FOR duty = 0 TO 255 STEP 5
PWM 0, duty
PAUSE 20
NEXT


8. Subroutines and Labels
   
9. `GOSUB label`: Jumps to a subroutine; `RETURN` resumes execution.
10. Best Practice: Use labels for modularity (e.g., `init`, `main_loop`, `error_handler`).

Example: Modular Temperature Monitor

init:
HI 0 'Setup pins
GOSUB main_loop

main_loop:
READAD 0, temp
GOSUB check_temp
PAUSE 100
GOTO main_loop

check_temp:
IF temp > 900 THEN
HI 1 'Alert
ELSE
LO 1
ENDIF
RETURN

Advanced Features

1. Interrupts
   
2. `ON INTERRUPT GOSUB routine`: Enables external/interrupt-on-change (IOC) triggers.
3. Limitation: Only one active interrupt routine per program.

Example: Button Interrupt

ON INTERRUPT 0 GOSUB button_pressed
ENABLE 'Enable interrupts
button_pressed:
HI 1 'Toggle LED
RETURN


4. EEPROM Operations
   
5. `WRITE #address, value`: Stores data in non-volatile memory.
6. `READ #address, variable`: Retrieves stored values.

Example: Saving Calibration Data

WRITE #0, 100 'Store offset value
READ #0, offset


Building Practical Circuits with PICAXE: Examples and Schematics

The PICAXE microcontroller excels in interfacing with real-world components, enabling precise control of actuators, data acquisition from sensors, and human-machine interaction through displays. This section explores practical circuit design, emphasizing modularity, signal integrity, and efficient resource utilization. Schematics are described in text format with component specifications, wiring conventions, and troubleshooting considerations to ensure reproducibility.


Controlling an 8x8 LED Matrix Using Shift Registers

An 8x8 LED matrix requires 64 control lines, which exceeds the I/O pins of most PICAXE models. Shift registers (e.g., 74HC595) reduce pin usage by serially shifting data into parallel outputs. The circuit employs a cascaded shift register configuration to drive rows and columns independently, minimizing ghosting effects.

Component Selection and Wiring:


PICAXE Chip: 28X2 or 40X2 (minimum 8 I/O pins for data/clock/latch signals).

Shift Registers: Two 74HC595 (one for rows, one for columns).

LEDs: 8x8 matrix with common-cathode or common-anode configuration (common-cathode recommended for PICAXE’s 5V logic compatibility).

Resistors: 220Ω per LED to limit current to ~20mA (adjust for brightness).

Power Supply: 5V regulated (shift registers and PICAXE) with separate 12V supply for LEDs (if using high-brightness LEDs).

Text-Based Schematic Description:
1. PICAXE Connections:


Pin 0: Data (DS) of first 74HC595 (rows).

Pin 1: Clock (SH_CP) of first 74HC595.

Pin 2: Latch (ST_CP) for both shift registers.

Pin 3: Data (DS) of second 74HC595 (columns).

Pin 4: Clock (SH_CP) of second 74HC595.

GND: Common ground for PICAXE, shift registers, and LED matrix.

2. Shift Register Cascading:


Connect the QH’ (serial output) of the first 74HC595 to the DS (serial input) of the second 74HC595.

Both ST_CP (latch) pins are tied together and controlled by PICAXE Pin 2.

3. LED Matrix Wiring:


Rows (74HC595 #1 outputs Q0–Q7): Connect to the cathodes of each row (common-cathode configuration).

Columns (74HC595 #2 outputs Q0–Q7): Connect to anodes via 220Ω resistors to the 5V supply (or 12V if using high-brightness LEDs).

Multiplexing: Activate one row at a time while cycling columns to create the illusion of all LEDs lit simultaneously (PWM or timing control via PICAXE).

Code Implementation (Multiplexing Example):

#picaxe 28x2
symbol row_data var byte
symbol col_data var byte
symbol row_pin = 2 ' Latch pin
symbol col_clock = 4 ' Clock for columns
symbol row_clock = 1 ' Clock for rows

' Initialize shift registers
shiftout row_data, NIBBLE_LSBFIRST, [row_pin, row_clock, row_data]
shiftout col_data, NIBBLE_LSBFIRST, [row_pin, col_clock, col_data]

' Example: Display a single pixel at (3,4)
for b0 to 7
row_data = %00000001 << b0 ' Activate one row
col_data = %00010000 ' Activate column 4
shiftout row_data, NIBBLE_LSBFIRST, [row_pin, row_clock, row_data]
shiftout col_data, NIBBLE_LSBFIRST, [row_pin, col_clock, col_data]
pause 1
row_data = 0
shiftout row_data, NIBBLE_LSBFIRST, [row_pin, row_clock, row_data]
next b0


Interfacing Sensors and Actuators with Signal Conditioning

PICAXE interfaces with analog and digital sensors/actuators, but raw signals often require conditioning to ensure compatibility with the microcontroller’s 0–5V logic levels and noise immunity.

Sensor Interfacing:
1. Temperature Sensors (e.g., LM35, DS18B20):


LM35: Outputs 10mV/°C. Use a voltage divider (e.g., 10kΩ + 2.2kΩ) to scale the 0–5V range to PICAXE’s ADC input (0–5V).

Wiring: Connect sensor output to PICAXE ADC pin via divider; GND to PICAXE GND.

Code: Read ADC value and convert to temperature using the formula:

temp = (adc0 500) / 1023 ' LM35: 10mV/°C → 5V = 500°C (theoretical max)

- DS18B20: Requires a 4.7kΩ pull-up resistor on the data line (DQ) to 5V. Use the `onewire` library for communication.

2. Light Sensors (e.g., LDR, BH1750):


LDR: Connect in a voltage divider with a fixed resistor (e.g., 10kΩ). PICAXE reads the divided voltage via ADC.

BH1750 (I2C): Requires I2C pull-up resistors (4.7kΩ) on SDA/SCL lines to 5V. Use the `i2c` library with the sensor’s I2C address (0x23 or 0x5C).

3. Ultrasonic Sensors (e.g., HC-SR04):


Trigger/Pulse: Connect the trigger pin to a PICAXE output (e.g., Pin 0) and use a short pulse (10µs) to initiate a reading.

Echo: Connect the echo pin to an input pin (e.g., Pin 1) with a 0.1µF capacitor for noise filtering.

Code: Measure pulse width and calculate distance:

distance = (echo_pulse / 58) ' Pulse width in µs → cm

Actuator Interfacing:
1. Relays:


Use a transistor (e.g., BC547) or MOSFET (e.g., IRF520) to switch high-power loads (e.g., 12V/24V relays). Include a flyback diode (1N4007) across the relay coil.

Wiring: PICAXE output → base of transistor (via 1kΩ resistor) → GND. Relay coil connects to power supply.

Debouncing: Relays exhibit mechanical bounce. Implement software debouncing with a delay:

high relay_pin
pause 50 ' Debounce delay

2. Servos:


Connect signal wire to a PICAXE PWM-capable pin (e.g., Pin 0). Use the `servo` command with a 50Hz PWM signal (1–2ms pulse width).

Power Supply: Servos require 4.8V–6V. Use an external supply with common GND to PICAXE.

3. DC Motors (with PID Control):


Signal Conditioning: Use an H-bridge (e.g., L298N) for bidirectional control. Add a diode (1N4007) across motor terminals for back-EMF protection.

PWM Input: Connect H-bridge enable pin to a PICAXE PWM pin (e.g., Pin 0) for speed control.

Implementing a PID Controller for DC Motor Speed Regulation

A PID (Proportional-Integral-Derivative) controller adjusts motor speed by continuously calculating an error value and applying corrections. PICAXE’s limited processing power requires simplified tuning and efficient code.

Circuit Setup:


Components:

PICAXE 28X2 (or higher).

DC motor (e.g., 6V, 1A).

H-bridge module (L298N).

Tachometer or

Crafting projects with PICAXE microcontrollers bridges the gap between theoretical knowledge and practical execution, empowering developers to create functional, scalable solutions with minimal overhead. From selecting the right chip based on project requirements to implementing robust circuits and programming logic, each step builds toward a cohesive and efficient workflow. By leveraging PICAXE’s strengths—such as its straightforward programming language, cost-effective hardware, and seamless integration with common components—users can innovate without unnecessary complexity. This guide serves as both a technical reference and a practical roadmap, ensuring that every developer, regardless of experience level, can harness the full potential of PICAXE for their next embedded systems endeavor.