Credit for the author

Dependents:   Stepper_4

Fork of sMotor by Nuno Sarmento

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers sMotor.cpp Source File

sMotor.cpp

00001 /*
00002 ############################################
00003 ##           sMotor v0.1 Library          ##
00004 ##          created by Samuel Matildes    ##
00005 ############################################
00006         ---- sam.naeec@gmail.com -----
00007 This library was made for 4-Phase Stepper Motors
00008 I don't take any resposability for the damage caused to your equipment.
00009 
00010 */
00011 
00012 #include "sMotor.h"
00013 
00014 #include "mbed.h"
00015 
00016 int motorSpeed; // Steper speed
00017 
00018 sMotor::sMotor(PinName A0, PinName A1, PinName A2, PinName A3) : _A0(A0), _A1(A1), _A2(A2), _A3(A3) { // Defenition of motor pins
00019     _A0=0;
00020     _A1=0;
00021     _A2=0;
00022     _A3=0;
00023 }
00024 
00025 
00026 void sMotor::anticlockwise(int current_step) { // rotate the motor 1 step anticlockwise 
00027     
00028     //for (int i = 0; i < 8; i++) {
00029 
00030         switch (current_step) { // activate the ports A0, A2, A3, A3 in a binary sequence for steps
00031             case 0: {
00032                 _A0=0;
00033                 _A1=0;
00034                 _A2=0;
00035                 _A3=1;
00036             }
00037             //break;
00038             case 1: {
00039                 _A0=0;
00040                 _A1=0;
00041                 _A2=1;
00042                 _A3=1;
00043             }
00044             //break;
00045             case 2: {
00046                 _A0=0;
00047                 _A1=0;
00048                 _A2=1;
00049                 _A3=0;
00050             }
00051             //break;
00052             case 3: {
00053                 _A0=0;
00054                 _A1=1;
00055                 _A2=1;
00056                 _A3=0;
00057             }
00058             //break;
00059             case 4: {
00060                 _A0=0;
00061                 _A1=1;
00062                 _A2=0;
00063                 _A3=0;
00064             }
00065             //break;
00066             case 5: {
00067                 _A0=1;
00068                 _A1=1;
00069                 _A2=0;
00070                 _A3=0;
00071             }
00072             //break;
00073             case 6: {
00074                 _A0=1;
00075                 _A1=0;
00076                 _A2=0;
00077                 _A3=0;
00078             }
00079             //break;
00080             case 7: {
00081                 _A0=1;
00082                 _A1=0;
00083                 _A2=0;
00084                 _A3=1;
00085             }
00086           //  break;
00087         //}
00088 
00089 
00090         wait_us(motorSpeed); // wait time defines the speed 
00091     }
00092 }
00093 
00094 void sMotor::clockwise(int current_step) { // rotate the motor 1 step clockwise 
00095     //for (int i = 7; i >= 0; i--) {
00096 
00097         switch (current_step) {
00098             case 0: {
00099                 _A0=0;
00100                 _A1=0;
00101                 _A2=0;
00102                 _A3=1;
00103             }
00104             break;
00105             case 1: {
00106                 _A0=0;
00107                 _A1=0;
00108                 _A2=1;
00109                 _A3=1;
00110             }
00111             break;
00112             case 2: {
00113                 _A0=0;
00114                 _A1=0;
00115                 _A2=1;
00116                 _A3=0;
00117             }
00118             break;
00119             case 3: {
00120                 _A0=0;
00121                 _A1=1;
00122                 _A2=1;
00123                 _A3=0;
00124             }
00125             break;
00126             case 4: {
00127                 _A0=0;
00128                 _A1=1;
00129                 _A2=0;
00130                 _A3=0;
00131             }
00132             break;
00133             case 5: {
00134                 _A0=1;
00135                 _A1=1;
00136                 _A2=0;
00137                 _A3=0;
00138             }
00139             break;
00140             case 6: {
00141                 _A0=1;
00142                 _A1=0;
00143                 _A2=0;
00144                 _A3=0;
00145             }
00146             break;
00147             case 7: {
00148                 _A0=1;
00149                 _A1=0;
00150                 _A2=0;
00151                 _A3=1;
00152             }
00153             break;
00154         }
00155 
00156 
00157         wait_us(motorSpeed); // wait time defines the speed 
00158     }
00159 //}
00160 void sMotor::step(int num_steps, int direction, int speed) {// steper function: number of steps, direction (0- right, 1- left), speed (default 1200)
00161     int count=0; // initalize step count
00162     motorSpeed=speed; //set motor speed
00163     if (direction==0) // turn clockwise
00164         do {
00165             clockwise();
00166             count++;
00167         } while (count<num_steps); // turn number of steps applied 
00168     else if (direction==1)// turn anticlockwise
00169         do {
00170             anticlockwise();
00171             count++;
00172         } while (count<num_steps);// turn number of steps applied 
00173 
00174 }
00175 
00176 
00177 void sMotor::anticlockwise(int current_step) { // rotate the motor 1 step anticlockwise 
00178     
00179     //for (int i = 0; i < 8; i++) {
00180 
00181         switch (current_step) { // activate the ports A0, A2, A3, A3 in a binary sequence for steps
00182             case 0: {
00183                 _A0=0;
00184                 _A1=0;
00185                 _A2=0;
00186                 _A3=1;
00187             }
00188             //break;
00189             case 1: {
00190                 _A0=0;
00191                 _A1=0;
00192                 _A2=1;
00193                 _A3=1;
00194             }
00195             //break;
00196             case 2: {
00197                 _A0=0;
00198                 _A1=0;
00199                 _A2=1;
00200                 _A3=0;
00201             }
00202             //break;
00203             case 3: {
00204                 _A0=0;
00205                 _A1=1;
00206                 _A2=1;
00207                 _A3=0;
00208             }
00209             //break;
00210             case 4: {
00211                 _A0=0;
00212                 _A1=1;
00213                 _A2=0;
00214                 _A3=0;
00215             }
00216             //break;
00217             case 5: {
00218                 _A0=1;
00219                 _A1=1;
00220                 _A2=0;
00221                 _A3=0;
00222             }
00223             //break;
00224             case 6: {
00225                 _A0=1;
00226                 _A1=0;
00227                 _A2=0;
00228                 _A3=0;
00229             }
00230             //break;
00231             case 7: {
00232                 _A0=1;
00233                 _A1=0;
00234                 _A2=0;
00235                 _A3=1;
00236             }
00237           //  break;
00238         //}
00239 
00240 
00241         wait_us(motorSpeed); // wait time defines the speed 
00242     }
00243 }
00244 
00245 void sMotor::stop(int current_step) { // rotate the motor 1 step clockwise 
00246     //for (int i = 7; i >= 0; i--) {
00247 
00248         switch (current_step) {
00249             case 1: {
00250                 _A0=0;
00251                 _A1=0;
00252                 _A2=0;
00253                 _A3=1;
00254             }
00255             break;
00256             case 2: {
00257                 _A0=0;
00258                 _A1=0;
00259                 _A2=1;
00260                 _A3=1;
00261             }
00262             break;
00263             case 3: {
00264                 _A0=0;
00265                 _A1=0;
00266                 _A2=1;
00267                 _A3=0;
00268             }
00269             break;
00270             case 4: {
00271                 _A0=0;
00272                 _A1=1;
00273                 _A2=1;
00274                 _A3=0;
00275             }
00276             break;
00277             case 5: {
00278                 _A0=0;
00279                 _A1=1;
00280                 _A2=0;
00281                 _A3=0;
00282             }
00283             break;
00284             case 6: {
00285                 _A0=1;
00286                 _A1=1;
00287                 _A2=0;
00288                 _A3=0;
00289             }
00290             break;
00291             case 7: {
00292                 _A0=1;
00293                 _A1=0;
00294                 _A2=0;
00295                 _A3=0;
00296             }
00297             break;
00298             case 0: {
00299                 _A0=1;
00300                 _A1=0;
00301                 _A2=0;
00302                 _A3=1;
00303             }
00304             break;
00305         }
00306 
00307 
00308         wait_us(motorSpeed); // wait time defines the speed 
00309     }
00310     
00311 void sMotor::delay(int delay_time){
00312     wait_us(delay_time);   
00313 }