One of the projects that I undertook this Summer was a lawn roller. Our yard became infested with moles, and as a result the yard became extremely difficult to mow. I looked at the hardware store for a solution, but for what they wanted for a big heavy wheel, I could not see spending that much. I decided to build my own.

I gathered up some steel angles, some pipe, a few U-bolts, and some concrete. The plan was to build a basic frame out of the steel angles, and pour the concrete into a round form to act as the heavy wheel.

I welded the steel frame together, and it came out pretty well. Pouring the concrete was not so successful. I had to pour the concrete in the form, and getting a 80 pound bag of concrete up to the top was a little bit of a struggle. I also had not thought of pouring the concrete into a bucket, mixing it there, and then pouring it into the form. So, I poured the concrete directly into the form, sprayed it with the hose, and mixed it in the form. It was a mess. Hopefully, all of the concrete is cured enough that it doesn't completely fall apart.

Then, the first time I get to use it, it works. Until I go in reverse. The main cross member that holds the whole frame together buckled as soon as I went in reverse. Of course, the frame got caught on the roller, and got all boogered up.

In retrospect, I should have built the thing much stronger then I did. I am going to try to replace the main beam with a square tube of steel, as opposed to the angle iron that I originally used. This should be strong enough, and not be as easily twisted. I will also be able to use the original angle iron as an extension arm from the new beam to give the whole thing a little more clearance from the mower.

Here is some code to start working with the accelerometer. It was taken from here, and edited to work with the Arduino Mega.


/*
Accelerometer Reader

Reads the X and Y of a 3-axis accelerometer

The accelerometer, an ADXL330 from Sparkfun, is attached
to analogs 1 through 3. Analog pins 0, 4, and 5
are used as digital I/O pins in this case, as follows:
Analog 0 = Digital 14 = HIGH (accelerometer self test)
Analog 4 = Digital 18 = LOW (accelerometer ground)
Analog 5 = Digital 19 = HIGH (accelerometer Vin)

Sends serial readings in this format:
X, Y\r\n

created 19 Sep 2008
by Tom Igoe

last modified 28 Oct 2008
by Rory Nugent

Recent Changes:
Removed calculation of the max and min, sends only X-axis and Y-axis values, and
configured a basic wait period after boot to wait for Processing and to throw out
all readings during this period.
*/

int accelReading = 0;

void setup() {
// initialize serial:
Serial.begin(9600);

pinMode(13,OUTPUT); //on board LED

// set up Analog 0, 4, and 5 to be
// digital I/O (14, 18, and 19, respectively):
pinMode(54, OUTPUT); //analog pin 0
pinMode(58, OUTPUT); //analog pin 4
pinMode(59, OUTPUT); //analog pin 5

// set pins appropriately for accelerometer's needs:
digitalWrite(54, HIGH); // acc. self test
digitalWrite(58, LOW); // acc. ground
digitalWrite(59, HIGH); // acc. power

digitalWrite(13,HIGH); //on board LED

// send a byte out the serial port until
// you get one back in to initialize
// call-and-response serial communication:
while (Serial.available() <=0) {
// take readings of the accelerometer while you wait for a call-and-response
// doing this seems to clear out any initial garbage and settle down the ADC
for (int channel = 1; channel < 4; channel++) {
analogRead(channel);
delay(10);
}
Serial.print("\n");
}

digitalWrite(13,LOW);
}

void loop() {
// only send if you have an incoming serial byte:
if (Serial.available()) {
// read and print the x-axis value from the accelerometer
Serial.print(analogRead(3));

// print a delimiter
Serial.print(",");

//read and print the y-axis from the accelerometer
Serial.print(analogRead(2));

// print carriage return and newline:
Serial.println();

Serial.flush();
}
}

I plan on editting this heavily, but it shows how you can use the analog pins as digital pins, but also uses the analog pins to power the accelerometer. This will simplify wiring. The code waits for a character to be sent over the serial port, which really isn't what I would be using it for, but it is a neat method.

