Ring-a-Thing

/ / Ring-A-Thing

The Ring-A-Thing is a modular ring-building kit that will allow you to press-fit a small cube magnet into the base and top, allowing you to switch out designs on your printed ring.

Here is the code for the base of the ring. Measure the diameter of your finger and pass in that value. If you want a delicate ring, the second parameter should be set to true.

Open OpenSCAD and paste the following code in:

$fn=100;
magnet=3.3;
ring_size = 16;
rotate([0,0,90])
ring(ring_size, true);

module ring(size, d=true) {
	difference() {
    		union() {
      		cylinder(r=size/2+2, h=9, center=false);
      		translate([0, size/4+2.5, 9/2]) 
			if(d){
	  			cube(size=[size, size/2+4, 9], center=true);
			}else{
	  			cube(size=[size+4, size/2+4, 9], center=true);
    			}
    		}
    		translate([0, 0, -1]) 
		cylinder(r=size/2, h=12+2, center=false);	
    
		translate([-1.5, size/2+1.5,2.5])
		cube(magnet);
 	}
}

Adjust the ring size and profile
Press F5 to view the ring base
Press F6 to render the mesh
Under Design select Export as STL
Open in ReplicatorG and process for printing

Design a top with a 3.3mm cube removed from it.

Top Parts

After you designed your top part open it up in blender by selecting File>Import>stl navigate to design and import it.
Deselect the part. Press SHIFT+A to add a MESH>cube.
Press N to open the panel on the right side.
Set the cube dimensions to 3.3 x 3.3 x 3.3
Move the cube so that it is placed in the center of the top part where the top part and the ring should connect
Select the cube then SHIFT+click on the top part.
Add a modifier
Select Boolean
Select the cube
When it accepts your selection, click Apply
Back in the main window deselect both objects
Click just on the cube and press X to delete the cube. You should be left with a hole where the cube was.
Export top as an STL and open it up in ReplicatorG

Bump Sensors

The robot wanders around autonomously until it bumps into something. You need to place the sensors in strategic locations so that the bot always detects the obstacles. It is important also that there is enough time between sensing and reacting.

Antennae

The front antennae sensors are wires connected to coiled wires which are connected to the Arduino digital pins and and a bolt connected to GND. The bolt is inside the coil so when the wire connected to the coil hits something, the coil makes an electrical connection with the bolt and closes the circuit. When the sensor is triggered, the bot stops and reverses direction, then stops and turns and proceeds in a new direction.

Take 4-6 feet of 18 awg wire. Wrap the wire around a 3/4 inch cylinder
Repeat for the second antennae
Unwrap 6 inches from the coil. This will be the antennae.
Solder a wire to the bottom of the coil and attach the wire to the Arduino digital pins
Solder a wire to the bolt and connect that wire to GND.
Thread the bolt through the base of the bot
Hot glue the base of the coil to the bot base. Don't get glue on the spirals above the bottom spiral.

SPST Switches

The SPST switches act the same way the antennae switches do. When contact is made, the circuit is closed.

If you have a minimum of two sensors on the front and three on the back, the bot should be able to navigate.

Attach the three switches to bumpers on the back of the bot. And connect the leads to the Arduino digital pins and GND.

SPST switches

One is used for power:
Cut the red wire of the power supply. Solder each lead to a lead of the toggle switch.

One is used to toggle the mode of the robot. Connect the two leads of the switch to Arduino digital 4 and to GND.

The Code

// Bug-bot v1.2
// (2) Servo motors (modified for continuous rotation) with tank-steering setup (pins 9 and 10).
// (5) bump sensors total - 2 in front (pins 2 and 3) and 3 in rear (pins 5, 6, 7).
// All sensors are normally HIGH (1) using arduino internal pull-up resistors.
// Sensors are brought LOW (0) by contacting the switch connected to GND.
// Either set of sensors can be used (front or back), by changing Mode Switch on pin 4.
// Pin 4 (HIGH or LOW) changes the bots default direction and sensors.
//

// include the Servo.h Arduino library
#include <Servo.h>

// create instances for each servo using the Servo.h library
// for more information, see: 
Servo servo_L;
Servo servo_R;

/////////////  Variables used for testing (you can change these)

