Updating the Code and a progress video

A number of major changes have been made in the code. These have been necessary in order to fix the issue of interference. Shielded cable did nothing, neither did wire management so with the code updates, routines have been altered to fix interference.

The first fix was quite simple. Since the relays were the source of interference, when one axis moved, its caused false signals to be fed to the other photo interrupter. As a result the movement of one axis, would slightly change the coordinate of the other axis. Thus the update routine was given the command to not update whilst the other axis was running.

The second fix was more complex. I myself did not write this part but got help from others at the workshop. After probing the photo interrupter signal on an oscilloscope, we were able to see the signal wave and see how often it peaked abruptly. This was approximately 30 milliseconds, hence a debounce routine was run every 30 milliseconds in order to essentially reverse whatever abrupt false signal was read.

The code below reflects these changes which occurred in the first tab of my major code. There were other very tiny changes for example in the values of the servo for the up and down routines but I won't include these.

	//Automated Gantry Warehousing Robot
	#include <Wire.h>
	#include <Servo.h>
	int Xdir=6; // drive pin to X direction relay
	int Ydir=4; // drive pin to Y direction relay
	int Xenable=5; // drive pin to X enable relay
	int Yenable=10; // drive pin to Y enable relay
	int Xpulse=3; // input from X encoder
	int Ypulse=2; // input from Y encoder
	int Solenoid = 9;
	int Xhome = 11;
	int Yhome = 8;
	volatile int Xstate=LOW;
	volatile int Ystate=LOW;
	volatile int xx = 0;
	boolean Xdirection=false; // true if motor forward / false if reverse
	boolean Ydirection=false; // true if motor forward / false if reverse
	boolean Xmoving=false;
	boolean Ymoving=false;
	Servo Lift;
	volatile int Xposition=0; // encoder count for X
	volatile int Yposition=0; // encoder count for Y
	boolean Xtravel = false;
	boolean Ytravel = false;
	int OldXstate, OldYstate; // input state of encoder pins (HIGH,LOW)
	String inputString = "";
	boolean stringComplete=false;
	String cmd = "";
	int arg [4] = {0,0,0,0};
	int ArgIndex;
	int BayX[4] = {6,17,28,39};
	int BayY[3] = {6,25,39};
	unsigned long millilog[200];
	unsigned long EncoderCheck;
	int mindex = 0;
	void setup()
	{
	Serial.begin(9600);
	Serial.setTimeout(2);
	inputString.reserve(200);
	Serial.println(" Automated Gantry Warehouse");
	attachInterrupt(1,UpdateX,FALLING);
	attachInterrupt(0,UpdateY,FALLING);
	pinMode(Xdir, OUTPUT);
	pinMode(Ydir, OUTPUT);
	pinMode(Xenable, OUTPUT);
	pinMode(Yenable, OUTPUT);
	pinMode(Solenoid,OUTPUT);
	// pinMode(Xpulse,INPUT);
	// pinMode(Ypulse,INPUT);
	pinMode(Xhome,INPUT);
	pinMode(Yhome,INPUT);
	digitalWrite(Solenoid,LOW);
	Lift.attach(7);
	Lift.write(128);
	OldXstate = digitalRead(Xpulse); // get state of encoder inputs
	OldYstate = digitalRead(Ypulse); // ...
	ServoUp();
	GoHome();
	}
	void loop(){
	if (stringComplete){
	HandleCommand();
	inputString="";
	stringComplete=false;
	}
	}
	void Home(){
	MoveTo(BayX[0],BayY[0]);
	}
	void MoveTo(int x, int y){
	// if ((x < 0) || (y < 0) || (x > 40) || (y > 40)){
	// Serial.println("XY commands out of bounds");
	// return;
	// }
	//Serial.println(x);
	//Serial.println(y);
	//return;
	if (x !=Xposition){
	if (x > Xposition) XForward();
	if (x < Xposition) XReverse();
	}
	if (Xdirection){
	while(Xposition <x){}
	}
	if (!Xdirection){
	while(Xposition > x){}
	}
	XStop();
	ShowEncoders();
	delay (1000);
	if (y != Yposition){
	if (y > Yposition) YForward();
	if (y < Yposition) YReverse();
	}
	ShowEncoders();
	if (Ydirection){
	while(Yposition < y ){}
	}
	if (!Ydirection){
	while(Yposition > y){}
	}
	YStop();
	ShowEncoders();
	}
	void PickUp(){
	if ((arg[0] > 3) || (arg[1] > 3)){
	Serial.println("Invalid Bay Number");
	return;
	}
	delay(100);
	MoveTo(BayX[arg[0]], BayY[arg[1]]);
	}
	void GetFridge(){
	if ((arg[0] > 3) || (arg[1] > 3)){
	Serial.println("Invalid Bay Number");
	return;
	}
	MoveTo(BayX[arg[0]],BayY[arg[1]]);
	delay(400);
	ServoDown();
	delay(500);
	SolenoidOn();
	delay(400);
	ServoUp();
	delay(300);
	MoveTo(BayX[0],BayY[0]);
	delay(2000);
	ServoDown();
	delay(100);
	SolenoidOff();
	delay(500);
	ServoUp();
	}
	void StoreFridge(){
	if ((arg[0] > 3) || (arg[1] > 3)){
	Serial.println("Invalid Bay Number");
	return;
	}
	MoveTo(BayX[0],BayY[0]);
	delay(300);
	ServoDown();
	delay(400);
	SolenoidOn();
	delay(300);
	ServoUp();
	delay(200);
	MoveTo(BayX[arg[0]],BayY[arg[1]]);
	delay(2000);
	ServoDown();
	delay(500);
	SolenoidOff();
	delay(300);
	ServoUp();
	}
	void GoHome(){
	if (digitalRead(Xhome) == HIGH) XReverse();
	while(digitalRead(Xhome) == HIGH){}
	XStop();
	delay(500);
	if (digitalRead(Yhome) == HIGH) YReverse();
	while(digitalRead(Yhome) == HIGH){}
	YStop();
	ResetEncoders();
	MoveTo(BayX[0],BayY[0]);
	}
	unsigned long last_X_update_time= 0;
	unsigned long last_Y_update_time= 0;
	int debounce_time = 30;
	void UpdateX(){
	if (!Xmoving) return;
	if (abs(millis()-last_X_update_time)>debounce_time){
	//Not too quick, count.
	if (Xdirection) Xposition++;
	if (!Xdirection) Xposition--;
	last_X_update_time = millis();
	}
	// mindex++;
	// millilog[mindex] = millis();
	}
	void UpdateY(){
	if (!Ymoving) return;
	if (abs(millis()-last_Y_update_time)>debounce_time){
	if (Ydirection) Yposition++;
	if (!Ydirection) Yposition--;
	last_Y_update_time = millis();
	}
	}

