The Kraken is the first robot built by TechLabs as part of its instructor training boot camp. It is named after a fearsome mythical sea creature. The instructors have experimented a great deal with both its physical build, and its software (sketch) to reach its current, battle-ready state. The Kraken sketch started with the „Sumo-Base“ sketch as a template, designed by Eric Ryan, author of „An Introduction to Robot Programming“. We continue to try out new ideas for interesting Sumo Robot League behaviors on the Kraken. Below is its state-of-the-art sketch as of July, 2017 which features some interesting „battle cry“ behavior, battle-ring edge avoidance, and multiple attack modes- feel free to copy:
/********************************************************************
TechLabs – „The Kraken“ sketch – July 2017 – Instructor Robot
credit: Miles Prinzen @ TechLabs and Eric Ryan Harrison for portions of code in „Sumo-Base“ (https://github.com/SumoRobotLeague/MRK-1/blob/master/Chapter_8/CompetitiveSumoRobot.ino)
********************************************************************/
#include „Motor.h“
#include „Pitches.h“
/************************/
/** PIN CONFIGURATIONS **/
/************************/
// LED pin
#define led 7
// IR Sensor pins
#define leftSensor A1
#define rightSensor A2
#define rearSensor A3
#define IREmitter 6
// Hardware pins
#define button 2
#define buzzer 5
// Ultrasonic sensor pins
#define echoPin A0
#define pingPin 3
// Motor pins
#define rightMotorSpeed 10
#define rightMotorDirection 8
#define leftMotorSpeed 9
#define leftMotorDirection 4
/*************************************************/
/** Global Variables and Configuration Settings **/
/*************************************************/
// Competition configuration settings
#define abortsThreshold 980
#define searchTime 2000
#define attacksDistance 18
// competition configuration variables
int turnDirection = 1; // 1 = left, 2 = right
unsigned long turnTime = 0; // holds the return from millis()
unsigned long forwardTime = 0;
int dAttack = 0; // holds attack duration in ticks
// Create our motor object
Motor motor;
// State variables
int buttonState = 1; // 1 = up, 0 = pressed
int state = 1; // 1 = idle, 2 = competing
void setup() {
Serial.begin(9600);
// pin setup
pinMode(button, INPUT_PULLUP);
pinMode(buzzer, OUTPUT);
// IR sensors
pinMode(leftSensor, INPUT);
pinMode(rightSensor, INPUT);
pinMode(rearSensor, INPUT);
pinMode(IREmitter, OUTPUT);
// Turn on our IR Emitter
digitalWrite(IREmitter, HIGH);
// ultrasonic sensors
pinMode(pingPin, OUTPUT);
pinMode(echoPin, INPUT);
// Motor setup
motor.setupRight(rightMotorSpeed, rightMotorDirection);
motor.setupLeft(leftMotorSpeed, leftMotorDirection);
Serial.println(„The Kraken is powered up. Waiting for button press.“);
}
void loop() {
if ( buttonState == 1 && digitalRead(button) == 0 ) {
buttonState = 0;
}
if ( buttonState == 0 && digitalRead(button) == 1 ) {
buttonState = 1;
if ( state == 1 ) {
// we were in idle mode, so let’s begin our
// competition countdown
Serial.println(„Competition countdown starting…“);
Serial.println(„Good luck!“);
begin_countdown();
} else {
state = 1;
motor.left(0);
motor.right(0);
Serial.println(„Kraken entering idle mode.“);
}
}
// if the countdown has ended, we’re now in competition mode
if ( state == 2 ) {
compete();
}
}
/***************************************************/
/** Competition State Functions **/
/** These functions control the operational state **/
/** of our robot while it’s in state 2. **/
/***************************************************/
// This function is the primary competition control
// function and controls the operational flow and state
// of the robot in competition mode (state 2).
void compete() {
// declare local function variables to read our sensor values and determine what we
// need our robot to do.
int distance = msToCm( ping() );
int leftIR = analogRead(leftSensor);
int rightIR = analogRead(rightSensor);
int rearIR = analogRead(rearSensor);
int rotDirection = random(1, 3); // curve direction
if ( rearIR < abortsThreshold ) {
if (rotDirection == 1) { curveFLeft(); delay(800); } else { curveFRight(); delay(800); }
} else if ( (leftIR < abortsThreshold || rightIR < abortsThreshold) && distance > 5 ) {
aborts();
} else if ( distance < attacksDistance ) {
// We have detected an enemy. attacks!
if ( dAttack < random(50, 300) ) attacks(); else {
playNote(NOTE_G1, 100, 0);
if (rotDirection == 1) reverseL(); else reverseR();
}
} else {
// We don’t see an enemy, search until we find one.
search();
}
Serial.print(„Left/“); Serial.print(leftIR);
Serial.print(“ – Rear/“); Serial.print(rearIR);
Serial.print(“ – Right/“); Serial.println(rightIR);
}
void reverseR() {
motor.left(-255);
motor.right(-255);
delay(300);
curveBRight(); delay(800); attacks(); delay(500);
}
void reverseL() {
motor.left(-255);
motor.right(-255);
delay(300);
curveBLeft(); delay(800); attacks(); delay(500);
}
void curveFLeft() {
Serial.println(„Rot.FL“);
motor.left(random(-127, 127));
motor.right(random(128, 255));
}
void curveFRight() {
Serial.println(„Rot.FR“);
motor.left(random(128, 255));
motor.right(random(-127, 127));
}
void curveBLeft() {
Serial.println(„Rot.BL“);
dAttack -= random(10, 50);
motor.left(120);
motor.right(-255);
}
void curveBRight() {
Serial.println(„Rot.BR“);
dAttack -= random(10, 50);
motor.left(-255);
motor.right(120);
}
// This function is a simple search algorithm that
// attempts to locate the opponent before moving
// into attacks mode.
void search() {
Serial.println(„Searching…“);
if ( dAttack > 1 ) dAttack -= 3;
digitalWrite(led, LOW);
// our time has exceeded our configured searchTime, reset.
if ( turnTime != 0 && ((millis() – turnTime) > searchTime) ) {
turnTime = 0;
}
if ( forwardTime != 0 && ((millis() – forwardTime) > 5000) ) {
forwardTime = 0;
}
// get random direction and store the start time
if ( turnTime == 0 ) {
turnDirection = random(1, 3);
turnTime = millis();
}
if ( forwardTime == 0 ) {
forwardTime = millis();
}
if ( millis() – forwardTime < 3000) {
// start our turn, 1 = left, 2 = right
if ( turnDirection == 1 ) {
motor.left(255);
motor.right(-255);
} else {
motor.left(-255);
motor.right(255);
}
} else {
motor.left(200);
motor.right(200);
}
}
// The attacks() function is used to control the robot
// when an opponent has been detected closer than the
// defined attacksDistance. It will move ahead at full
// speed in an attempt to push the opponent outside of
// the ring.
void attacks() {
dAttack++;
Serial.println(„Attack!“);
digitalWrite(led, HIGH);
playNote(NOTE_B2, 100, 0);
motor.left(255);
motor.right(255);
}
// The aborts() function is an interrupting function that
// is called whenever the infrared sensors detect the
// ring border. This function will immediately halt
// other control function operations and move in reverse
// at full speed.
void aborts() {
Serial.println(„Run away!“);
motor.left(-255);
motor.right(-255);
delay(800);
}
// This function will begin our competition countdown sequence.
// When the button is depressed when in idle mode, this function
// will be called and begin a 5 second countdown with audible
// beeps at every second.
//
// PRACTICAL EXERCISE SOLUTION:
// This function also turns on the LED each time a note is
// played on the buzzer.
void begin_countdown() {
for ( int i = 0; i < 8; i++ ) {
delay(200); // wait 1 full second
// blinky angrily at our opponent
digitalWrite(led, HIGH);
playNote(NOTE_B2, 100, 0);
digitalWrite(led, LOW);
}
// wait one more full second before playing our next note
delay(1000);
digitalWrite(led, HIGH);
playNote(NOTE_D3, 80, 5);
digitalWrite(led, LOW);
playNote(NOTE_F3, 80, 5);
digitalWrite(led, HIGH);
playNote(NOTE_GS3, 80, 5);
digitalWrite(led, LOW);
playNote(NOTE_D4, 800, 5);
digitalWrite(led, LOW);
playNote(NOTE_F4, 800, 5);
digitalWrite(led, HIGH);
playNote(NOTE_GS4, 800, 5);
digitalWrite(led, LOW);
playNote(NOTE_D5, 80, 5);
digitalWrite(led, LOW);
playNote(NOTE_F5, 80, 5);
digitalWrite(led, HIGH);
playNote(NOTE_GS5, 80, 5);
playNote(NOTE_D6, 800, 5);
playNote(NOTE_F6, 800, 5);
playNote(NOTE_GS6, 800, 5);
// Our countdown is nearly complete. Wait 1
// more second and then set state to 2 so that
// we can begin our competition!
delay(2000);
digitalWrite(led, LOW);
state = 2;
}
/**********************/
/** Helper Functions **/
/**********************/
// Note-playing buzzer helper function.
void playNote(int note, int duration, int rest) {
tone(buzzer, note, duration);
delay(rest);
}
// Helper function to manage our ultrasonic sensor.
long ping() {
long duration;
digitalWrite(pingPin, LOW);
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(10);
digitalWrite(pingPin, LOW);
duration = pulseIn(echoPin, HIGH);
return duration;
}
// Helper function to return the distance to an object
// detected by the ultrasonic sensor in centimeters.
long msToCm(long microseconds) {
return microseconds / 29 / 2;
}
// Simple blinky function called in loop() whenever a state
// change is made by a user button press.
void blinky(int blinkys) {
for ( int i = 0; i <= blinkys; i++ ) {
digitalWrite(led, HIGH);
delay(500);
digitalWrite(led, LOW);
delay(500);
}
}
