## Swash plate actuated by three servos

These lasts weeks, I work a little on the first idea that makes me renew with DIY electronics. I won’t currently tell what it is all about, I’m not ready for that now. But I want to share what giving me a headache for now. The idea is to make a plane tilt and lift, following the movement of three servo actuators. The following video of the cardboard prototype demonstrate the mechanism.

Recently I replace the mechanical part with a RC helicopter swash plate. It’s much more efficient for this prototype.

I tried to do the formula myself, but I’m really rusted in trigonometry. A friend’s coworker give me great help. He wrote the formula I needed to make the motor move like I imagine.

I wanted the servo motors to be actuated from a given angle of inclination, the direction of this inclination and an offset in height. There is the formula. It needs some adjustment for the offset. I still don’t really understand how to calculate it. I want the height to be relative to the ray of the swash plate.

```void calculateHeights( double phi, double theta, double H, double R, double &L1, double &L2, double &L3 )
{
const double phi1 =   0*pi/180;
const double phi2 = 120*pi/180;
const double phi3 = 240*pi/180;

double x1 = R*cos(phi1);
double y1 = R*sin(phi1);

double x2 = R*cos(phi2);
double y2 = R*sin(phi2);

double x3 = R*cos(phi3);
double y3 = R*sin(phi3);

double nx = cos(theta)*sin(phi);
double ny = sin(theta)*sin(phi);
double nz = cos(phi);

double D = nz*H;

L1 = ( D - nx*x1 - ny*y1 ) / nz;
L2 = ( D - nx*x2 - ny*y2 ) / nz;
L3 = ( D - nx*x3 - ny*y3 ) / nz;
}```

This is it for now. I’ll work on the function and get back with it. If you understand more than me, any help is welcome!

As you have seen, the hardware part of the Glowing Marque prototype, build from an old scanner, is functioning. The last step I did is the programming of a protocol to communicate with the Arduino by the Insek Proxy Internet to Serial Proxy app.

The first issue is that I want to send a string of hexadecimal values and then convert it to real hex in the Arduino for displaying this data. The second problem to solve is to send a longer string that the serial buffer and the buffer of the Messenger library.

There is the piece of code I did for the protocol:

```#include <Messenger.h>

#define DATASIZE 70
unsigned char data[DATASIZE+1]; // + 1 space for the closing \0 char.

Messenger message = Messenger();

/*
2010-11-03: Append data.
Args: source, target, position to start from zero to DATASIZE.
*/
void appendData(char * s, unsigned char * dp, int pos) {

// Create and reset the pointer to display data.
dp = dp + pos; // Move to starting position.

char monkey[3];
long chimp;
for (int i=0; i<strlen(s); i=i+2) {
monkey[0] = s[i];
monkey[1] = s[i+1];
monkey[2] = '\0';

// Convert the monkey string to long int.
chimp = strtol(monkey, NULL, 16);

// Append chimp to displayData;
*dp++ = (unsigned char)chimp; // Cast the long to an unsigned char.

//Serial.print(chimp, BYTE);
}

*dp = '\0'; // Close the string.

}

void messageCompleted() {

//Serial.println("Message completed.");

while ( message.available() ) {
//Serial.print(".");
if ( message.checkString("data") ) { // Show text.

if( message.checkString("flush")) {
flushData();
Serial.println("\nData flushed.");

} else {
// 1st get position

// 2nd get length

// 3rd get data
char tmp_data[128];

// Move data to the temps string.
message.copyString(tmp_data, 128);

// Check if data length
// Find the first position of the \0.
int data_length = strlen(tmp_data);

// Data are always 2 char to build one hex value.
if( length*2 == data_length) {

if( pos + data_length - 1 > DATASIZE) {
Serial.println("\nData overflow.");
} else {

//Serial.println(strlen(tmp_data));

//Serial.println(tmp_data);

appendData(tmp_data, &data[0], pos);

Serial.println("");
Serial.println("Data:");

for(int a=0; a < DATASIZE; a++) {
if( data[a] == '\0' ) {
Serial.print("-");
} else {
Serial.print(data[a], BYTE);
}
}
}
} else {
}

} // End append data.

} else {
message.readChar(); // Flush the rest of the message buffer.
}

}
}

void flushData() {
for(int i=0; i<DATASIZE+1; i++) {
data[i] = '\0';
}
}

void setup() {

Serial.begin(9600);
message.attach(messageCompleted);

}
void loop() {
while ( Serial.available( ) ) message.process(Serial.read( ) );
}```

