Arduino controlled Turntable for 3D Photography

1/*********
2  This project has been developed and produced by Pierre   Pennings (September/October 2019),
3  It applies parts of the code (related to   BLE client/server) published by Rui Santos https://randomnerdtutorials.com/courses   : Learn ESP32 with Arduino IDE
4  His book has been a great help for me to realise   this project.
5
6  This Project is about making a (3D printed) Turntable rotate   in a selectable number of steps per 360 degrees using a Stepper Motor.
7  The   turntable's housing contains a ESP 32 (NodeMCU) that is programmed as a Bluetooth   Low Energy (BLE) server.
8  After every step of x degrees, the turntable stops   and sends a command over the Bluetooth
9  connection to another ESP32, that is   set up as e BLE Client.
10  The BLE Client is interfaced with a Sony HX400V Camera   through a special Multiconnector (looks like a micro USB C)
11  to activate the   focus and the camera shutter and then move another step of x degrees. At the same   time a LED spotlight can be activated.
12  
13  The ESP 32 device works at 3.3   Volt levels.
14  The ESP module is fed with 5 V derived from the Stepper Motor   driver L298N which is connected to a 12V 3A supply.
15  The 12V connection is used   to power the Stepper Motor.
16  The ESP 32 that has an on-board 3.3V voltage regulator,   which is used for powering the 128*64 OLED display.
17  Four different pushbuttons   are used to control the turntable.
18      * the RED button (ModeSelect) is used   for interaction with the OLED display for mode settings
19      * The righthand   GREEN button (ManualShot) is used for confirmation of the selected turning mode.
20       (and could also be programmed for taking manual pictures with the remote camera)
21       * The GREEN button (GoToOrigin) left of the OLED Display is used for commanding   the turntable to its ORIGIN Position (sensed with a switch underneath the turntable)
22       * The other GREEN button (StartPause) on the most left of the OLED Display   is used for starting or pausing an action and choosing another mode
23      (with   the current programme it causes a system reset and gets you back to the WELCOME   menu)
24      
25  This code is licensed under GPL3+ license.
26  
27*********/
28
29#include   <BLEDevice.h>                                                  // Include the BLE   Libraries
30#include <BLEServer.h>
31#include <BLEUtils.h>
32#include <BLE2902.h>
33
34#include   <AccelStepper.h>                                               // Include the Arduino   AccelStepper Library
35#define FULL4WIRE 4                                                     //   defines the type of StepperMotor used (NEMA 17)
36
37#include <Wire.h>                                                       //   Include the Libraries for the OLED display
38#include <Adafruit_SSD1306.h>
39#include   <Adafruit_GFX.h>
40
41#define SCREEN_WIDTH 128                                                //   OLED display width, in pixels
42#define SCREEN_HEIGHT 64                                                //   OLED display height, in pixels
43#define OLED_RESET -1
44
45Adafruit_SSD1306   display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
46
47#define bleServerName   "TurnTableESP32"                                  //BLE server name
48#define   SERVICE_UUID "e6c24700-6f9c-4bf4-b078-4fc82fad3e28"             //See for generating   UUIDs: https://www.uuidgenerator.net/
49
50BLECharacteristic CONTROLCharacteristics("1e0ed88a-1b69-4197-83fa-0373670c4819",   BLECharacteristic::PROPERTY_NOTIFY);
51BLEDescriptor CONTROLDescriptor(BLEUUID((uint16_t)0x2903));
52
53/////////////////////////////////initialise   the GPIO pins///////////////////////////////////////////////////////////////////////////////////////////////////////////////
54const   int BlueToothPin = 12;                                            // GPIO Pin 12   of ESP32 connected to BlueLED for showing the BlueToothStatus
55const int ModeSelectPin   = 13;                                           // GPIO Pin 13 of ESP32 to select   the Mode of operation of the Turntable (Red button)
56const int StartPausePin =   32;                                           // GPIO Pin 32 of ESP32 connected   to a Green Pushbutton for Starting/Pausing the Turntable
57const int GoToOriginPin   = 33;                                           // GPIO Pin 33 of ESP32 connected   to a Green Pushbutton for commanding the Turntable to origin position
58const int   ManualShotPin = 4;                                            // GPIO Pin 4 of ESP32   connected to Pushbutton for taking a manual shot
59const int OriginPin = 15;                                               //   GPIO Pin 15 of ESP32 connected to a switch on the turntable to sense that the Turntable   has reached the Origin position
60const int motorPin1 = 14 ;                                              //   IN1 on the L298 N driver (Blue)
61const int motorPin2 = 27 ;                                              //   IN2 on the L298 N driver (Pink)
62const int motorPin3 = 26 ;                                              //   IN3 on the L298 N driver (Yellow)
63const int motorPin4 = 25 ;                                              //   IN4 on the L298 N driver (Orange)
64// NOTE: GPIO Pin 21 of ESP32 is connected   to the SDA pin and GPIO Pin 22 of ESP32 is connected to the SCL pin of the OLED   display; no initialisation is needed for these pins
65
66const int stepsPerRevolution   = 200;                                     // Number of steps for one 360 degrees   rotation of the Stepper Motor
67
68//////////////////////////////////initialise   the Global variables///////////////////////////////////////////////////////////////////////////////////////////////////////
69int   ShootPinState = 1;                                                  // variable   for reading the Manual Shoot pushbutton status
70
71float stepperSpeed = 800;                                                //speed of the steppermotor (steps   per second)
72int Revcount = 0 ;                                                      //   Number of revolutions to made since Start
73int stepcount = 0 ;                                                     //   variable for counting the steps in the 360 degrees turn
74int turnmode = 0  ;                                                     //   variable for selecting the turning mode of the Turntable
75                                                                        //   1 => 5 steps of 72 degrees, 2 => 10 steps of 36 degrees, 3 => 15 steps of 24 degrees,   4 => 20 steps of 18 degrees,  5 = continous rotation
76
77volatile bool GoToOriginState   = false;
78volatile bool StartPauseState = false;
79
80void IRAM_ATTR GotoORIGIN()
81     {
82    GoToOriginState = true;
83    Serial.println("GoToOrigin pushed");
84     }
85
86void IRAM_ATTR STARTPAUSE()
87    {
88    StartPauseState = true;
89     Serial.println("StartPause button pushed");
90    }
91    
92bool deviceConnected   = false;
93bool BLE = false;
94char TakeAuto[11] = "AutoShot";
95char TakeManual[11]   = "ManualShot";
96
97
98///////////////////////////////// Create Instance of   Stepper library//////////////////////////////////////////////////////////////////////////////////////////////////////
99AccelStepper   stepper(FULL4WIRE, motorPin1, motorPin2, motorPin3, motorPin4);
100
101/////////////////////////////////set   up of the callbacks procedure for BLE////////////////////////////////////////////////////////////////////////////////////////////////
102class   MyServerCallbacks: public BLEServerCallbacks                      //Setup callbacks   onConnect and onDisconnect
103{
104  void onConnect(BLEServer* pServer) {
105    deviceConnected   = true;
106  };
107  void onDisconnect(BLEServer* pServer) {
108    deviceConnected   = false;
109  }
110};
111
112///////////////////////////////the setup code that   follows, will run once after "Power On" or after a RESET////////////////////////////////////////////////////////////////
113void   setup() {
114  Serial.begin(115200);                                                 //   Start serial communication with serial monitor of the Arduino IDE
115
116  pinMode   (motorPin1, OUTPUT);                                          // Set the motorPin1   as output
117  pinMode (motorPin2, OUTPUT);                                          //   Set the motorPin2 as output
118  pinMode (motorPin3, OUTPUT);                                          //   Set the motorPin3 as output
119  pinMode (motorPin4, OUTPUT);                                          //   Set the motorPin4 as output
120  pinMode (BlueToothPin, OUTPUT);                                       //   Set the BlueToothPin as output
121
122  pinMode (ManualShotPin, INPUT_PULLUP);                                //   Set the ManualShotPin as input and use the internal pullup resistor to set the Pin   to HIGH
123  pinMode (ModeSelectPin, INPUT_PULLUP);                                //   Set the ModeSelectPin as input and use the internal pullup resistor to set the Pin   to HIGH
124  pinMode (StartPausePin, INPUT_PULLUP);                                //   Set the StartPausePin as input and use the internal pullup resistor to set the Pin   to HIGH
125  pinMode (GoToOriginPin, INPUT_PULLUP);                                //   Set the GoToOriginPin as input and use the internal pullup resistor to set the Pin   to HIGH
126  pinMode (    OriginPin, INPUT_PULLUP);                                //   Set the     OriginPin as input and use the internal pullup resistor to set the Pin   to HIGH
127
128  attachInterrupt(digitalPinToInterrupt(GoToOriginPin), GotoORIGIN,   FALLING); 
129  Serial.print("goto origin pin  "); Serial.println(GoToOriginState);
130
131   attachInterrupt(digitalPinToInterrupt(StartPausePin), STRTPSE, FALLING); 
132   Serial.print("Start/pause pin  "); Serial.println(StartPauseState);
133  
134   Wire.begin();                                                         //OLED display   setup
135  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  
136  display.clearDisplay();
137   
138  stepper.setMaxSpeed(3000.0);                                          //   setting the maximum speed of the steppermotor
139  stepper.setSpeed(stepperSpeed);                                        // setting the running speed of the steppermotor   at the value of stepperSpeed
140  stepper.setAcceleration (200.0);                                      //   setting the Acceleration of the steppermotor 
141
142  /////////////////////herafter   functions are called for setting up the Turntable Server//////////////////////////////////////////////////////////////////////////   
143  WELCOME ();                                                           //displaying   a welcome message until the red button is pushed
144  TURNTABLEMODES ();                                                    //displaying   the possible turntable modes of operation 
145  delay (200);
146  HOWTOSET ();                                                          //displaying   an explanation how to select the turntable modes
147  SETMODE ();                                                           //setting   the turntable modes by pushing the red button and selecting with the green button
148   delay (2000);                                                         //display   selected mode for 2 seconds
149  ORIGIN ();                                                            //controlling   the turntable to an origin position
150 
151
152  /////////////////////routine for   setting up the Bluetooth connection with the Camera Client//////////////////////////////////////////////////////////////////////////
153   BLEDevice::init(bleServerName);                                       // Create   the BLE Device
154  BLEServer *pServer = BLEDevice::createServer();                       //   Create the BLE Server
155  pServer->setCallbacks(new MyServerCallbacks());
156  BLEService   *ControlService = pServer->createService(SERVICE_UUID);    // Create the BLE Service
157   
158  ControlService->addCharacteristic(&CONTROLCharacteristics);            //Create   BLE Characteristics
159  CONTROLDescriptor.setValue("Control");                                 //Create   a BLE Descriptor
160  CONTROLCharacteristics.addDescriptor(new BLE2902());                   //Descriptor   https://www.bluetooth.com/specifications/gatt/descriptors/  
161  
162  ControlService->start();                                                // Start the service
163  pServer->getAdvertising()->start();                                     // Start advertising
164  Serial.println("Trying   to make a BLE connection with the Camera client"); 
165  }
166
167////////////////////////////the   loop code that follows, will run repeatedly until "Power Off" or a RESET///////////////////////////////////////////////////////////////
168void   loop() {
169  
170  CONNECTION();
171    
172  switch (turnmode) {    
173      case   1:                                                           // Turnmode 1: 5 X   72 dgr)
174        STARTandTURN();
175        break;
176          
177      case   2:                                                           // Turnmode 2: 10 X   36 dgr)
178        STARTandTURN();
179        break;
180        
181      case 3:                                                            // Turnmode 3: 15 X 24   dgr)
182        STARTandTURN();
183        break;
184        
185      case 4:                                                           //   Turnmode 4: 20 X 18 dgr)
186        STARTandTURN();
187        break;
188        
189       case 5:                                                           // Turnmode   5: CONTINUOUS
190        STARTCONTINUOUS ();
191        break;    
192                  }   
193}
194//////////////////END of LOOP////////////////////////////////////
195
196/////////////////Hereafter   follows the Function for sending a Command message to the Client
197void SendCommand   (char message [10])
198    {
199    CONTROLCharacteristics.setValue(message);                           //Set   Characteristic value as an integer and notify connected client
200    CONTROLCharacteristics.notify();    
201    }
202
203/////////////////Hereafter follows the Function for displaying   a Welcome message at Start-up of the Turntable on the OLED Display////////////////////////////////////////
204void   WELCOME ()
205    {
206  display.startWrite();
207  display.setTextSize(2);
208   display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
209   display.setCursor(0,0);
210  display.println("WELCOME! ");
211  display.setTextSize(1);
212   display.println("Automatic TurnTable");
213  display.println("by Pierre Pennings");
214   display.println("to make 3D pictures");
215  display.println("");
216  display.setTextColor(BLACK,   WHITE);                                   // Draw 'inverse' text
217  display.println("to   PROCEED:");
218  display.println("    Push RED BUTTON");
219  display.display();
220
221   while (digitalRead (ModeSelectPin))
222    { 
223     digitalWrite(BlueToothPin,   HIGH);                                  // turn the blue LED on
224     delay(10);                                                          // wait 10 miliseconds
225      digitalWrite(BlueToothPin, LOW);                                   // turn   the LED off by making the voltage LOW
226     delay(500);                                                        //   wait 500 miliseconds
227    } 
228  delay(500);
229  Serial.println(" ModeSelectPin   = 01  ");
230  digitalWrite(BlueToothPin, LOW);                                      //   turn the blue LED off
231  display.clearDisplay();
232    }
233
234/////////////////Hereafter   follows the Function for displaying the possible Turntable Modes on the OLED Display/////////////////////////////////////////////////////////////
235void   TURNTABLEMODES ()
236    {
237  display.startWrite();
238  display.setTextSize(2);
239   display.setCursor(0,0);
240  display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
241   display.println("TURNTABLE");
242  display.setTextSize(1);
243  display.println("Mode   1 =  5 * 72 dgr");
244  display.println("Mode 2 = 10 * 36 dgr");
245  display.println("Mode   3 = 15 * 24 dgr");
246  display.println("Mode 4 = 20 * 18 dgr");
247  display.println("Mode   5 = Continuous");
248  display.setTextColor(BLACK, WHITE);                                   //   Draw 'inverse' text
249  display.println("PROCEED: RED BUTTON");
250  display.display();
251   
252  while (digitalRead (ModeSelectPin))
253    { 
254     digitalWrite(BlueToothPin,   HIGH);                                  // turn the blue LED on
255     delay(10);                                                          // wait 10 miliseconds
256      digitalWrite(BlueToothPin, LOW);                                   // turn   the LED off by making the voltage LOW
257     delay(500);                                                        //   wait 500 miliseconds
258    }
259   delay(500);
260   Serial.println(" ModeSelectPin   == 02  ");
261   digitalWrite(BlueToothPin, LOW);                                      //   turn the blue LED off
262   display.clearDisplay();
263    }
264
265/////////////////Hereafter   follows the Function for displaying an instruction about How to Set the possible   Turntable Modes ////////////////////////////////////////////////////
266void HOWTOSET   ()
267    {
268  display.startWrite();
269  display.setTextSize(2);
270  display.setCursor(0,0);
271   display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
272   display.println("HOW TO SET");
273  display.setTextSize(1);
274  display.println("to   change TurnMode:");
275  display.setTextColor(BLACK, WHITE);                                   //   Draw 'inverse' text
276  display.println("push RED BUTTON");
277  display.setTextColor(WHITE);                                           //display.setBackgroundcolor(WHITE);
278   display.println("");
279  display.println("if TurnMode is OK :");
280  display.setTextColor(BLACK,   WHITE);                                   // Draw 'inverse' text
281  display.println("push   GREEN BUTTON");
282  display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
283   display.println("-ManualShot Button-");
284  display.display();
285    }
286
287/////////////////Hereafter   follows the Function for setting/changing the Turn Mode and displaying the Selected   Turntable Mode on the OLED display //////////////////////////////////
288void SETMODE   ()
289    {
290CHANGEMODE:
291    turnmode = turnmode + 1;
292    display.clearDisplay();
293     display.startWrite();
294    display.setTextSize(2);
295    display.setCursor(0,0);
296     display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
297     display.print("MODE =");
298    display.setCursor(90,0);
299    display.println(turnmode);
300     display.setCursor(0,45);
301    display.setTextSize(1);
302    display.setTextColor(BLACK,   WHITE);                                   // Draw 'inverse' text
303    display.println("Red   Button to change");
304    display.setCursor(0,55);
305    display.println("GREEN   Button to stop");
306    display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
307     display.setTextSize(2);
308    display.setCursor(0,20);
309  while (digitalRead   (ModeSelectPin))
310      { 
311    digitalWrite(BlueToothPin, LOW);                                      //   turn the LED off by making the voltage LOW   
312    if (!digitalRead(ManualShotPin))         
313        {
314      Serial.println("GREEN BUTTON pushed");
315      turnmode   = turnmode-1 ;
316      goto STOPCHANGEMODE;
317        }
318      }
319    {
320     digitalWrite(BlueToothPin, HIGH);                                     // turn   the blue LED on
321  switch (turnmode) {
322        case 1:
323          display.println("5X   72 dgr");
324          display.display();
325          break;
326        case 2:      
327          display.println("10X 36 dgr");
328          display.display();
329           break;
330        case 3:
331          display.println("15X 24 dgr");
332           display.display();
333          break;
334        case 4:
335          display.println("20X   18 dgr");
336          display.display();
337          break;
338        case 5:
339           display.println("CONTINUOUS");
340          display.display();
341          break;     
342                  }  
343    delay(500);
344    Serial.println("RED BUTTON   pushed");
345    Serial.print(" turnmode "); Serial.println(turnmode);
346    if   (turnmode > 5)  {turnmode = 0;}
347    goto CHANGEMODE;
348    }
349
350    STOPCHANGEMODE:
351     //Serial.println("GREEN BUTTON pushed");
352    digitalWrite(BlueToothPin,   LOW);                                      // turn the blue LED off
353    display.clearDisplay();
354     display.startWrite();
355    display.setTextSize(2);
356    display.setCursor(5,0);
357     display.setTextColor(BLACK, WHITE);                                   // Draw   'inverse' text
358    display.println(" SELECTED ");
359    display.setCursor(5,20);
360     display.print(" MODE: ");
361    display.print(turnmode); display.println("   ");
362    display.setCursor(0,45);
363    display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
364     
365    switch (turnmode) {
366        case 1:
367          display.println("5X   72 dgr");
368          display.display();
369          break;
370        case 2:      
371          display.println("10X 36 dgr");
372          display.display();
373           break;
374        case 3:
375          display.println("15X 24 dgr");
376           display.display();
377          break;
378        case 4:
379          display.println("20X   18 dgr");
380          display.display();
381          break;
382        case 5:
383           display.println("CONTINUOUS");
384          display.display();
385          break;     
386                  }  
387    }
388
389/////////////////Hereafter follows   the Function for setting up the BLE connection to the Camera or proceeding without   connection  ////////////////////////////////////////
390void CONNECTION ()
391    {
392     while (deviceConnected == false)
393    { 
394     digitalWrite(BlueToothPin,   HIGH);                                  // turn the blue LED on
395     delay(50);                                                          // wait 50 miliseconds
396      digitalWrite(BlueToothPin, LOW);                                   // turn   the LED off by making the voltage LOW
397     delay(100);                                                        //   wait 100 miliseconds
398     Serial.println("trying to connect");
399     display.clearDisplay();
400      display.startWrite();
401     display.setTextSize(2);
402     display.setCursor(0,0);
403      display.setTextColor(WHITE);                                       //display.setBackgroundcolor(WHITE);
404      display.println("BLUETOOTH");
405     display.println("CONNECTING");
406      display.setTextSize(1);
407     display.println("to proceed without");
408      display.println("Bluetooth");
409     display.println();
410     display.setTextColor(BLACK,   WHITE);                                // Draw 'inverse' text
411     display.println("PUSH   RED BUTTON");
412     display.display();
413
414    while (digitalRead (ModeSelectPin)   == false)
415    { 
416      Serial.println(" proceed without BLE  ");
417      digitalWrite(BlueToothPin,   LOW);                                  // turn the blue LED off
418      display.clearDisplay();
419       display.startWrite();
420      display.setTextSize(2);
421      display.setCursor(0,0);
422       display.setTextColor(WHITE);                                      //display.setBackgroundcolor(WHITE);
423       display.println("PROCEEDING");
424      display.println("WITHOUT");
425       display.println("BLUETOOTH");
426      display.display();
427      BLE =   false;
428      delay (2000);
429      goto STARTTURNING;
430    } 
431  }
432  if   (deviceConnected){
433     digitalWrite(BlueToothPin, HIGH);                                  //   turn the blue LED on
434     display.clearDisplay();
435     display.startWrite();
436      display.setTextSize(2);
437     display.setCursor(0,0);
438     display.setTextColor(WHITE);                                        //display.setBackgroundcolor(WHITE);
439      display.println("BLUETOOTH");
440     display.println("CONNECTED!");
441      display.display();
442     BLE = true;
443     delay (2000);
444    }
445  STARTTURNING:;
446     }
447
448/////////////////Hereafter follows the Function for Starting the Turning   of the Turntable  ////////////////////////////////////////////////////////////////////////////////
449void   STARTandTURN ()
450    {
451    while (digitalRead (ModeSelectPin) == true)
452         { 
453          Serial.println("Push RED Button to start");
454          display.clearDisplay();
455           display.startWrite();
456          display.setTextSize(2);
457          display.setCursor(0,0);
458           display.setTextColor(WHITE);                               //display.setBackgroundcolor(WHITE);
459           display.println("TO START");
460          display.println("TURNING");
461           display.setCursor(0,45);
462          display.setTextColor(BLACK, WHITE);                         // Draw 'inverse' text
463          display.println("RED   BUTTON");
464          display.display();
465        }
466                     
467      for (Revcount = 1; Revcount <= (turnmode *5) ; Revcount++) {   
468          Serial.print("Revcount   "); Serial.println(Revcount);
469          display.clearDisplay();
470          display.startWrite();
471           display.setTextSize(2);
472          display.setCursor(0,0);
473          display.setTextColor(WHITE);                                 //display.setBackgroundcolor(WHITE);
474          display.println("   STEP");
475          display.print("  ");
476          display.print(Revcount);
477           display.print(" / ");
478          display.println(turnmode *5);
479           display.display();
480          
481          stepper.setSpeed(stepperSpeed/turnmode);                     // set the stepperSpeed at xx steps per second, depending on   the turnmode
482          stepper.runToNewPosition (stepsPerRevolution/(turnmode*5)*Revcount);      //Moves the motor (with acceleration/deceleration) to the new target position   (blocks until it is at position).
483          
484          display.setCursor(0,42);
485           display.setTextSize(3);
486          if (BLE == 1){
487          display.println("   SHOOT!");                                 // display the fact that the TakeAuto   command is given via Bluetooth connection to camera
488          display.display();
489           delay (500);}
490          display.setCursor(0,30);
491          display.println("          ");                               // clear the SHOOT field on the display
492           display.display();
493          SendCommand (TakeAuto);
494          delay(2500);
495            
496          if (GoToOriginState == true)                                //   check if Go To Origin button has been pushed
497          {ORIGIN (); GoToOriginState   = false; Revcount = 0 ; }
498
499        }
500          stepper.stop();                                             //Sets   a new target position that causes the stepper to stop as quickly as possible, using   the current speed and acceleration parameters. 
501          stepper.setCurrentPosition(0);
502           stepper.disableOutputs();                                   //control   of the steppermotor is disabled to avoid unnecessary heating of the motor
503        
504          // if (StartPauseState == true)                               // check   if StartPause button has been pushed
505         // {/*STRTPSE ()*/ SETMODE ();   StartPauseState = false; }     // THIS DOES NOT WORK THE WAY IT IS MEANT; Pushing   the Start/Pause button causes a reset and you enter the welcome menu; which is fine   for the moment
506    }
507       
508
509 /////////////////Hereafter follows the   Function for Starting the CONTINUOUS Turning of the Turntable  /////////////////////////////////////////////////////////////////
510void   STARTCONTINUOUS ()
511    {
512          Serial.println("Continuous Rotation ");
513           display.clearDisplay();
514          display.startWrite();
515          display.setTextSize(2);
516           display.setCursor(0,0);
517          display.setTextColor(WHITE);                                  //display.setBackgroundcolor(WHITE);
518           display.println("CONTINUOUS");
519          display.println("ROTATION");
520           display.setTextColor(BLACK, WHITE);                           // Draw   'inverse' text
521          display.println("RED BUTTON");
522          display.println("TO   STOP");
523          display.display();
524      do
525       {
526        stepper.setSpeed(40);                                            // rotating at constant speed, until   stopped with red button
527        stepper.move(1);
528        stepper.run();
529        }
530      while (digitalRead (ModeSelectPin) == true );
531        stepper.stop();                                                  //Sets a new target position that   causes the stepper to stop as quickly as possible, using the current speed and acceleration   parameters. 
532        stepper.setCurrentPosition(0);
533        stepper.disableOutputs();                                        //control of the steppermotor is disabled   to avoid unnecessary heating of the motor
534          
535      if (GoToOriginState   == true)                                      // check if Go To Origin button has   been pushed
536         {ORIGIN (); GoToOriginState = false; }
537      //if (StartPauseState   == true)                                    // check if StartPause button has been   pushed
538      //   {STRTPSE (); StartPauseState = false; }                      //   THIS DOES NOT WORK THE WAY IT IS MEANT; Pushing the Start/Pause button causes a   reset and you enter the welcome menu; which is fine for the moment
539       }
540
541/////////////////Hereafter   follows the Function for driving the Turntable to the Origin position  /////////////////////////////////////////////////////////////////////
542   void ORIGIN ()
543    {
544        Serial.print("going to origin, GoToOriginPin   = "); Serial.println((digitalRead (GoToOriginPin)) );
545        display.clearDisplay();
546         display.startWrite();
547        display.setTextSize(2);
548        display.setCursor(0,0);
549         display.setTextColor(WHITE);                                    //display.setBackgroundcolor(WHITE);
550         display.println("GOING TO");
551        display.println("  ORIGIN");
552         display.display();           
553        do
554           {
555           stepper.setSpeed(40);
556            stepper.move(1);                                             // rotating   the Turntable until the OriginPin goes LOW
557           stepper.run();
558           }
559         while ((digitalRead (OriginPin)) == HIGH );
560        stepper.stop();                                                 //Sets   a new target position that causes the stepper to stop as quickly as possible, using   the current speed and acceleration parameters. 
561        stepper.setCurrentPosition(0);
562         delay (100);
563        stepper.disableOutputs();                                       //control   of the steppermotor is disabled to avoid unnecessary heating of the motor
564        
565         Serial.println("Origin Reached ");
566        display.clearDisplay();
567         display.startWrite();
568        display.setTextSize(2);
569        display.setCursor(0,20);
570         display.setTextColor(WHITE);                                    //display.setBackgroundcolor(WHITE);
571         display.println("ARRIVED");
572        display.println("AT ORIGIN");
573         display.display();
574        delay (1000);
575
576        while (digitalRead   (ModeSelectPin) == true)
577        {
578        Serial.println("Push RED Button   to proceed");
579        display.clearDisplay();
580        display.startWrite();
581         display.setTextSize(2);
582        display.setCursor(0,0);
583        display.setTextColor(WHITE);                                //display.setBackgroundcolor(WHITE);
584        display.println("TO   START");
585        display.println("TURNING");
586        display.setCursor(0,45);
587         display.setTextColor(BLACK, WHITE);                        // Draw 'inverse'   text
588        display.println("RED BUTTON");
589        display.display();
590         }
591    }
592
593/////////////////Hereafter follows the Function for pauzing/restarting   Turntable selecting a new mode and to put it back in the Origin position  /////////////////////////
594/////////////////THIS   DOES NOT WORK THE WAY IT IS MEANT; Pushing the Start/Pause button causes a reset   and you enter the welcome menu; which is fine for the moment
595 void STRTPSE ()   
596    { 
597        Serial.print("Start/pause Pin = "); Serial.println((digitalRead   (StartPausePin)) );
598        //display.clearDisplay();
599        //display.startWrite();
600         //display.setTextSize(2);
601        //display.setCursor(0,0);
602        //display.setTextColor(WHITE);                                     //display.setBackgroundcolor(WHITE);
603        //display.println("START   ");
604        //display.println(" / PAUSE");
605        //display.display();
606         //delay (500);         
607     //ORIGIN ();
608     SETMODE ();
609     delay   (1000);
610    }
611

