luce001

Firstly I would like to thank Ray for his hard work in starting off this excellent post! also for Eric and friends for the various coding updates.. I have made a few changes to the code and managed to get a working turntable on my layout, including an OLED display to show the position and head/tail indication. I only have 4 positions on my turntable and I didn't use the servo brake or manual pot but left these functions in. The display I used was a 1.3" I2C IIC Serial 128X64 OLED LCD LED Display Module Digital for Arduino W which can be obtained easily on eBay... the driver for this is U8glib.h https://code.google.com/p/u8glib/ and the other components as mentioned by others I ordered from Proto-pic. The revised coding is as follows, pictures to follow... Jonathan //////////////////////////////////////////////////////////////////////////////// // // DCC Turntable Rev 17 9 Jan 2015 // based on code from rmweb.co.uk forum - edited by J.Luce // Program functions: // "Real World" interface // 2- N.O. Push buttons to enable move to "Head" or "Tail" // 1- 10k Continuous turn POT to select track. // 1- N.O. Reset button on fascia // Use digital inputs on 6 & 7 to stepforward and backward and // read out in the serial monitor so that you can program easier. // Release & Servo Brake function works with brake and release function. // Route positioning not taking shortest route to next location- (i.e. Tk.1 to Tk. 10 would be through 0) // Always approaches a track from the same direction to account for gear/mechanical lash/slop. // if the table was going CW to pos. 1 it approaches value B and stops // if the table was going CCW to Pos 1 it should go past B a (value B-X) and then go CW to B. // Added a (commented out)set up tool in the "loop" section of the code to set up the POT on the fascia panel. // this let's you align the POT to the markings on the panel. Uncomment to use, then re-comment to hide. // Set up tool in the "loop" section of the code to set up the Brake Servo using the POT on the fascia panel. // this let's you find the optimal Release and Brake position for the servo brake. Uncomment to use, then re-comment to hide. // Added u8g display to show track position and heading, initialise at startup // Move to track 0 "Head" at startup //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // // DCC Turntable Control Routines #include <DCC_Decoder.h> #include <AccelStepper.h> #include <Wire.h> #include <Adafruit_MotorShield.h> #include "utility/Adafruit_PWMServoDriver.h" #include <Servo.h> //servo library reference #include "U8glib.h" // setup u8g object, please remove comment from one of the following constructor calls // IMPORTANT NOTE: The following list is incomplete. The complete list of supported // devices with all constructor calls is here: http://code.google.com/p/u8glib/wiki/device U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_FAST); // Dev 0, Fast I2C / TWI ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Defines and structures // #define kDCC_INTERRUPT 0 typedef struct { int address; // Address to respond to } DCCAccessoryAddress; DCCAccessoryAddress gAddresses[5]; // Allows 4 dcc addresses: [XX] = number of addresses you need (including 0). const unsigned long releaseTimeout_ms = 2000; //reduced to 2 seconds for now const long MOTOR_STEP_COUNT = 200 * 16; //number of steps for a full rotation //new stuff boolean tableTargetHead = false; //the new variable for Head/Tail Position either from DCC or Analog int tableTargetPosition = 0; //the new variable for Table Postition either from DCC or Analog boolean newTargetLocation = false; boolean buttonPushedHead = false; boolean buttonPushedTail = false; boolean inMotionToNewTarget = false; boolean isReleased = false; // isReleased tries to make sure the motor is not continuously released unsigned long stepperLastMoveTime = 0; const long MOTOR_OVERSHOOT = 10; // the amount of overshoot/ lash correction when approaching from CCW int overshootDestination = -1; //Servo Stuff Servo brakeservo; // create servo object to control a servo const int servoBrake = 9; //value for brake position const int servoRelease = 2; //value for release position //Programming button variables boolean programmingMode = false; boolean programmingModeMoveForward = true; //If in programming mode, are we moving forward? unsigned long programmingLastMoveMillis = 0; //When was the last programming move done? const int programRotateDelay = 100; //Delay between steps in ms while holding button //location variables const int A = 144; //TT Track 0- Head const int B = 328; //TT Track 1- Head const int C = 482; //TT Track 2- Head const int D = 632; //TT Track 3- Head const int N = 1745; //TT Track 0- Tail const int O = 1928; //TT Track 1- Tail const int P = 2080; //TT Track 2- Tail const int Q = 2230; //TT Track 3- Tail const int PositionTrackHead[] = { A, B, C, D }; const int PositionTrackTail[] = { N, O, P, Q }; //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // // Adafruit Setup Adafruit_MotorShield AFMStop(0x60); // Default address, no jumpers // Connect stepper with 200 steps per revolution (1.8 degree) // to the M3, M4 terminals (blue,yellow,green,red) Adafruit_StepperMotor *myStepper2 = AFMStop.getStepper(200, 2); // you can change these to SINGLE, DOUBLE, INTERLEAVE or MICROSTEP! // wrapper for the motor! (3200 Microsteps/revolution) void forwardstep2() { myStepper2->onestep(BACKWARD, MICROSTEP); } void backwardstep2() { myStepper2->onestep(FORWARD, MICROSTEP); } void release2() { myStepper2->release(); } // Now we'll wrap the stepper in an AccelStepper object AccelStepper stepper2 = AccelStepper(forwardstep2, backwardstep2); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Decoder Initiation // void ConfigureDecoder() { //Put all the decoder #'s you need here. Remember to change //DCCAccessoryAddress gAddresses[XX];(above) where XX = number of addresses you need. gAddresses[0].address = 200; gAddresses[1].address = 201; gAddresses[2].address = 202; gAddresses[3].address = 203; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Basic accessory packet handler // void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data) { // Convert NMRA packet address format to human address address -= 1; address *= 4; address += 1; address += (data & 0x06) >> 1; boolean enable = (data & 0x01) ? 1 : 0; for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++) { if( address == gAddresses[i].address ) { Serial.println(""); Serial.print("DCC addr: "); Serial.print(address,DEC); Serial.print(" Head/Tail = (1/0) : "); Serial.println(enable,DEC); //new stuff tableTargetHead = enable; tableTargetPosition = i; //picture loop u8g.firstPage(); do { draw(tableTargetPosition, tableTargetHead); } while( u8g.nextPage() ); //New packet and we have a new target location, set the flag newTargetLocation = true; doStepperMove(); // old location for if/else statements } } } ///////////////////////////////////////////////////////////////////////////// // // draw ug8 display // void draw(int address, boolean enable) { // graphic commands to redraw the complete screen should be placed here u8g.setFont(u8g_font_unifont); u8g.setPrintPos(20, 25); u8g.print("Position "); u8g.print(address,DEC); u8g.setPrintPos(20, 45); if (enable) { u8g.print("Head"); } else { u8g.print("Tail"); } u8g.drawRFrame(0,0,128,64,8); } ///////////////////////////////////////////////////////////////////////////// // // readAnalogLocation() Reads the pot input on analog pin 1, displays some // information out the serial, and sets the target position variable // int readAnalogLocation() { int potDisp = analogRead(1); int potOut = potDisp / 79; //1023 / 13 Serial.println(""); Serial.print("Analog Location: "); Serial.print("Track # "); Serial.print(potOut, DEC); Serial.print(" Head/Tail = (1/0) : "); Serial.println(tableTargetHead, DEC); //tableTargetPosition = potOut; return potOut; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Subroutine: doStepperMove() // Moves the stepper based on location inputs, calls up "SetStepperTargetLocation()" // /////////////////////////////////////// void doStepperMove() { // Run the Stepper Motor // stepper2.run(); boolean isInMotion = (abs(stepper2.distanceToGo()) > 0); boolean newTargetSet = false; // If there is a new target location, set the target if (newTargetLocation) { Serial.println("Moving to New Target Location..."); SetStepperTargetLocation(); newTargetSet = true; } if (inMotionToNewTarget) { if ((!isInMotion) && (!newTargetSet)) { Serial.print("Not Moving! DtG: "); Serial.print(stepper2.distanceToGo()); Serial.print(" TP: "); Serial.print(stepper2.targetPosition()); Serial.print(" CP: "); Serial.print(stepper2.currentPosition()); Serial.print(" S: "); Serial.print(stepper2.speed()); Serial.println(); } //release the brake brakeservo.write(servoRelease); delay (5); inMotionToNewTarget = isInMotion; } else { if (programmingMode) { //If we are programming, do that move //release the brake brakeservo.write(servoRelease); delay (5); if ((millis() - programmingLastMoveMillis) >= programRotateDelay) { programmingLastMoveMillis = millis(); stepper2.move(programmingModeMoveForward ? 1 : -1); Serial.println(""); Serial.print("Programming mode, Current location: "); Serial.println(stepper2.currentPosition()); int potDisp = analogRead(1); int potOut = potDisp / 79; //1023 / 13 Serial.print("Analog Location: "); Serial.print("Track # "); Serial.println(potOut, DEC); delay(45); } } if ((stepper2.currentPosition() % MOTOR_STEP_COUNT) == 0) { //setCurrentPosition seems to always reset the position to 0, ignoring the parameter Serial.print("Current location: "); Serial.print(stepper2.currentPosition()); Serial.println(" % STEPCOUNT. Why here?"); } } //stepper timer subroutine came from here. } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Subroutine: SetStepperTargetLocation() // Takes the global variables: tableTargetHeadOrTail, and tableTargetPosition, and sets the stepper2 // object moveTo() target position in steps- inserts values back into "doStepperMove()" // /////////////////////////////////////// void SetStepperTargetLocation() { int newTargetLoc = -1; if (tableTargetHead) { //use head location variable { newTargetLoc = PositionTrackHead[tableTargetPosition]; inMotionToNewTarget = true; } } else { //use tail location variable { newTargetLoc = PositionTrackTail[tableTargetPosition]; inMotionToNewTarget = true; } } if (newTargetLoc > 0) { int currentLoc = stepper2.currentPosition(); int mainDiff = newTargetLoc - currentLoc; if (mainDiff > (MOTOR_STEP_COUNT / 2)) { mainDiff = mainDiff - MOTOR_STEP_COUNT; } else if (mainDiff < (-MOTOR_STEP_COUNT / 2)) { mainDiff = mainDiff + MOTOR_STEP_COUNT; } if (mainDiff < 0) { mainDiff -= MOTOR_OVERSHOOT; overshootDestination = MOTOR_OVERSHOOT; } stepper2.move(mainDiff); } programmingMode = false; newTargetLocation = false; } ////////////////////////////////////////////////////////////////////////////////////////////////// // // Stepper Timer sub routine this runs from the main loop. It also supports the release function. // ////////////////////////////////////////////////////////////////////////////////////////////////// void stepperTimer() { // Run the Stepper Motor // stepper2.run(); boolean isInMotion = (abs(stepper2.distanceToGo()) > 0); //Check if we have any distance to move for release() timeout. Can check the // buffered var isInMotion because we also check the other variables. if (isInMotion || programmingMode ) { //We still have some distance to move, so reset the release timeout stepperLastMoveTime = millis(); isReleased = false; } else { if (!isReleased) { if (overshootDestination > 0) { stepper2.move(overshootDestination); overshootDestination = -1; } if (((millis() - stepperLastMoveTime) >= releaseTimeout_ms)) { //If isReleased, don't release again. isReleased = true; Serial.print ("Relative Current Position: "); Serial.print(stepper2.currentPosition()); //shows position the table thinks it is at (how it got here) int currentLoc = stepper2.currentPosition(); // Resets the positon to the actual positive number it should be currentLoc = currentLoc % MOTOR_STEP_COUNT; if (currentLoc < 0) { currentLoc += MOTOR_STEP_COUNT; } stepper2.setCurrentPosition(currentLoc); stepper2.moveTo(currentLoc); Serial.print (" Actual Current Position: "); Serial.println(stepper2.currentPosition()); // shows the position value corrected. //Set the servo brake brakeservo.write(servoBrake); delay(750); //release the motor release2(); Serial.println(" Brake Set & Motor Released "); } } } } /////////////////////////////////////////////////////// // // Check Programming Buttons- look for either of the programming buttons being pushed // void checkProgrammingButtons() { programmingMode = false; bool buttonPushedProgUp = (digitalRead(6) == LOW); bool buttonPushedProgDown = (digitalRead(7) == LOW); //If one button is pushed, but not both if ((buttonPushedProgDown || buttonPushedProgUp) && !(buttonPushedProgDown && buttonPushedProgUp)) { programmingMode = true; programmingModeMoveForward = buttonPushedProgUp; doStepperMove(); } } /////////////////////////////////////////////////////////////// // Manual move to using the pushbuttons and POT // void checkManualButtons() { //Read the Head button input if (digitalRead(4) == LOW) { buttonPushedHead = true; } else if (buttonPushedHead) { //Button was pushed, but is not being pushed now //Clear pushed variable buttonPushedHead = false; //Set the target head variable tableTargetHead = true; //Read the analog location tableTargetPosition = readAnalogLocation(); //Then set the new target flag newTargetLocation = true; doStepperMove(); } //Read the Tail button input if (digitalRead(5) == LOW) { buttonPushedTail = true; } else if (buttonPushedTail) { //Button was pushed, but is not being pushed now //Clear pushed variable buttonPushedTail = false; //Set the target head variable tableTargetHead = false; //Read the analog location tableTargetPosition = readAnalogLocation(); //Then set the new target flag newTargetLocation = true; doStepperMove(); } } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // // Setup // void setup() { Serial.begin(9600); AFMStop.begin(); // Start the shield //servo brake release before stepp moves brakeservo.attach(10); // attaches the servo on pin 10 to the servo object brakeservo.write(servoRelease); delay (30); //initial display tableTargetHead = true; tableTargetPosition = 0; u8g.firstPage(); do { draw(tableTargetPosition, tableTargetHead); } while( u8g.nextPage() ); //configure pin3 as an input and enable the internal pull-up resistor pinMode(3, INPUT_PULLUP); //Hall Effect sensor: to reset position on startup //configure pin4 as an input and enable the internal pull-up resistor pinMode(4, INPUT_PULLUP); //Head button //configure pin5 as an input and enable the internal pull-up resistor pinMode(5, INPUT_PULLUP); //Tail button //configure pin6 as an input and enable the internal pull-up resistor pinMode(6, INPUT_PULLUP); //Programming: Move forward single step //configure pin7 as an input and enable the internal pull-up resistor pinMode(7, INPUT_PULLUP); //Programming: Move reverse single step //read the sensoron Dig I/O #3 (open collector type- Hall Effect sensor) value into a variable int sensorVal = digitalRead(3); //set stepper motor speed and acceleration stepper2.setMaxSpeed(80.0); stepper2.setAcceleration(10.0); // if near reference point move away while (sensorVal == LOW) { sensorVal = digitalRead(3); forwardstep2(); delay(25); Serial.println("Stepper Home"); } // step backward to sensor index point while (sensorVal == HIGH) { sensorVal = digitalRead(3); backwardstep2(); delay(50); } //when home- sets brake delay (500); brakeservo.write(servoBrake); //initial track position 0 head newTargetLocation = true; doStepperMove(); DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true); ConfigureDecoder(); DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT ); } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Main loop // void loop() { static int addr = 0; //////////////////////////////////////////////////////////////// // Loop DCC library DCC.loop(); //////////////////////////////////////////////////////////////// // Bump to next address to test if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) ) { addr = 0; } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // To configure the POT (uncomment this text) //configure alalog pin 1 as an input // int potDisp = analogRead(1); // // int potOut = potDisp / 79; //1023 / 13 // delay(1000); // Serial.print("Analog Location: "); // Serial.println(potOut); // end of POT configuration- re-comment this section to hide during normal use //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // To configure the Servo Brake (uncomment this text) //configure alalog pin 1 as an input // int potDisp = analogRead(1); // reads the value of the potentiometer (value between 0 and 1023) // int potOut = map(potDisp, 0, 1023, 0, 50); // scale it to use it with the servo (value between 0 and 180) // brakeservo.write(potOut); // sets the servo position according to the scaled value // delay(1000); // Serial.print("Servo Position Value: "); // Serial.println(potOut); // end of POT configuration- re-comment this section to hide during normal use //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Tests to see if the manual move buttons are pressed, if so set the needed flags checkManualButtons(); //Checks the programming buttons, if depressed then set the right flags checkProgrammingButtons(); //StepperAccel.Run() in this function stepperTimer(); }