The protocol is relatively simple, there is the structure:

`header position length data`
• The ‘header’ is the command, what the Arduino have to do with that string. I use ‘data’ as the header to send data.
• The ‘position’ is the position in the array the data will be copied.
• The ‘length’ is the quantity of numbers to send. It’s used to check if the Arduino received the right length of data and to verify if the data will not overflow the data array.

There is an example to send a first packet of data:

`data 0 4 ff00ff00`

Here I send four numbers build with two hexadecimal characters (from 00 to ff). They will be placed at the beginning of the array.

If I want to append ‘ddee33’ to this value in the array, I shall use this call:

`data 4 3 ddee`

So this way I can send many blocks of data and built an array longer than the serial buffer.

After that I can implement other calls to work with this data. A sample call can be (not built in this sample code): show data. I did that in code of the Glowing Marquee project, so I send packets of hex data, and ask the Arduino to show it. I will be back with more on this project in my next posts.

## Array of function pointers with mixed parameters

This is my work to create an array of function pointers which they can accept one parameter of any kind.

```/*
2010-10-18: Basics of array of function pointers.
The trick here is to make these functions accept different
types of parameters using a void pointer.
*/

// Define the function pointer type.
// The void pointer can be casted to any type of value.
typedef void(*fctPtr)(void *);

// Declare the functions.
void fA(void *arg);
void fB(void *arg);
void fC(void *arg);

// Declare an array of functions pointers.
fctPtr f[3] = {fA,fB,fC}; // Array of function name (the pointer to that name).

// The functions.
void fA(void *arg) {

// Cast as a pointer to an int and assign it's value to r.
int r = *(int*)arg;

Serial.print("fA:");
Serial.println(r);
}
void fB(void *arg) {

// Cast as a pointer to a string of chars.
char * str = (char*)arg;

Serial.print("fB:");
Serial.println(str);
}
void fC(void *arg) {
Serial.println("fC:Called with no parameter.");
}

void setup() {
Serial.begin(9600);
delay(1000); // Wait a second.

int a = 123;
(*f[0])(&a); // Call the first function of the array of functions.

char b[] = "This is a test!";
(*f[1])(&b);

// Calling a function with no parameter.
(*f[2])(NULL);
// This call also work : (*f[2])(0).
}

void loop() {}
```

## Insek Internet to serial relay 02 released

After many hours of coding, the version 02 is now out! The application now make the relay in both direction. You can send string from the net to your Arduino, and send string from this serial device to your Web API. I invite you to try it and share your comments!

## A work in progress

The summer is over, so much time to type some lines of code. I work hard to make an updated version of my little Integer to serial relay, Insek. Obj-c is not familiar for me, but I like to lern it. I’ve just created a project page on Google code to distribute the files, show code examples, and maintain the development. Currently, I’m working on the communication from the serial device (the Arduino) to the computer (Insek). It’s work, but I have many issue with the the data inputs buffering. Follow the development on Insek project home page. If you can help developing this project, you are welcome!

## Canon SX10 remote control for 3 bucks

I recently hacked my Canon SX10 IS with the CHDK pack. This add the nice feature to remotely trigger the camera. Really useful to do night shooting. I wanted to make a cheap but efficient remote control. I found all the needed parts in a Dollarama dollar store for only 3\$. In the headlamp we have all I needed: a 3 AAA battery holder and a trigger push button. I simply replaced de leds circuit by the USB extension cable. And now, I’m ready to do long exposition steady shots!

## Stepper motor controller circuit and code

I build a step motor controller based on the schematics found on the Arduino Web site. First I try the 2 pins one for bipolar stepper motor. I wont be able to make it work, even less with the library available on the site. Maybe I’m dumb and I really dont understand something, but this circuit keeps both coils active at the same time.