Part of phase 1 will be defining the design of the ROV. Currently, we are planning are 4 thrusters. Two of the thrusters will be located on each side of the chassis. One will be pointing upward to control ascent/descent, and one will be pointing backward to control forward motion. The two thrusters that are pointing backward will also control turning. We will need 4 separate motor controllers for this design. This may seem a little excessive, but for the level of control that I think we need, I think this is appropriate.

The design will involve a main tube to house the electronics and web cam, and two outriggers to mount the motors, and maybe lights, or anything else that may be needed.

Yesterdays brainstorming did come up with a decision though. The thought was that we would include an emergency ascent module if the ROV came disconnected from the surface computer. This is a neat idea, but the original plan was not to include a battery on board, simply to save space and weight. This had to be scratched, since if the ROV is to ascend on its own, it will need a battery on board. So, we have decided it will need its own power source.

The emergency ascent system would monitor things internally on the ROV such as temperature, humidity, and maybe pressure. This way if something went horribly wrong on the ROV, it would try to surface immediately.

It could be something as simple as a 555 timer tied into the signal lines running to the altitude motors. This would assume that the motors run off of a servo type signal though. The 555 timer circuit would be controlled mostly by the emergency ascent related sensors, and the microcontroller on board. I.E. just the humidity sensor could trigger the emergency systems if the microcontroller became locked up.

Is there a way to have the watchdog trigger a pin if the ROV's built-in microcontroller becomes locked up?

Idea: a surface pc transmits a heart-beat signal. If the rov does not receive the heart-beat signal every X seconds, it triggers the emergency ascent system.

Here is a quick run down of the current task list:

Phase 1: Decide on a design. We have a rough picture in mind of what we want to accomplish, but we need a formalized design so we know what kind of materials we need.

Phase 2: Source materials.

Phase 3: Begin construction. As I am sure at this point there will be some 'that won't fit' moments, we'll do a dry fit construction of everything. We'll have to make sure that all of our electronics, motors, wiring, etc fit where they are proposed to go.

Phase 4: Electronics design. What exactly will be included in order to make the ROV work.

Phase 5: Finalize construction. At this point, we'll make everything final.

Phase 6: Dry testing. This phase will include all the above water testing of the electronics and remote controls. Make sure the web cam works. Make sure the motors respond.

Phase 7: Water tight testing. All electronics will be removed, the submersible resealed, and sunk to a shallow depth.

Phase 8: Shallow water function testing. This will be the first time that the ROV will be sunk with everything ready for use. This is where it is going to be getting fun!

Phase 9: Revisit design to address any concerns found during functional testing.

One of the reasons for the pulse jet was to pair it with a remote control airplane. This would be incredibly awesome, but also incredibly difficult to pull off. I think the speeds that it could be capable of would be more than anything we could wish for. I think the actual design and assembly would be enough to stall the project. Also, an airplane of this size and complexity would only be able to be flown in very limited conditions.

Due to the oncoming winter months of hibernation, another project has (re)surfaced that will allow us to both build it at work, and allow us to launch in less than ideal airplane conditions. We've decided on an ROV. An underwater, semi-autonomous vehicle with remote control. We will start out building a basic frame out of PVC pipes, and add some bilge pumps for thrusters.

If all goes well, we should be able to launch it into the bay, and get some underwater pictures from the onboard webcam. I hope to incorporate a pan/tilt mount as well.

Once all the basic features are working, and we have demonstrated that the ROV works under human control, I hope to add an IMU for stability control.

Everything is wiped, and we are starting over. New URL, new start.

New project too! Pulse jets. A very simple take on a jet engine. Take air and fuel. Mix them together in a combustion chamber. Add a spark. Boom. If you design the chamber, intake, and exhaust tubes correctly, you have a nice amount of thrust.

We are going to be building a valveless type, which simplifies the design significantly.
A traditional ramjet engine that you would find on a commercial aircraft just adds a set of turbines to this system. That can wait.

There is also a new team. 2 engineers from work and myself were looking for something to keep ourselves busy while we weren't busy. We are coming from different specialties, but we all get along very well. I think together we have the intellect and experience to carry out a wide variety of crazy things. Hopefully having more than myself working on a given project at a time will keep me focused on actually completing a project.