view raw Automated Gantry hosted with ❤ by GitHub

Finally the long awaited video can be seen below. From it the difference from V1 to V2 is clear, particularly that this one actually works. Still there is much to fix and add. I'm thinking about a PCB to counter messy circuit boards and interference, buttons to make for a less repetitive and more efficient design, and a new mechanism for the Z axis that drops straight down rather than side on.

Mounting the Circuit Board and Cable Management

With construction finished, the electronic components now. It was made based on the same design of the MDF aluminum frame having 6 holes on top for hexstands to be screwed into. This way the circuit board could be mounted using the hexstands and taken off easily if issues with programming, wiring etc happened in future. This mount is shown below:

Once this was mounted, all wires had to be simply plugged into the circuit. However, I already had concerns that interference in the wires primarily motor wires, relays and the photo interrupter cables would be an issue. Thus, I took care in separately the paths of wires making them neat to minimise noise, physical cable tangle, and simply for aesthetics. This was primarily done using duct tape and some flexible plastic tube for the X axis. For the thick shielded cable, small cable clamp like things were stuck to the slide of the legs simply by using the sticky side which came with it. Images of this and the system put together are below:

Next, the arduino code will be looked at and a number of changes will be introduced to improve efficiency and function in particular to the new design.

Building and attaching the base and its frame

The frame to house the wooden base is displayed below. It was made using 4 pieces of 25x25x1.4mm angle aluminum. These were screwed together to form a rectangular frame. 2 pieces of 3mm flat aluminium where used to form a centre support beam. These were screwed and positioned to sit level with the sides of the angle aluminum. The reason for this centre brace was that MDF board was the material which was going to be used. I was aware that this was common to bend in the centre thus, the support was added to ensure a flat board. 

The board was 9mm MDF cut to fit to the frame using a jigsaw. After the board got in the way of the screw which secured the frame to the legs, I had to cut a small square piece off each corner of the MDF board using the jigsaw. This gave room to screw and unscrew the nuts and bolts so the frame could be easily detached from the legs for storage later.

Attaching the legs and final eletronics

With the axis's finished, I began to contemplate where the "fridges" would be picked up from. At the start, the idea was to like version 1, have the legs and structure screwed to a wooden base. This wooden base would be the floor of the warehouse on which the system would operate. Under this vision I began making the legs.

The legs were 30x30x3mm angle aluminum to make for very strong legs. These were cut to approximately 32mm using a hack saw. They were then all filed to be level and then screwed to the frame of the X-axis. However after all of this, the distance from the servo to the floor was much to high. Thus the original concept of a wooden base which the legs would rest on would not work. 

