Flame Runtime on Inferno Embedded

Unipolar Stepper Motor

Fri, 27 Dec 2013 01:33:14 +0000

Summary

Driver a stepper motor back and forth.

Code

#define MHVLIB_NEED_PURE_VIRTUAL

// Bring in the MHV IO header
#include <MHV_io.h>

// Bring in the Stepper driver
#include <MHV_StepperMotorUnipolar.h>

// Bring in the realtime clock driver
#include <MHV_RTC.h>

// Bring in the power management header
#include <avr/power.h>
#include <avr/sleep.h>

// Bring in the timer header
#include <MHV_Timer8.h>

// Program space header, saves RAM by storing constants in flash
#include <avr/pgmspace.h>

#if defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
#define ATTINY
// A timer we will use to tick the RTC
MHV_Timer8 tickTimer(MHV_TIMER8_0);
MHV_TIMER_ASSIGN_1INTERRUPT(tickTimer, MHV_TIMER0_INTERRUPTS);

#else
// A timer we will use to tick the RTC
MHV_Timer8 tickTimer(MHV_TIMER8_2);
MHV_TIMER_ASSIGN_1INTERRUPT(tickTimer, MHV_TIMER2_INTERRUPTS);
#endif

#define ALARM_COUNT	4
// The RTC object we will use
MHV_RTC_CREATE (rtc, ALARM_COUNT);

// A timer trigger that will tick the RTC
void rtcTrigger(void *data) {
	rtc.tick1ms();
}

/* We have a hard limit of 1000 steps/second due to the 1ms resolution of the RTC class
 * The motor & control circuitry have a lower limit due to their electrical & mechanical properties
 */
#define MAX_SPEED 500
#define MIN_SPEED 100

/* The steps per rotation
 * For the 28BYJ48 geared stepper, this is 32 steps multiplied by a gear ratio of 64,
 * multiplied by 2 since we are half stepping
 */
#define STEPS_PER_ROTATION	(2*32*64)

/* The stepper driver
 * Available modes are WAVE, FULL and HALF
 */
MHV_StepperMotorUnipolar stepper(rtc, MHV_STEPPER_MODE_HALF, MHV_PIN_B0);

/* A class that tells the stepper what to do next
 * Note that moveComplete() is called every time the stepper driver has completed a move
 */
class StepperInstructions : public MHV_StepperListener {
private:
	bool	_forward;		// The direction we are currently rotating
	float	_speed;			// The rotation speed (steps/second)
	bool	_speedUp;		// True if we are increasing speed, false otherwise

public:
	StepperInstructions();
	void moveComplete(int32_t position);
};

StepperInstructions::StepperInstructions() :
	_forward(true),
	_speed(1),
	_speedUp(true) {}

void StepperInstructions::moveComplete(int32_t position) {
	_forward = !_forward;
	_speed += (_speedUp) ? 100 : -100;

	if (_speed > MAX_SPEED) {
		_speed = MAX_SPEED;
		_speedUp = false;
	} else if (_speed < MIN_SPEED) {
		_speed = MIN_SPEED;
		_speedUp = true;
	}

	int32_t newPosition = (_forward) ? 1 * STEPS_PER_ROTATION : 0;
	stepper.rotate(_forward, _speed, newPosition);
}

StepperInstructions stepperInstructions;

int NORETURN main(void) {
	// Disable all peripherals and enable just what we need
	power_all_disable();
#ifdef ATTINY
	power_timer0_enable();
#define PRESCALER	MHV_TIMER_PRESCALER_5_64
#else
	power_timer2_enable();
#define PRESCALER	MHV_TIMER_PRESCALER_7_64
#endif

	set_sleep_mode(SLEEP_MODE_IDLE);

	// Register the listener with the stepper driver to be notified when moves are complete
	stepper.registerListener(stepperInstructions);

	// Configure the tick timer to tick every 1ms (at 16MHz)
	tickTimer.setPeriods(PRESCALER, 249, 0);
	tickTimer.setTriggers(rtcTrigger, 0, 0, 0);
	tickTimer.enable();

	sei();

	/* Start with a forward rotation of 1 revolution at 100 steps/second
	 * Further instructions will be triggered from StepperInstructions::moveComplete
	 */
	stepper.rotate(true, 100, 1 * STEPS_PER_ROTATION);

	for (;;) {
		/* All the interesting things happen in events
		 */
		rtc.handleEvents();

		// Sleep until an interrupt occurs
		sleep_mode();
	}

	UNREACHABLE;
}