// use to determine direction of bot and which sensors to use.
int mode_pin = 4; // connect the mode switch to digital pin 4

int antennae_L = 3; // connect left antennae sensor to digital pin 3
int antennae_R = 2; // connect right antennae sensor to digital pin 2

int bumper_R = 5; // connect right bump sensor to Analog pin 0, which is pin 14 when used as a digital pin
int bumper_C = 6; // connect center bump sensor to Analog pin 1 (digital pin 15)
int bumper_L = 7; // connect left bump sensor to Analog pin 2 (digital pin 16)

// Value to change servo stopping point pulse - use Code 7-2 to determine the specific pulse for each motor 
int servo_R_stop = 89;  // set the Neutral position for Right Servo - change as needed
int servo_L_stop = 89;  // set the Neutral position for Left Servo  - change as needed

// integers to use for updating Servo motors
// change these values to change the various motor actions
int stop_time = 1000;  // stop for 1000 millliseconds = 1 second
int backup_time = 700; // backup for 700 milliseconds = .7 seconds
int turn_time = 300;   // turn (either direction) for 300 milliseconds = .3 seconds

//////////////////////////  End of variables used for testing 
// value names used to hold timing variables.
unsigned long timer_startTick;

// value names used to hold antennae states
int antennae_R_val;
int antennae_L_val;

// value names used to hold bumper states
int bumper_R_val;
int bumper_C_val;
int bumper_L_val;

// Set the forward and reverse speed values for the Right Servo based on the Neutral position
int servo_R_forward = servo_R_stop + 50; 
int servo_R_reverse = servo_R_stop - 50;

// Set the forward and reverse speed values for the Left Servo based on the Neutral position
int servo_L_forward = servo_L_stop - 50;
int servo_L_reverse = servo_L_stop + 50;

// end of variables

// Begin Setup
void setup(){

Serial.begin(9600); // start Serial connection at 9600 bps

servo_L.attach(9);  // attach servo_L to pin 9 using the Servo.h library
  servo_R.attach(10); // attach servo_R to pin 10 using the Servo.h library

pinMode(mode_pin, INPUT);  // declare input 
  digitalWrite(mode_pin, HIGH); // enable pull-up resistor

pinMode(antennae_R, INPUT);  // declare input  
  digitalWrite(antennae_R, HIGH); // enable pull-up resistor
  pinMode(antennae_L, INPUT);  // declare input  
  digitalWrite(antennae_L, HIGH); // enable pull-up resistor

pinMode(bumper_R, INPUT);  // declare input  
  digitalWrite(bumper_R, HIGH); // enable pull-up resistor
  pinMode(bumper_C, INPUT);  // declare input  
  digitalWrite(bumper_C, HIGH); // enable pull-up resistor
  pinMode(bumper_L, INPUT);  // declare input  
  digitalWrite(bumper_L, HIGH); // enable pull-up resistor
}
// End Setup