Instead, another design had to be made. I decided rather than have the legs rest on a base, that the legs would simply rest on the floor. The base for the system to would be housed in an aluminium frame which could be screwed to the legs. This way the distance from the servo to the base could be set at a reasonable height and changed if need be.

I would make this frame later and for now simply finished mounting the photo interrupter for the X motor. This was done just like the Y Motor but proved a lot easier since it was not a moving component. 

Finishing the X-axis and beginning on electronics

The first addition was making a mounting bracket for the idle wheel. This was made similarly to the Y axis but was altered slightly to all exist on one bracket which could be screwed onto the extendable side. After this the belt was added, and just like the Y was tensioned, the whole X structure now screwed together. After testing that the Y structure's running by hand an issue was found. One runner of the 4 was elevated slightly due to it being slightly too far out. As a result it ran along the top of the flat aluminium rather than beside it. This could cause issues in operation or locks in the motor so I quickly fixed this. To do this involved taking the bracket and wheel off and remaking it completely, this time slightly less out, and with the runner slightly lower. After this rework, the Y axis ran smoothly as required so well it ran when tilted under the force of gravity.

Next, a small bracket was made and screwed to the Y axis structure. It was positioned directly in line with the motor, the piece which would connect the belt to the Y structure. This consisted simply of 2 pieces of angle and a piece of flat aluminum for the belt to rest on. Another piece of 3mm flat was then screwed on top to lock the belt. However upon doing this, another issue arose. As previously predicted the motor and idle wheel brackets were slightly too long causing the belt to not sit flat. In operation, this would cause the belt to lock when it got close to the idle wheel or motor. Hence, both brackets were raised and then screwed in again which solved the issue. This finalised the building of the primary X-axis structure.

With the structural completion of the axis's, electronics started to be added. The simplest of this included another limit switch to reset the position of the X-axis when the centre of the Y-axis structure activated the switch. The harder piece was the photo interrupter. At first this was attached just like on version, simply soldered straight onto shielded cable. However the shielded cable was not very flexible and as a result it interfered with the movement of the X-axis and eventually caused the photo interrupter to break. Thus a new photo interrupter was used however this time it was attached tot he cable differently. Firstly, the photo interrupter was fed through a small piece of experimenters board. It was soldered to this and then trimmed very short. Next the wire was then soldered to the back of the experimenters board in a vertical position as shown in the image below. This made it so the wire would not touch the X-axis structure at all. To hold all this in place and ensure a break would not occur again, hot glue was used to act as a sealant for the solder and wire. This was then cut to size using a band saw and a hand held drill was used to drilled holes to fit M3 screws. These allowed it to be screwed into the Y structure and stay in a static position at which it could accurately need the encoder wheel for the Y. This process was quite extensive and brought many issues however I am confident it will not do so with the X axis photo interrupter. This is because the X unlike the Y structure does not have to move. I also now had the experience and resulting new way to connect the shielded cable.

Building the X-axis

I will not go too deep into the build process of the X-axis as it was essentially a repeat of the Y except on a larger scale. Particular care had to be taken to get the dimensions correct. Some changes included using a wider 20mm flat aluminium as a guider for the Y axis. The sides themselves also use a 25mm by 20mm as the running surface for the runners of the Y-axis. The sides parallel to the Y-axis use wider 35mm by 20mm angle. These were all bolted together using M3 screws consisting of 2 major parts like the Y-axis. This is a solid part and an attachment for tensioning the belt.

In addition to this, a bracket was made which was screwed to the side of the angle. Like the Y-axis, this is attached to a bracket which houses the motor keeping it stiff and sturdy. There is a chance looking at it now that this bracket will have to be raised when the belt is connected to the Y structure but this will come later if needed.

The final change was also that a limit switch was attached to the Y axis. This will serve to allow the axis position to reset to 0 position when the runner hits the switch.

Finishing building the Y-Axis

Thanks to a friend of mine, I was able to get the M2.5 screws required to fix the motor. Thus, I made a small bracket which held the motor. This was then fixed to the Y-axis using some counter sunk screws such to not block the motor position. Once this was done, tensioning the belt was then possible. The extendable portion of the Y was simply held tight whilst a hole on each side was drilled. This was then screwed so if ever the belt wasn't fully tensioned, another hole could be drilled to adjust. 

The second part that was completed was the attachment of the ball bearing runner wheels. Like the Z runners, these proved to be an issue as both sides had to be kept level, particularly as the gap from both sides was quite far. The runners like the Z were bolted using 8M screws and nuts. On the motor side this was bolted to a separate bracket however on the extension side, it could be simply bolted to the side. One other issue was that the brackets had to be dissembled to allow me to drill the holes accurately with the vertical drill. Finally, one thing I noticed was the nuts loosened up over time with the friction of the runners. Hence, thread locking glue (loctite) was let to seep through the thread. Now the runners are secure on both the Z and Y. The image below shows the progress so far.