Hardware

To complete this tutorial, you need a unipolar stepper motor and 4 N channel MOSFETs with internal bypass diodes.

Blinking LED

Fri, 27 Dec 2013 01:24:36 +0000

Summary

Blink an LED connected to Arduino pin 13.

Code

// Bring in the MHV IO header
#include <MHV_io.h>

// Bring in the AVR delay header (needed for _delay_ms)
#include <util/delay.h>
#include <avr/power.h>

int main() {
// Disable all peripherals and enable just what we need
	power_all_disable();

// Enable output on pin 13 of the Arduino - this normally has an LED connected
	mhv_setOutput(MHV_ARDUINO_PIN_13);

	while (true) {
// Turn off the LED
		mhv_pinOff(MHV_ARDUINO_PIN_13);

// Sleep for 1/3 sec
		_delay_ms(333);

// Turn on the LED
		mhv_pinOn(MHV_ARDUINO_PIN_13);

// Sleep for 1/3 sec
		_delay_ms(333);
	}

// Main must return an int, even though we never get here
	return 0;
}

How it works

Line 2

The MHV_io.h header contains basic I/O functionality for MHVLib. It is needed for mhv_setOutput(), mhv_pinOff() and mhv_pinOn().

Building with Makefiles

Thu, 26 Dec 2013 08:23:11 +0000

The Flame Runtime can be built from the command line using GNU make.

Getting a Toolchain

To do so, you should have an AVR toolchain installed. Windows, Linux & MacOSX users are encouraged to use Inferno Embedded AVR Tools, as this is the toolchain Flame is tested with.

Preparing to Build

After cloning the git repository (or extracting the release archive), edit the env script in the top level of the package, and configure it to suit your installation. As shipped, it expects the AVR toolchain to be in /usr/local/mhvavrtools, and will add this to the path.

flame 20111227

Tue, 27 Dec 2011 00:20:47 +0000

Use object references instead of pointers where applicable
- Add WS2801 LED driver & RGB pixel types
- Add Unipolar stepper motor driver
- Ensure all tutorials use NORETURN/UNREACHABLE

Downloads

mhvlib-20111227.7z (532.9 KB)

flame 20111109

Wed, 09 Nov 2011 00:20:47 +0000

Add VUSB console, allows text output from V-USB devices (such as the MHVBoard) over USB. Requires Paul Stoffregen’s HID Listen program to receive the output.
- Extended Device_TX with new methods that utilise dynamic memory: printf(), and write(Xint(8|16|32)_t). The following classes inherit from Device_TX and will be able to use the new methods:
  - MHV_Display* (all display classes)
  - MHV_HardwareSerial (serial port driver)
  - MHV_VusbConsole (USB console mentioned above)
  - MHV_VusbTypist (USB Keyboard driver with Device_TX support)

Downloads

mhvlib-20111109.7z (1.14 MB)

flame 20111011

Tue, 11 Oct 2011 00:20:47 +0000

Add Doxygen documentation
- Address Doxygen warnings
- Minor optimisations (flash usage in RTC class)
- New Class: MHV-VusbTypist - allows strings to be sent to an emulated USB keyboard

Downloads

mhvlib-20111011.7z (1.15 MB)

flame 20110929

Thu, 29 Sep 2011 00:20:47 +0000

Illustrate AVR LibC power saving in all tutorials
- Add new event driven classes: PinChangeManager and ADC
- Add event functionality to Device_RX and RTC
- Port Arduino PID class to MHVlib

Downloads

mhvlib-20110929.7z (112.2 KB)

flame 20110920

Tue, 20 Sep 2011 00:20:47 +0000

Bug fixes
- Added HD44780 via Shift Register driver
- Added Voltage Regulator
- Added EEPROM support

Downloads

mhvlib-20110920.7z (106.9 KB)

flame 20110110

Mon, 10 Jan 2011 00:20:47 +0000

Add HD44780 support

Downloads

mhvlib-20110110.7z (67.1 KB)

flame 20101231

Fri, 31 Dec 2010 00:20:47 +0000

Relocate async writing from HardwareSerial to Device_TX. HardwareSerial & Display_Monochrome implement this, and all subclasses now support async text support.

Heads up!

As a result of the above change, the asyncWrite() calls to HardwareSerial are no longer supported, and instead are replaced by write() calls inherited from Device_TX.

Downloads

mhvlib-20101231.7z (62.5 KB)