So I tried the second circuit, the 4 pins one. With the same library I wasn’t able to make it work either. So I create a piece of code of my own and I finally managed to make the motor run correctly.

After that, I realize that I can merge the to circuits to possibly create a PWM abled bipolar motor controller with the L297D. A somewhat bizzare idea, but I think it’s possible if we can program the Arduino to send 4 synced PWM signals. I’ll come back later (maybe never) with this thought. After some research I found that the TI DRV8811 and the Allegro A3977 are much more appropriate chips to do microstepping.

But for now, there is my circuit. It’s advantage is that it can release the coils. Download the schematics (Fritzing format).

The two PNP transistors are connected like the circuit proposed on the Arduino Web site. Plus, I use the enable pins. So my circuit needs four pins, and I don’t found a way to use less.

### Parts list

• 1 x Arduino
• 1 x L293 Quadruple Half H-Bridge
• 2 x 1K Ohm Resistors
• 2 x 10K Ohm Resistors
• 2 x 2N2222 NPN Transistors
• 1 x Bipolar Step Motor

There is the sequence to make the motor turn one direction, invert it to make it turn the other.

Control sequence
CTRL A EN A CTRL B EN B
0 0 1 1
1 1 0 0
0 0 0 1
0 1 0 0

There is my code to control the stepper motor. Like you see in my code I use direct port command to take less processor time. And I create a function called in the main loop for each steps. This way the code can do something else when the motor is running.

```/*
Stepper Motor Controller
by Kevin Filteau 2010-05-29
Playwithmyled.com
*/

// Motor controller pins.
#define pinMotorCtrlA 4
#define pinMotorCtrlB 7
#define pinMotorEnA 5
#define pinMotorEnB 6

// Direction constants.
#define GOLEFT 0
#define GORIGHT 1

// Motor states and position.
boolean motorRunning = false;
int motorMax = 700;
int motorPos = 0;

/**********************************************
MOTOR
**********************************************/

// Setup the motor.
void motorSetup() {
pinMode(pinMotorCtrlA, OUTPUT);
pinMode(pinMotorCtrlB, OUTPUT);
pinMode(pinMotorEnA, OUTPUT);
pinMode(pinMotorEnB, OUTPUT);
// Everybody to LOW.
digitalWrite(pinMotorCtrlA, LOW);
digitalWrite(pinMotorCtrlB, LOW);
digitalWrite(pinMotorEnA, LOW);
digitalWrite(pinMotorEnB, LOW);
}

// Free the motor.
void motorFree() {
digitalWrite(pinMotorEnA, LOW);
digitalWrite(pinMotorEnB, LOW);
}

// Make the motor spin one step in the direction specified.
// Pins    7654 ----
// Binary 0000 0000
void motorSpin(boolean dir) {

static int pos = 0; // Starting step pos.

int stepsSeq[] = {0xC0,0x30,0x40,0x20}; // Registry value.
int st;

// Timing
static unsigned long previousMillis;
long interval = 3;

if(millis() - previousMillis > interval) {
previousMillis = millis();

st = stepsSeq[pos];
if( dir == GOLEFT ) {
pos++; if(pos>3) pos=0;
motorPos++;
} else {
pos--; if(pos<0) pos=3;
motorPos--;
}
PORTD &= 0xF;
PORTD |= st;
}

}

/**********************************************
MAIN FUNCTIONS.
**********************************************/
void setup() {
motorSetup();

}

void loop() {
motorSpin(GOLEFT);
// motorSpin(GORIGHT);
}```

And to close this post. Some pictures of the prototype, the finalized circuit board (useful for the pinout) and a video taken while testing the circuit.

## Make things works

Well, now that all things are weld together, I’m investigating the programmation. At this time I want to build an app in Objective-C Cocoa for Mac. I’m totally new to it. I work hard to create an app that will act as a Web server that send the data received from an Internet connexion to the serial port of the Arduino. I found some base code that will probably help me doing it. I’ll let you know when I’ll succeed.