1/*********
2  This project has been developed and produced by Pierre  Pennings (September/October 2019),
3  It applies parts of the code (related to  BLE client/server) published by Rui Santos https://randomnerdtutorials.com/courses  : Learn ESP32 with Arduino IDE
4  His book has been a great help for me to realise  this project.
5
6  This Project is about making a (3D printed) Turntable rotate  in a selectable number of steps per 360 degrees using a Stepper Motor.
7  The  turntable's housing contains a ESP 32 (NodeMCU) that is programmed as a Bluetooth  Low Energy (BLE) server.
8  After every step of x degrees, the turntable stops  and sends a command over the Bluetooth
9  connection to the ESP32, that is set  up as BLE Client. (for which this program has been written.
10  The BLE Client  is interfaced with a Sony HX400V Camera through a special Multiconnector (looks  like a micro USB)
11  to activate the focus and the camera shutter and then move  another step of x degrees.
12  At the same time a LED spotlight will be activated.  The spotlight is controlled by this program.
13  
14  The ESP 32 device works  at 3.3 Volt levels.
15  The ESP module is fed with 5 V derived from a step-up converter  that gets its pimary power from the 3.3v output of the Sony HX400V Camera. 
16  As such the Camera client can be completely housed in a small 3D printed box,  without the need of en external power supply nor batteries.
17  
18  The ESP 32  that has an on-board 3.3V voltage regulator, that uses the 5V from the step up convertor.
19  Actually we are converting from 3.3V o 5V and back to 3.3V (just because the ESP32  does not accept 3.3V as an input).
20  Four different LEDs are used to indicate  the following:
21      * the RED LED to indicate the availability of the the 3.3  V input from the Camera
22      * the BLUE LED to indicate the status of the BLUETOOTH  connection.
23      * the YELLOW LED to indicate that the FOCUS command to the  camera is active
24      * the GREEN LED to indicate that the SHOOT command is  given to the camera.
25      
26  This code is licensed under GPL3+ license.
27  
28*********/
29#include "BLEDevice.h"
30
31//////////////////////constants  that won't change://////////////////////////////////////
32const int YellowLEDPin  = 15;                // YellowLEDPin refers GPIO 15 of ESP32 (for focussing of the  camera)
33const int BlueLEDPin = 16;                  // BlueLEDPin refers GPIO  16 of ESP32
34const int GreenLEDPin = 17;                 // GreenLEDPin refers  GPIO 17 of ESP32 (for taking a shot with the camera)
35const int FlashLEDPin =  4;                  // FlashLEDPin refers GPIO 04 of ESP32
36
37//////////////////////////  Variables:///////////////////////////////////////////////////
38String command[10];
39String  Rx = String ('0');
40
41///////////////////////BLE settings ////////////////////////////////////////////////////
42#define  bleServerName "TurnTableESP32"                                                //the  name of the BLE Server, that we are connecting to
43
44static BLEUUID ControlServiceUUID("e6c24700-6f9c-4bf4-b078-4fc82fad3e28");            //The UUID of the service that we want to read
45static BLEUUID CONTROLCharacteristicUUID("1e0ed88a-1b69-4197-83fa-0373670c4819");     //The UUID of the Characteristic that we want to read
46
47static boolean  doConnect = false;                                                     //Flag indicating  to begin connecting
48static boolean connected = false;                                                     //Flag  indicating if the connection is made
49
50static BLEAddress *pServerAddress;                                                    //Address  of the peripheral device; to be found during scanning.
51static BLERemoteCharacteristic*  CONTROLCharacteristic;                                //the Characteristic that  we want to receive
52
53const uint8_t notificationOn[] = {0x1, 0x0};                                          //Activate  notify
54const uint8_t notificationOff[] = {0x0, 0x0};
55
56//////////////////////////////////////////connect  to Server ////////////////////////////
57bool connectToServer(BLEAddress pAddress)                                             //Connect to the BLE Server that has  the name, Service, and Characteristics
58  {
59    BLEClient* pClient = BLEDevice::createClient();
60    pClient->connect(pAddress);                                                        //  Connect to the remote BLE Server.
61    Serial.println(" - Connected to server");
62  
63    BLERemoteService* pRemoteService = pClient->getService(ControlServiceUUID);        // Obtain a reference to the service we are after in the remote BLE server.
64    if (pRemoteService == nullptr)
65    {
66    Serial.print("Failed to find  our service UUID: ");
67    Serial.println(ControlServiceUUID.toString().c_str());
68    return (false);
69    }
70
71    CONTROLCharacteristic = pRemoteService->getCharacteristic(CONTROLCharacteristicUUID);   // Obtain a reference to the characteristic in the service of the remote BLE  server.
72    if (CONTROLCharacteristic == nullptr)
73    {
74    Serial.print("Failed  to find our characteristic UUID");
75    return false;
76    }
77    Serial.println("  - Found our characteristics");
78    CONTROLCharacteristic->registerForNotify(CONTROLNotifyCallback);                //Assign callback functions for the Characteristics
79  }
80
81//////////////////////////////////////////call  back function /////////////////////////
82class MyAdvertisedDeviceCallbacks: public  BLEAdvertisedDeviceCallbacks              //Callback function that gets called
83                                                                                    //when  another device's advertisement has been received
84  {
85  void onResult(BLEAdvertisedDevice  advertisedDevice)
86    {
87    if (advertisedDevice.getName() == bleServerName)                                //Check if the name of the advertiser matches with  the server name
88      { 
89      advertisedDevice.getScan()->stop();                                           //Scan  can be stopped, we found what we are looking for
90      pServerAddress = new BLEAddress(advertisedDevice.getAddress());               //Address of advertiser is the one we need
91      doConnect = true;                                                             //Set indicator, stating  that we are ready to connect
92      Serial.println("Device found. Connecting!");
93      connected = true;
94      }
95    }
96  };
97
98//////////////////////////////////////////Reading  new data ///////////////////////////
99static void CONTROLNotifyCallback(BLERemoteCharacteristic*  pBLERemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify) 
100    {                                                                               //When  the BLE Server sends a new CONTROL reading with the notify property
101        Rx  = String(*pData);
102        Serial.print("  Command Received: "); Serial.print(Rx);  
103
104      if (Rx == String(77))                                                         //if  the first character of the received pData is 77 HEX (being a B in ASCII), the command  is "ManualShot"
105        {
106        digitalWrite(FlashLEDPin, HIGH);                                            //activates  the FlashLight connected to the server
107        delay (100);                                                                //short  time to enable the Flash LED to achieve its full illuminance level
108        digitalWrite(YellowLEDPin,  HIGH);                                           //put Yellow LED to on; activates  the Focus of the Camera for 0,9 seconds
109        delay (900);
110        digitalWrite(YellowLEDPin,  LOW);                                            //put Yellow LED to Off
111        Serial.println("  ManualShot");
112        digitalWrite(GreenLEDPin, HIGH);                                            //put  Green LED to On; activates the shutter of the Camera for 0,2 seconds
113        delay  (200);
114        digitalWrite(GreenLEDPin, LOW);                                             //put  Green LED to Off
115        Rx = String(0);
116        }
117      if (Rx == String(65))                                                          //if the first character  of the received pData is 65 HEX (being a A in ASCII), the the command is "AutoShot"
118        {
119        digitalWrite(FlashLEDPin, HIGH);                                             //activates  the FlashLight connected to the server
120        delay (100);                                                                 //short  time to enable the Flash LED to achieve its full illuminance level
121        digitalWrite(YellowLEDPin,  HIGH);                                            //put Yellow LED to on; activates  the Focus of the Camera for 0,9 seconds
122        delay (900);
123        digitalWrite(YellowLEDPin,  LOW);                                            //put Yellow LED to Off
124        Serial.println("  Auto Shot");
125        digitalWrite(GreenLEDPin, HIGH);                                            //put  Green LED to On; activates the shutter of the Camera for 0,2 seconds
126        delay  (200);
127        digitalWrite(GreenLEDPin, LOW);                                             //put  Green LED to Off
128        Rx = String(0);
129        }    
130        delay(600);  
131        digitalWrite(FlashLEDPin, LOW);                                             //de-activates  the FlashLight connected to the server
132   }
133//////////////////////////////the  setup code that follows, will run once after "Power On" or after a RESET
134void  setup()  {
135  Serial.begin(115200);                                                             //Start  serial communication
136  Serial.println("Starting BLE Client application...");
137
138  pinMode(GreenLEDPin, OUTPUT);                                                     //  initialize digital pin GreenLEDPin as an output.
139  pinMode(YellowLEDPin, OUTPUT);                                                    // initialize digital pin YellowLEDPin  as an output.
140  pinMode(BlueLEDPin, OUTPUT);                                                      //  initialize digital pin BlueLEDPin as an output.
141  pinMode(FlashLEDPin, OUTPUT);                                                     // initialize digital pin FlashLEDPin  as an output.
142
143  digitalWrite(FlashLEDPin, LOW);                                                   //  at start turn the FlashLEDPin off (LOW means Flash Light OFF);
144  
145  BLEDevice::init("");                                                              //Init BLE device
146                                                                                    //  Retrieve a Scanner and set the callback we want to use to be informed when we
147                                                                                    //  have detected a new device.  Specify that we want active scanning and start the
148                                                                                    //  scan to run for 30 seconds.
149  BLEScan* pBLEScan = BLEDevice::getScan();
150  pBLEScan->setAdvertisedDeviceCallbacks(new  MyAdvertisedDeviceCallbacks());
151  pBLEScan->setActiveScan(true);
152  digitalWrite(BlueLEDPin,  HIGH);                                                   // at start of scan process:  turn the blue LED on;
153  pBLEScan->start(10);
154     if (connected == false)  {                                                      // blue LED will start flashing  if no scan succes after 9 seconds
155       for (int s = 1; s <10 ; s++) 
156        {
157        digitalWrite(BlueLEDPin, HIGH);                                             //  turn the blue LED on
158        delay(50);                                                                  //  wait 50 miliseconds
159        digitalWrite(BlueLEDPin, LOW);                                              //  turn the LED off by making the voltage LOW
160        delay(500);                                                                 //  wait 500 miliseconds
161        Serial.print
162          ("NOT connected to the  BLE Server. Device will reboot after: ");
163          Serial.print (10-s); Serial.println  ("seconds");                          // device will automatically reset to try  again scan for nearby BLE server again. 
164        }
165     } 
166  }
167  
168
169//////////////////////////////the  loop code that follows, will run repeatedly until "Power On" or a RESET
170void  loop() {
171                                                                                    //  If the flag "doConnect" is true then we have scanned for and found the desired
172                                                                                    //  BLE Server with which we wish to connect.  Now we connect to it.  Once we are
173                                                                                    //  connected we set the connected flag to be true.
174  if (doConnect == true)
175  {
176    if (connectToServer(*pServerAddress))
177      {
178        Serial.println("We  are now connected to the BLE Server.");
179        digitalWrite(BlueLEDPin, HIGH);                                             // turn the blue LED on 
180        connected  = true;
181      }
182    else
183      {
184        digitalWrite(BlueLEDPin, HIGH);                                             // turn the blue LED on
185        delay(50);                                                                  // wait 50 miliseconds
186        digitalWrite(BlueLEDPin, LOW);                                              //  turn the LED off by making the voltage LOW
187        delay(100);                                                                 //  wait 100 miliseconds
188        Serial.println("NOT connected to the BLE Server.");                         // Restart your device to scan for nearby BLE server again.
189        connected = false;
190      }
191        doConnect = false;  
192  }  
193  
194      CONTROLCharacteristic->getDescriptor(BLEUUID((uint16_t)0x2902))->writeValue((uint8_t*)notificationOn,  2, true);      //Activate the Notify property of each Characteristic    
195      delay(500);                                                                                                          //  Delay half a second between loops. 
196}
197