// Begin Loop
void loop(){

////////////////////////////////////////////////////////
  // if the switch_pin is LOW, use the Antennae sensors
  ////////////////////////////////////////////////////////
  if (!digitalRead(mode_pin) ){

antennae_R_val = digitalRead(antennae_R); // read Right antennae
    antennae_L_val = digitalRead(antennae_L); // read Left antennae

// Use Antennae sensors
    // check to see if either antennae sensor is connected to GND (it is being touched).
    if (antennae_R_val == 0 || antennae_L_val == 0){

// now check to see if only the Left antennae was touched  
      if (!antennae_R_val && antennae_L_val){
        // if so, print the word "Left"
        Serial.println("Left");  
        // reset timer
        timer_startTick = millis();
        // Stop motors
        stop_motors();
        // back up a bit
        backup_motors();
        // turn Right for a bit
        turn_right();
      }

// otherwise, if the Right sensor was touched and the Left was not,
      else if (antennae_R_val && !antennae_L_val){
        // print the word "Right"
        Serial.println("Right");  
        // reset timer
        timer_startTick = millis();
        // Stop motors
        stop_motors();
        // back up a bit
        backup_motors();
        // turn Left for a bit
        turn_left();
      }

else {
        // otherwise, both antennae sensors were touched 
        // print the word "Both"
        Serial.println("Both");  
        // reset timer
        timer_startTick = millis();
        // Stop motors
        stop_motors();
        // back up a bit
        backup_motors();
        // turn either direction
        turn_left();
      }      
    }

else {
      // otherwise no sensors were touched, so go Forward!
      forward_motors();
    }

// print the states of each antennae
    Serial.print("Right sensor");
    Serial.print(antennae_R_val);
    Serial.print("    ");
    Serial.print("Left sensor");
    Serial.print(antennae_L_val);
    Serial.println("    ");  
    // End Antennae sensors

}
  ///////////////////////////////////////////////////////////
  // Else, if the switch_pin is HIGH, use the Bumper sensors
  ///////////////////////////////////////////////////////////
  else{

// read the bumper sensors
    bumper_R_val = digitalRead(bumper_R);
    bumper_C_val = digitalRead(bumper_C);
    bumper_L_val = digitalRead(bumper_L);

// Use Bumper sensors
    // check to see if the right bumper was touched 
    if (!bumper_R_val){
      // if so, print the word "Right"
      Serial.println("Right");  
      // reset timer
      timer_startTick = millis();
      // Stop motors
      stop_motors();
      // back up a bit
      ahead_motors();
      // turn Left
      turn_left();

}

// check to see if the left bumper was touched 
    else if (!bumper_L_val){
      // if so, print the word "Left" 
      Serial.println("Left");  
      // reset timer
      timer_startTick = millis();
      // Stop motors
      stop_motors();
      // back up a bit
      ahead_motors();
      // turn Right
      turn_right();
    }

// check to see if the center bumper was touched 
    else if (!bumper_C_val){
      // if so, print the word "Center" 
      Serial.println("Center");  
      // reset timer
      timer_startTick = millis();
      // Stop motors
      stop_motors();
      // back up a bit
      ahead_motors();
      // turn Left
      turn_left();
    }

else{
      // otherwise no sensors were touched, so go Forward (which is actually Reverse when the direction is switched)!
      reverse_motors(); 
    }

// print the states of each bumper
    Serial.print("Right Bumper: ");
    Serial.print(bumper_R_val);
    Serial.print("    ");
    Serial.print("Left Bumper: ");
    Serial.print(bumper_R_val);
    Serial.print("    ");
    Serial.print("Center Bumper: ");
    Serial.print(bumper_L_val);
    Serial.println("    ");  
  }
  // End Bumper sensors
}
///////////////////// End Loop /////////////////////

// Beginning motor control functions

void stop_motors(){
  // stop motors for the amount of time defined in the "stop_time" variable
  while(millis() < timer_startTick + stop_time){ 
    servo_L.write(servo_L_stop); 
    servo_R.write(servo_R_stop);    
  }  
  timer_startTick = millis();  // reset timer variable
}

void backup_motors(){
  // backup for the amount of time defined in the "backup_time" variable
  while(millis() < timer_startTick + backup_time){ 
    servo_L.write(servo_L_reverse); 
    servo_R.write(servo_R_reverse);    
  }
  timer_startTick = millis();  // reset timer variable
}

void ahead_motors(){
  // go forward for the amount of time defined in the "backup_time" variable
  while(millis() < timer_startTick + backup_time){ 
    servo_L.write(servo_L_forward); 
    servo_R.write(servo_R_forward); 
  }
  timer_startTick = millis();  // reset timer variable
}

void turn_right(){
  // turn right for the amount of time defined in the "turn_time" variable
  while(millis() < timer_startTick + turn_time){ 
    servo_L.write(servo_L_forward); 
    servo_R.write(servo_R_reverse); 
  }
}

void turn_left(){
  // turn left for the amount of time defined in the "turn_time" variable
  while(millis() < timer_startTick + turn_time){ 
    servo_L.write(servo_L_reverse); 
    servo_R.write(servo_R_forward); 
  }
}

void reverse_motors(){
  // go reverse indefinitely
  servo_L.write(servo_L_reverse); 
  servo_R.write(servo_R_reverse);    
}

void forward_motors(){
  // go forward indefinitely
  servo_L.write(servo_L_forward); 
  servo_R.write(servo_R_forward); 
}
// End motor control functions

// End Code