1/*********
2  This project has been developed and produced by Pierre  Pennings (September/October 2019),
3  It applies parts of the code (related to  BLE client/server) published by Rui Santos https://randomnerdtutorials.com/courses  : Learn ESP32 with Arduino IDE
4  His book has been a great help for me to realise  this project.
5
6  This Project is about making a (3D printed) Turntable rotate  in a selectable number of steps per 360 degrees using a Stepper Motor.
7  The  turntable's housing contains a ESP 32 (NodeMCU) that is programmed as a Bluetooth  Low Energy (BLE) server.
8  After every step of x degrees, the turntable stops  and sends a command over the Bluetooth
9  connection to another ESP32, that is  set up as e BLE Client.
10  The BLE Client is interfaced with a Sony HX400V Camera  through a special Multiconnector (looks like a micro USB C)
11  to activate the  focus and the camera shutter and then move another step of x degrees. At the same  time a LED spotlight can be activated.
12  
13  The ESP 32 device works at 3.3  Volt levels.
14  The ESP module is fed with 5 V derived from the Stepper Motor  driver L298N which is connected to a 12V 3A supply.
15  The 12V connection is used  to power the Stepper Motor.
16  The ESP 32 that has an on-board 3.3V voltage regulator,  which is used for powering the 128*64 OLED display.
17  Four different pushbuttons  are used to control the turntable.
18      * the RED button (ModeSelect) is used  for interaction with the OLED display for mode settings
19      * The righthand  GREEN button (ManualShot) is used for confirmation of the selected turning mode.
20      (and could also be programmed for taking manual pictures with the remote camera)
21      * The GREEN button (GoToOrigin) left of the OLED Display is used for commanding  the turntable to its ORIGIN Position (sensed with a switch underneath the turntable)
22      * The other GREEN button (StartPause) on the most left of the OLED Display  is used for starting or pausing an action and choosing another mode
23      (with  the current programme it causes a system reset and gets you back to the WELCOME  menu)
24      
25  This code is licensed under GPL3+ license.
26  
27*********/
28
29#include  <BLEDevice.h>                                                  // Include the BLE  Libraries
30#include <BLEServer.h>
31#include <BLEUtils.h>
32#include <BLE2902.h>
33
34#include  <AccelStepper.h>                                               // Include the Arduino  AccelStepper Library
35#define FULL4WIRE 4                                                     //  defines the type of StepperMotor used (NEMA 17)
36
37#include <Wire.h>                                                       //  Include the Libraries for the OLED display
38#include <Adafruit_SSD1306.h>
39#include  <Adafruit_GFX.h>
40
41#define SCREEN_WIDTH 128                                                //  OLED display width, in pixels
42#define SCREEN_HEIGHT 64                                                //  OLED display height, in pixels
43#define OLED_RESET -1
44
45Adafruit_SSD1306  display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
46
47#define bleServerName  "TurnTableESP32"                                  //BLE server name
48#define  SERVICE_UUID "e6c24700-6f9c-4bf4-b078-4fc82fad3e28"             //See for generating  UUIDs: https://www.uuidgenerator.net/
49
50BLECharacteristic CONTROLCharacteristics("1e0ed88a-1b69-4197-83fa-0373670c4819",  BLECharacteristic::PROPERTY_NOTIFY);
51BLEDescriptor CONTROLDescriptor(BLEUUID((uint16_t)0x2903));
52
53/////////////////////////////////initialise  the GPIO pins///////////////////////////////////////////////////////////////////////////////////////////////////////////////
54const  int BlueToothPin = 12;                                            // GPIO Pin 12  of ESP32 connected to BlueLED for showing the BlueToothStatus
55const int ModeSelectPin  = 13;                                           // GPIO Pin 13 of ESP32 to select  the Mode of operation of the Turntable (Red button)
56const int StartPausePin =  32;                                           // GPIO Pin 32 of ESP32 connected  to a Green Pushbutton for Starting/Pausing the Turntable
57const int GoToOriginPin  = 33;                                           // GPIO Pin 33 of ESP32 connected  to a Green Pushbutton for commanding the Turntable to origin position
58const int  ManualShotPin = 4;                                            // GPIO Pin 4 of ESP32  connected to Pushbutton for taking a manual shot
59const int OriginPin = 15;                                               //  GPIO Pin 15 of ESP32 connected to a switch on the turntable to sense that the Turntable  has reached the Origin position
60const int motorPin1 = 14 ;                                              //  IN1 on the L298 N driver (Blue)
61const int motorPin2 = 27 ;                                              //  IN2 on the L298 N driver (Pink)
62const int motorPin3 = 26 ;                                              //  IN3 on the L298 N driver (Yellow)
63const int motorPin4 = 25 ;                                              //  IN4 on the L298 N driver (Orange)
64// NOTE: GPIO Pin 21 of ESP32 is connected  to the SDA pin and GPIO Pin 22 of ESP32 is connected to the SCL pin of the OLED  display; no initialisation is needed for these pins
65
66const int stepsPerRevolution  = 200;                                     // Number of steps for one 360 degrees  rotation of the Stepper Motor
67
68//////////////////////////////////initialise  the Global variables///////////////////////////////////////////////////////////////////////////////////////////////////////
69int  ShootPinState = 1;                                                  // variable  for reading the Manual Shoot pushbutton status
70
71float stepperSpeed = 800;                                               //speed of the steppermotor (steps  per second)
72int Revcount = 0 ;                                                      //  Number of revolutions to made since Start
73int stepcount = 0 ;                                                     //  variable for counting the steps in the 360 degrees turn
74int turnmode = 0  ;                                                     //  variable for selecting the turning mode of the Turntable
75                                                                        //  1 => 5 steps of 72 degrees, 2 => 10 steps of 36 degrees, 3 => 15 steps of 24 degrees,  4 => 20 steps of 18 degrees,  5 = continous rotation
76
77volatile bool GoToOriginState  = false;
78volatile bool StartPauseState = false;
79
80void IRAM_ATTR GotoORIGIN()
81    {
82    GoToOriginState = true;
83    Serial.println("GoToOrigin pushed");
84    }
85
86void IRAM_ATTR STARTPAUSE()
87    {
88    StartPauseState = true;
89    Serial.println("StartPause button pushed");
90    }
91    
92bool deviceConnected  = false;
93bool BLE = false;
94char TakeAuto[11] = "AutoShot";
95char TakeManual[11]  = "ManualShot";
96
97
98///////////////////////////////// Create Instance of  Stepper library//////////////////////////////////////////////////////////////////////////////////////////////////////
99AccelStepper  stepper(FULL4WIRE, motorPin1, motorPin2, motorPin3, motorPin4);
100
101/////////////////////////////////set  up of the callbacks procedure for BLE////////////////////////////////////////////////////////////////////////////////////////////////
102class  MyServerCallbacks: public BLEServerCallbacks                      //Setup callbacks  onConnect and onDisconnect
103{
104  void onConnect(BLEServer* pServer) {
105    deviceConnected  = true;
106  };
107  void onDisconnect(BLEServer* pServer) {
108    deviceConnected  = false;
109  }
110};
111
112///////////////////////////////the setup code that  follows, will run once after "Power On" or after a RESET////////////////////////////////////////////////////////////////
113void  setup() {
114  Serial.begin(115200);                                                 //  Start serial communication with serial monitor of the Arduino IDE
115
116  pinMode  (motorPin1, OUTPUT);                                          // Set the motorPin1  as output
117  pinMode (motorPin2, OUTPUT);                                          //  Set the motorPin2 as output
118  pinMode (motorPin3, OUTPUT);                                          //  Set the motorPin3 as output
119  pinMode (motorPin4, OUTPUT);                                          //  Set the motorPin4 as output
120  pinMode (BlueToothPin, OUTPUT);                                       //  Set the BlueToothPin as output
121
122  pinMode (ManualShotPin, INPUT_PULLUP);                                //  Set the ManualShotPin as input and use the internal pullup resistor to set the Pin  to HIGH
123  pinMode (ModeSelectPin, INPUT_PULLUP);                                //  Set the ModeSelectPin as input and use the internal pullup resistor to set the Pin  to HIGH
124  pinMode (StartPausePin, INPUT_PULLUP);                                //  Set the StartPausePin as input and use the internal pullup resistor to set the Pin  to HIGH
125  pinMode (GoToOriginPin, INPUT_PULLUP);                                //  Set the GoToOriginPin as input and use the internal pullup resistor to set the Pin  to HIGH
126  pinMode (    OriginPin, INPUT_PULLUP);                                //  Set the     OriginPin as input and use the internal pullup resistor to set the Pin  to HIGH
127
128  attachInterrupt(digitalPinToInterrupt(GoToOriginPin), GotoORIGIN,  FALLING); 
129  Serial.print("goto origin pin  "); Serial.println(GoToOriginState);
130
131  attachInterrupt(digitalPinToInterrupt(StartPausePin), STRTPSE, FALLING); 
132  Serial.print("Start/pause pin  "); Serial.println(StartPauseState);
133  
134  Wire.begin();                                                         //OLED display  setup
135  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  
136  display.clearDisplay();
137  
138  stepper.setMaxSpeed(3000.0);                                          //  setting the maximum speed of the steppermotor
139  stepper.setSpeed(stepperSpeed);                                       // setting the running speed of the steppermotor  at the value of stepperSpeed
140  stepper.setAcceleration (200.0);                                      //  setting the Acceleration of the steppermotor 
141
142  /////////////////////herafter  functions are called for setting up the Turntable Server//////////////////////////////////////////////////////////////////////////  
143  WELCOME ();                                                           //displaying  a welcome message until the red button is pushed
144  TURNTABLEMODES ();                                                    //displaying  the possible turntable modes of operation 
145  delay (200);
146  HOWTOSET ();                                                          //displaying  an explanation how to select the turntable modes
147  SETMODE ();                                                           //setting  the turntable modes by pushing the red button and selecting with the green button
148  delay (2000);                                                         //display  selected mode for 2 seconds
149  ORIGIN ();                                                            //controlling  the turntable to an origin position
150 
151
152  /////////////////////routine for  setting up the Bluetooth connection with the Camera Client//////////////////////////////////////////////////////////////////////////
153  BLEDevice::init(bleServerName);                                       // Create  the BLE Device
154  BLEServer *pServer = BLEDevice::createServer();                       //  Create the BLE Server
155  pServer->setCallbacks(new MyServerCallbacks());
156  BLEService  *ControlService = pServer->createService(SERVICE_UUID);    // Create the BLE Service
157  
158  ControlService->addCharacteristic(&CONTROLCharacteristics);            //Create  BLE Characteristics
159  CONTROLDescriptor.setValue("Control");                                 //Create  a BLE Descriptor
160  CONTROLCharacteristics.addDescriptor(new BLE2902());                   //Descriptor  https://www.bluetooth.com/specifications/gatt/descriptors/  
161  
162  ControlService->start();                                               // Start the service
163  pServer->getAdvertising()->start();                                    // Start advertising
164  Serial.println("Trying  to make a BLE connection with the Camera client"); 
165  }
166
167////////////////////////////the  loop code that follows, will run repeatedly until "Power Off" or a RESET///////////////////////////////////////////////////////////////
168void  loop() {
169  
170  CONNECTION();
171    
172  switch (turnmode) {    
173      case  1:                                                           // Turnmode 1: 5 X  72 dgr)
174        STARTandTURN();
175        break;
176          
177      case  2:                                                           // Turnmode 2: 10 X  36 dgr)
178        STARTandTURN();
179        break;
180        
181      case 3:                                                           // Turnmode 3: 15 X 24  dgr)
182        STARTandTURN();
183        break;
184        
185      case 4:                                                           //  Turnmode 4: 20 X 18 dgr)
186        STARTandTURN();
187        break;
188        
189      case 5:                                                           // Turnmode  5: CONTINUOUS
190        STARTCONTINUOUS ();
191        break;    
192                  }  
193}
194//////////////////END of LOOP////////////////////////////////////
195
196/////////////////Hereafter  follows the Function for sending a Command message to the Client
197void SendCommand  (char message [10])
198    {
199    CONTROLCharacteristics.setValue(message);                           //Set  Characteristic value as an integer and notify connected client
200    CONTROLCharacteristics.notify();   
201    }
202
203/////////////////Hereafter follows the Function for displaying  a Welcome message at Start-up of the Turntable on the OLED Display////////////////////////////////////////
204void  WELCOME ()
205    {
206  display.startWrite();
207  display.setTextSize(2);
208  display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
209  display.setCursor(0,0);
210  display.println("WELCOME! ");
211  display.setTextSize(1);
212  display.println("Automatic TurnTable");
213  display.println("by Pierre Pennings");
214  display.println("to make 3D pictures");
215  display.println("");
216  display.setTextColor(BLACK,  WHITE);                                   // Draw 'inverse' text
217  display.println("to  PROCEED:");
218  display.println("    Push RED BUTTON");
219  display.display();
220
221  while (digitalRead (ModeSelectPin))
222    { 
223     digitalWrite(BlueToothPin,  HIGH);                                  // turn the blue LED on
224     delay(10);                                                         // wait 10 miliseconds
225     digitalWrite(BlueToothPin, LOW);                                   // turn  the LED off by making the voltage LOW
226     delay(500);                                                        //  wait 500 miliseconds
227    } 
228  delay(500);
229  Serial.println(" ModeSelectPin  = 01  ");
230  digitalWrite(BlueToothPin, LOW);                                      //  turn the blue LED off
231  display.clearDisplay();
232    }
233
234/////////////////Hereafter  follows the Function for displaying the possible Turntable Modes on the OLED Display/////////////////////////////////////////////////////////////
235void  TURNTABLEMODES ()
236    {
237  display.startWrite();
238  display.setTextSize(2);
239  display.setCursor(0,0);
240  display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
241  display.println("TURNTABLE");
242  display.setTextSize(1);
243  display.println("Mode  1 =  5 * 72 dgr");
244  display.println("Mode 2 = 10 * 36 dgr");
245  display.println("Mode  3 = 15 * 24 dgr");
246  display.println("Mode 4 = 20 * 18 dgr");
247  display.println("Mode  5 = Continuous");
248  display.setTextColor(BLACK, WHITE);                                   //  Draw 'inverse' text
249  display.println("PROCEED: RED BUTTON");
250  display.display();
251  
252  while (digitalRead (ModeSelectPin))
253    { 
254     digitalWrite(BlueToothPin,  HIGH);                                  // turn the blue LED on
255     delay(10);                                                         // wait 10 miliseconds
256     digitalWrite(BlueToothPin, LOW);                                   // turn  the LED off by making the voltage LOW
257     delay(500);                                                        //  wait 500 miliseconds
258    }
259   delay(500);
260   Serial.println(" ModeSelectPin  == 02  ");
261   digitalWrite(BlueToothPin, LOW);                                      //  turn the blue LED off
262   display.clearDisplay();
263    }
264
265/////////////////Hereafter  follows the Function for displaying an instruction about How to Set the possible  Turntable Modes ////////////////////////////////////////////////////
266void HOWTOSET  ()
267    {
268  display.startWrite();
269  display.setTextSize(2);
270  display.setCursor(0,0);
271  display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
272  display.println("HOW TO SET");
273  display.setTextSize(1);
274  display.println("to  change TurnMode:");
275  display.setTextColor(BLACK, WHITE);                                   //  Draw 'inverse' text
276  display.println("push RED BUTTON");
277  display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
278  display.println("");
279  display.println("if TurnMode is OK :");
280  display.setTextColor(BLACK,  WHITE);                                   // Draw 'inverse' text
281  display.println("push  GREEN BUTTON");
282  display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
283  display.println("-ManualShot Button-");
284  display.display();
285    }
286
287/////////////////Hereafter  follows the Function for setting/changing the Turn Mode and displaying the Selected  Turntable Mode on the OLED display //////////////////////////////////
288void SETMODE  ()
289    {
290CHANGEMODE:
291    turnmode = turnmode + 1;
292    display.clearDisplay();
293    display.startWrite();
294    display.setTextSize(2);
295    display.setCursor(0,0);
296    display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
297    display.print("MODE =");
298    display.setCursor(90,0);
299    display.println(turnmode);
300    display.setCursor(0,45);
301    display.setTextSize(1);
302    display.setTextColor(BLACK,  WHITE);                                   // Draw 'inverse' text
303    display.println("Red  Button to change");
304    display.setCursor(0,55);
305    display.println("GREEN  Button to stop");
306    display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
307    display.setTextSize(2);
308    display.setCursor(0,20);
309  while (digitalRead  (ModeSelectPin))
310      { 
311    digitalWrite(BlueToothPin, LOW);                                      //  turn the LED off by making the voltage LOW   
312    if (!digitalRead(ManualShotPin))        
313        {
314      Serial.println("GREEN BUTTON pushed");
315      turnmode  = turnmode-1 ;
316      goto STOPCHANGEMODE;
317        }
318      }
319    {
320    digitalWrite(BlueToothPin, HIGH);                                     // turn  the blue LED on
321  switch (turnmode) {
322        case 1:
323          display.println("5X  72 dgr");
324          display.display();
325          break;
326        case 2:     
327          display.println("10X 36 dgr");
328          display.display();
329          break;
330        case 3:
331          display.println("15X 24 dgr");
332          display.display();
333          break;
334        case 4:
335          display.println("20X  18 dgr");
336          display.display();
337          break;
338        case 5:
339          display.println("CONTINUOUS");
340          display.display();
341          break;    
342                  }  
343    delay(500);
344    Serial.println("RED BUTTON  pushed");
345    Serial.print(" turnmode "); Serial.println(turnmode);
346    if  (turnmode > 5)  {turnmode = 0;}
347    goto CHANGEMODE;
348    }
349
350    STOPCHANGEMODE:
351    //Serial.println("GREEN BUTTON pushed");
352    digitalWrite(BlueToothPin,  LOW);                                      // turn the blue LED off
353    display.clearDisplay();
354    display.startWrite();
355    display.setTextSize(2);
356    display.setCursor(5,0);
357    display.setTextColor(BLACK, WHITE);                                   // Draw  'inverse' text
358    display.println(" SELECTED ");
359    display.setCursor(5,20);
360    display.print(" MODE: ");
361    display.print(turnmode); display.println("  ");
362    display.setCursor(0,45);
363    display.setTextColor(WHITE);                                          //display.setBackgroundcolor(WHITE);
364    
365    switch (turnmode) {
366        case 1:
367          display.println("5X  72 dgr");
368          display.display();
369          break;
370        case 2:     
371          display.println("10X 36 dgr");
372          display.display();
373          break;
374        case 3:
375          display.println("15X 24 dgr");
376          display.display();
377          break;
378        case 4:
379          display.println("20X  18 dgr");
380          display.display();
381          break;
382        case 5:
383          display.println("CONTINUOUS");
384          display.display();
385          break;    
386                  }  
387    }
388
389/////////////////Hereafter follows  the Function for setting up the BLE connection to the Camera or proceeding without  connection  ////////////////////////////////////////
390void CONNECTION ()
391    {
392    while (deviceConnected == false)
393    { 
394     digitalWrite(BlueToothPin,  HIGH);                                  // turn the blue LED on
395     delay(50);                                                         // wait 50 miliseconds
396     digitalWrite(BlueToothPin, LOW);                                   // turn  the LED off by making the voltage LOW
397     delay(100);                                                        //  wait 100 miliseconds
398     Serial.println("trying to connect");
399     display.clearDisplay();
400     display.startWrite();
401     display.setTextSize(2);
402     display.setCursor(0,0);
403     display.setTextColor(WHITE);                                       //display.setBackgroundcolor(WHITE);
404     display.println("BLUETOOTH");
405     display.println("CONNECTING");
406     display.setTextSize(1);
407     display.println("to proceed without");
408     display.println("Bluetooth");
409     display.println();
410     display.setTextColor(BLACK,  WHITE);                                // Draw 'inverse' text
411     display.println("PUSH  RED BUTTON");
412     display.display();
413
414    while (digitalRead (ModeSelectPin)  == false)
415    { 
416      Serial.println(" proceed without BLE  ");
417      digitalWrite(BlueToothPin,  LOW);                                  // turn the blue LED off
418      display.clearDisplay();
419      display.startWrite();
420      display.setTextSize(2);
421      display.setCursor(0,0);
422      display.setTextColor(WHITE);                                      //display.setBackgroundcolor(WHITE);
423      display.println("PROCEEDING");
424      display.println("WITHOUT");
425      display.println("BLUETOOTH");
426      display.display();
427      BLE =  false;
428      delay (2000);
429      goto STARTTURNING;
430    } 
431  }
432  if  (deviceConnected){
433     digitalWrite(BlueToothPin, HIGH);                                  //  turn the blue LED on
434     display.clearDisplay();
435     display.startWrite();
436     display.setTextSize(2);
437     display.setCursor(0,0);
438     display.setTextColor(WHITE);                                       //display.setBackgroundcolor(WHITE);
439     display.println("BLUETOOTH");
440     display.println("CONNECTED!");
441     display.display();
442     BLE = true;
443     delay (2000);
444    }
445  STARTTURNING:;
446    }
447
448/////////////////Hereafter follows the Function for Starting the Turning  of the Turntable  ////////////////////////////////////////////////////////////////////////////////
449void  STARTandTURN ()
450    {
451    while (digitalRead (ModeSelectPin) == true)
452        { 
453          Serial.println("Push RED Button to start");
454          display.clearDisplay();
455          display.startWrite();
456          display.setTextSize(2);
457          display.setCursor(0,0);
458          display.setTextColor(WHITE);                               //display.setBackgroundcolor(WHITE);
459          display.println("TO START");
460          display.println("TURNING");
461          display.setCursor(0,45);
462          display.setTextColor(BLACK, WHITE);                        // Draw 'inverse' text
463          display.println("RED  BUTTON");
464          display.display();
465        }
466                     
467     for (Revcount = 1; Revcount <= (turnmode *5) ; Revcount++) {   
468          Serial.print("Revcount  "); Serial.println(Revcount);
469          display.clearDisplay();
470          display.startWrite();
471          display.setTextSize(2);
472          display.setCursor(0,0);
473          display.setTextColor(WHITE);                                //display.setBackgroundcolor(WHITE);
474          display.println("  STEP");
475          display.print("  ");
476          display.print(Revcount);
477          display.print(" / ");
478          display.println(turnmode *5);
479          display.display();
480          
481          stepper.setSpeed(stepperSpeed/turnmode);                    // set the stepperSpeed at xx steps per second, depending on  the turnmode
482          stepper.runToNewPosition (stepsPerRevolution/(turnmode*5)*Revcount);     //Moves the motor (with acceleration/deceleration) to the new target position  (blocks until it is at position).
483          
484          display.setCursor(0,42);
485          display.setTextSize(3);
486          if (BLE == 1){
487          display.println("  SHOOT!");                                 // display the fact that the TakeAuto  command is given via Bluetooth connection to camera
488          display.display();
489          delay (500);}
490          display.setCursor(0,30);
491          display.println("         ");                               // clear the SHOOT field on the display
492          display.display();
493          SendCommand (TakeAuto);
494          delay(2500);
495           
496          if (GoToOriginState == true)                                //  check if Go To Origin button has been pushed
497          {ORIGIN (); GoToOriginState  = false; Revcount = 0 ; }
498
499        }
500          stepper.stop();                                             //Sets  a new target position that causes the stepper to stop as quickly as possible, using  the current speed and acceleration parameters. 
501          stepper.setCurrentPosition(0);
502          stepper.disableOutputs();                                   //control  of the steppermotor is disabled to avoid unnecessary heating of the motor
503        
504         // if (StartPauseState == true)                               // check  if StartPause button has been pushed
505         // {/*STRTPSE ()*/ SETMODE ();  StartPauseState = false; }     // THIS DOES NOT WORK THE WAY IT IS MEANT; Pushing  the Start/Pause button causes a reset and you enter the welcome menu; which is fine  for the moment
506    }
507       
508
509 /////////////////Hereafter follows the  Function for Starting the CONTINUOUS Turning of the Turntable  /////////////////////////////////////////////////////////////////
510void  STARTCONTINUOUS ()
511    {
512          Serial.println("Continuous Rotation ");
513          display.clearDisplay();
514          display.startWrite();
515          display.setTextSize(2);
516          display.setCursor(0,0);
517          display.setTextColor(WHITE);                                  //display.setBackgroundcolor(WHITE);
518          display.println("CONTINUOUS");
519          display.println("ROTATION");
520          display.setTextColor(BLACK, WHITE);                           // Draw  'inverse' text
521          display.println("RED BUTTON");
522          display.println("TO  STOP");
523          display.display();
524      do
525       {
526        stepper.setSpeed(40);                                           // rotating at constant speed, until  stopped with red button
527        stepper.move(1);
528        stepper.run();
529       }
530      while (digitalRead (ModeSelectPin) == true );
531        stepper.stop();                                                 //Sets a new target position that  causes the stepper to stop as quickly as possible, using the current speed and acceleration  parameters. 
532        stepper.setCurrentPosition(0);
533        stepper.disableOutputs();                                       //control of the steppermotor is disabled  to avoid unnecessary heating of the motor
534          
535      if (GoToOriginState  == true)                                      // check if Go To Origin button has  been pushed
536         {ORIGIN (); GoToOriginState = false; }
537      //if (StartPauseState  == true)                                    // check if StartPause button has been  pushed
538      //   {STRTPSE (); StartPauseState = false; }                      //  THIS DOES NOT WORK THE WAY IT IS MEANT; Pushing the Start/Pause button causes a  reset and you enter the welcome menu; which is fine for the moment
539       }
540
541/////////////////Hereafter  follows the Function for driving the Turntable to the Origin position  /////////////////////////////////////////////////////////////////////
542  void ORIGIN ()
543    {
544        Serial.print("going to origin, GoToOriginPin  = "); Serial.println((digitalRead (GoToOriginPin)) );
545        display.clearDisplay();
546        display.startWrite();
547        display.setTextSize(2);
548        display.setCursor(0,0);
549        display.setTextColor(WHITE);                                    //display.setBackgroundcolor(WHITE);
550        display.println("GOING TO");
551        display.println("  ORIGIN");
552        display.display();           
553        do
554           {
555           stepper.setSpeed(40);
556           stepper.move(1);                                             // rotating  the Turntable until the OriginPin goes LOW
557           stepper.run();
558           }
559        while ((digitalRead (OriginPin)) == HIGH );
560        stepper.stop();                                                 //Sets  a new target position that causes the stepper to stop as quickly as possible, using  the current speed and acceleration parameters. 
561        stepper.setCurrentPosition(0);
562        delay (100);
563        stepper.disableOutputs();                                       //control  of the steppermotor is disabled to avoid unnecessary heating of the motor
564        
565        Serial.println("Origin Reached ");
566        display.clearDisplay();
567        display.startWrite();
568        display.setTextSize(2);
569        display.setCursor(0,20);
570        display.setTextColor(WHITE);                                    //display.setBackgroundcolor(WHITE);
571        display.println("ARRIVED");
572        display.println("AT ORIGIN");
573        display.display();
574        delay (1000);
575
576        while (digitalRead  (ModeSelectPin) == true)
577        {
578        Serial.println("Push RED Button  to proceed");
579        display.clearDisplay();
580        display.startWrite();
581        display.setTextSize(2);
582        display.setCursor(0,0);
583        display.setTextColor(WHITE);                               //display.setBackgroundcolor(WHITE);
584        display.println("TO  START");
585        display.println("TURNING");
586        display.setCursor(0,45);
587        display.setTextColor(BLACK, WHITE);                        // Draw 'inverse'  text
588        display.println("RED BUTTON");
589        display.display();
590        }
591    }
592
593/////////////////Hereafter follows the Function for pauzing/restarting  Turntable selecting a new mode and to put it back in the Origin position  /////////////////////////
594/////////////////THIS  DOES NOT WORK THE WAY IT IS MEANT; Pushing the Start/Pause button causes a reset  and you enter the welcome menu; which is fine for the moment
595 void STRTPSE ()  
596    { 
597        Serial.print("Start/pause Pin = "); Serial.println((digitalRead  (StartPausePin)) );
598        //display.clearDisplay();
599        //display.startWrite();
600        //display.setTextSize(2);
601        //display.setCursor(0,0);
602        //display.setTextColor(WHITE);                                    //display.setBackgroundcolor(WHITE);
603        //display.println("START  ");
604        //display.println(" / PAUSE");
605        //display.display();
606        //delay (500);         
607     //ORIGIN ();
608     SETMODE ();
609     delay  (1000);
610    }
611