Arduino gecontroleerd Servo uitoefenaar (2 / 2 stap)

Stap 2:


Hier is het volledige programma - vrij voor u om te gebruiken als u nodig hebt...
Deze code is uitgebreid getest en ik ben niet bewust van eventuele bugs!

/*************************************************************/
/ *** S W E E P U S E C S--Servo Drive programma V.110308 *** /
/ *** Mark Theobald-- www.DisabledAdventurers.com *** /
/*************************************************************/
#include < Servo.h >
#include < EEPROM.h >

Servo Servo1;                   Een Servo-Object maken
int CPOS = 1500;        Huidige positie (in usec)
int SPEED = 2500;        Servo snelheid (1-100 * 300)
int vertraging = 1000;        Vertraging tussen veegt (0-5000 msec.)
int INCR = 1;              Servo Increment (1-50 usec)
int CSTOP = 1;              Halte centrum (ja of Nee)
int AMIN = 675;          Absolute Min (Minimum = 675)
int AMAX = 2325;        Absolute Max (maximale 2325 =)
int MIN, MAX;                    Huidige MIN en MAX waarden
int SPCP;                         Sweep Passes middenpositie
int Ct, LoopCount;          Enkele globale variabelen
char String [80];               Een tekenreeksbuffer
int getal;                     Een aantal variabele

int ABYTE, EPAD;           voor lezen & schrijven EEPROM

VOID StoreDefaults (void);
VOID RetrieveDefaults (void);
VOID CheckSerial (void);
VOID SweepTo (int positie);
VOID ManualRotation (void);
VOID ManualEntry (void);
VOID GetANumber (void);

/*************************************************************/
VOID Setup {}

Servo1.attach (9, AMIN, AMAX);            De SERVO koppelen aan Pin 9
Servo1.writeMicroseconds (1500);     Positie Servo naar Midden
Serial.begin (115200);                          Dit in HyperTerminal overeenkomen!
Serial.Print ("\n\r");                                  Toon het Menu van de Operator

Serial.print( "-------------------------------------------- \n\r" );
Serial.Print ("S W E E P U S E C S--Servo Drive Program \n\r");
Serial.print( "-------------------------------------------- \n\r" );
Serial.Print ("s/S = snelheid, i/I = verhuizing Increment, d/D = vertraging \n\r");
Serial.Print ("n/N = Min, m/M = Max, < spatie > = pauze,? = Display \n\r");
Serial.Print ("C = Center Stop, L/R = handmatige modus, X = Reset \n\r");
Serial.Print ("Z = winkel Defaults, P = positie handmatig invoeren \n\r");
Serial.print( "-------------------------------------------- " );

MIN = AMIN;                    MIN en MAX-waarden naar ABSOLUTE MIN en MAX waarden initialiseren
MAX = AMAX;
RetrieveDefaults();        Lees alle waarden die zijn opgeslagen in EEPROM
terwijl (!. Serial.available());                Wachten op een willekeurige toets om te beginnen
Serial.Read();   }

/*************************************************************/
void loop {}

sprintf (String, "\n\r%06d:", ++ LoopCount);    Bijhouden van Loops
Serial.Print (String);
SweepTo (MAX);
Serial.Print ("CW");                  Laatste deel geven
CheckSerial();
vertraging (DELAY);

Als (CSTOP & & SPCP) {//We wilt stoppen bij center & &
SweepTo (1500);                     Vegen passeert middenpositie
Serial.Print ("Midden");
CheckSerial();
vertraging (DELAY);    }

SweepTo (MIN);
Serial.Print ("Linksom");
CheckSerial();
vertraging (DELAY);

Als (CSTOP & & SPCP) {}
SweepTo (1500);
Serial.Print ("Midden");
CheckSerial();
vertraging (DELAY);    }    }

/*************************************************************/
VOID RetrieveDefaults() {}
EPAD = 0;

ABYTE = int (EEPROM.read (EPAD ++));
MIN = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD ++));
MIN = MIN | ABYTE;
Serial.Print ("\n\rMIN:");
Serial.Print (MIN, DEC);
Als (MIN < AMIN ||  MIN > = MAX) MIN = AMIN;

ABYTE = int (EEPROM.read (EPAD ++));
MAX = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD ++));
MAX = MAX | ABYTE;
Serial.Print ("MAX:");
Serial.Print (MAX, DEC);
Als (MAX < = MIN || MAX > AMAX) MAX = AMAX;

SPCP = MIN < 1500 & & MAX > 1500;     Sweep Passes middenpositie

ABYTE = int (EEPROM.read (EPAD ++));
SNELHEID = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD ++));
SNELHEID = SNELHEID | ABYTE;
Serial.Print ("snelheid:");
Serial.Print (snelheid / 100, DEC);
Als (< 100 snelheid ||  SNELHEID > 30000) snelheid = 2500;

ABYTE = int (EEPROM.read (EPAD ++));
VERTRAGING = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD ++));
VERTRAGING = VERTRAGING | ABYTE;
Serial.Print ("vertraging:");
Serial.Print (vertraging / 50, DEC);
Als (vertraging < 0 ||  > 5000 VERTRAGEN) vertraging = 1000;

ABYTE = int (EEPROM.read (EPAD ++));
INCR = ABYTE << 8;
ABYTE = int (EEPROM.read (EPAD));
INCR = INCR | ABYTE;
Serial.Print ("INCR:");
Serial.Print (INCR, DEC);
Als (INCR < 1 ||  INCR > 50) INCR = 50;    }

/*************************************************************/
VOID StoreDefaults() {}
EPAD = 0;

EEPROM.write (EPAD ++, char ((MIN >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (MIN & 0x00FF));

EEPROM.write (EPAD ++, char ((MAX >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (MAX & 0x00FF));

EEPROM.write (EPAD ++, char ((snelheid >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (snelheid & 0x00FF));

EEPROM.write (EPAD ++, char ((vertraging >> 8) & 0x00FF));
EEPROM.write (EPAD ++, char (vertraging & 0x00FF));

EEPROM.write (EPAD ++, char ((INCR >> 8) & 0x00FF));
EEPROM.write (EPAD, char (INCR & 0x00FF));    }

/*************************************************************/
VOID CheckSerial() {}
char sleutel;

terwijl (Serial.available()) {}
Als ((sleutel = Serial.read()) == de ' ||  Sleutel == de ' ||  Belangrijkste == '?')    {
Als (sleutel == van ' & & snelheid > 300) snelheid-= 300;
Als (sleutel == de ' & & snelheid < 30000) snelheid += 300;
Als (sleutel == '?')  Serial.Print ("\n\r");
sprintf (String, "snelheid: % d", snelheid / 300);     0 - 100
Serial.Print (String);    }

Als (sleutel 'i' == ||  Sleutel 'I' == ||  Belangrijkste == '?')    {
Als (sleutel == "i" & & INCR > 1) INCR--;
Als (sleutel == "I" & & INCR < 50) INCR ++;
sprintf (String, Incr:%'d ' vanaf, INCR);            0 - 50
Serial.Print (String);    }

Als (sleutel == had' ||  Sleutel == had' ||  Belangrijkste == '?')    {
Als (sleutel == had' & & vertraging > 49) vertraging-= 50;
Als (sleutel == had' & & vertraging < 5000) vertraging += 50;
sprintf (String, "vertraging: % d", vertraging / 50);     0 - 100
Serial.Print (String);    }

Als (sleutel == 'n' ||  Sleutel == 'N' ||  Belangrijkste == '?')    {
Als (sleutel == 'n') als ((MIN-= 20) < AMIN) MIN = AMIN;
Als (sleutel == 'N') als ((MIN += 20) > MAX - 1) MIN = MAX - 1;
sprintf (String, Min:%'d ' vanaf, MIN);
Serial.Print (String);
SPCP = MIN < 1500 & & MAX > 1500;    } //Sweep passes middenpositie

Als (sleutel == ben ' ||  Sleutel == ben ' || Belangrijkste == '?')    {
Als (sleutel == ben ') als ((MAX-= 20) < MIN + 1) MAX = MIN + 1;
Als (sleutel == ben ') als ((MAX += 20) > AMAX) MAX = AMAX;
sprintf (String, "Max: % d", MAX);
Serial.Print (String);
SPCP = MIN < 1500 & & MAX > 1500;    }

Als (toets 'c' == ||  Belangrijkste == 'C') {}
CSTOP =! CSTOP;
sprintf (String, "\n\rStop @ het centrum = %s \n\r", CSTOP? "Ja": "No");
Serial.Print (String);    }

Als (sleutel == ' ') {}
Serial.Print ("Pause");
terwijl (!. Serial.available());      Onderbroken - wachten op een willekeurige toets
Serial.Read();
Serial.Print ("Run");    }

Als (sleutel == 'x' ||  Belangrijkste == 'X') {//Reset alle variabelen
SNELHEID = 7500;
VERTRAGING = 1000;
INCR = CSTOP = SPCP = 1;
MIN = AMIN;
MAX = AMAX;    }

Als (toets 'r' == ||  Toets 'R' == ||  Toets 'l' == ||  Belangrijkste == 'L')
ManualRotation();

Als (sleutel == 'z' ||  Belangrijkste == 'Z') StoreDefaults();

Als (sleutel == 'p' ||  Belangrijkste == 'P') {}
terwijl Serial.read() (Serial.available());       Buffer leeg
ManualEntry();    }    }    }

/*************************************************************/
VOID ManualEntry() {}
Serial.Print ("\n\n\rMANUAL modus");
sprintf (String, "---MIN:% d, MAX: % d", MIN, MAX);
Serial.Print (String);
Serial.Print ("\n\rNumeric positie < invoeren >, < spatie > = Exit \n\r");

terwijl (1) {}
GetANumber();
Als (aantal < 0) keren;
sprintf (String, ": %d", nummer);
Serial.Print (String);

Als (nummer > = MIN & & nummer < = MAX) {}
Onderverdeling = nummer;
Servo1.writeMicroseconds (onderverdeling);
Serial.Print ("\n\r");    }

else {}
Serial.Print Is ("niet In bereik \n\r");
sprintf (String, "%d - %d < Enter > of < spatie > naar Exit...\n\r", MIN, MAX);
Serial.Print (String);    }    }    }

/*************************************************************/
VOID GetANumber() {}
Sleutel char = 0;

Aantal = 0;
terwijl (sleutel! = "") {}
Als (Serial.available()) {}
Als ((sleutel = Serial.read()) 13 ==) terugkeer;     CR
Als (Key > 47 & & Key < 58) {//ASCII '0' t h bent u '9'
Als (Number) nummer * = 10;                    Geen Leading nullen!
Nummer += (Key - 48);    }    }    }

Aantal = -1;
terugkeer;    }

/*************************************************************/
VOID ManualRotation() {}
char sleutel;

Serial.Print ("\n\n\rMANUAL rotatie modus");
Serial.Print ("\n\rl/L=Left, r/R = rechts, < spatie > = Exit \n\r");

terwijl (1) {}
Als (Serial.available()) {}
Als ((sleutel = Serial.peek()) == 'p' ||  Belangrijke 'P' ==) terugkeer;

Als ((sleutel = Serial.read()) == ' ') {}
Serial.Print ("\n\r");
terugkeer;    }

Als (toets 'r' == ||  Toets 'R' == ||  Toets 'l' == ||  Belangrijkste == 'L') {}
Als (toets 'r' == & & CPOS < AMAX) CPOS ++;

Als (toets 'R' ==) {}
Als (CPOS < AMAX - 9) CPOS += 10;
anders CPOS = AMAX;    }

Als (toets 'l' == & & CPOS > AMIN) CPOS--;

Als (sleutel == 'L') {}
Als (CPOS > AMIN + 9) CPOS-= 10;
anders CPOS = AMIN;    }

Servo1.writeMicroseconds (onderverdeling);
sprintf (String, ": %d", CPOS);
Serial.Print (String);    }    }    }    }

/*************************************************************/
VOID SweepTo (int positie) {}

Als (CPOS < positie) terwijl ((CPOS += INCR) < = positie) {}
Servo1.writeMicroseconds (onderverdeling);
voor (Ct = snelheid; CT < 30000; CT++);    }

anders terwijl ((CPOS-= INCR) > = positie) {}
Servo1.writeMicroseconds (onderverdeling);
voor (Ct = snelheid; CT < 30000; CT++);    }

Als (CPOS! = positie) Servo1.writeMicroseconds (CPOS = positie);    }

/*************************************************************/
/ *** EINDE PROGRAMMA *** /
/*************************************************************/

Gerelateerde Artikelen

Arduino gecontroleerd Servo Robot (SERVISCH)

Arduino gecontroleerd Servo Robot (SERVISCH)

wat een betere manier om te experimenteren met opensource micro-controllers ( Arduino ) dan door het bouwen van uw eigen bron robot open ( CC (SA-door))?Wat te doen met uw Servische?(hier) - hoe uw Servische verbinden met het internet en het rijden o
Galvo - Laser Arduino gecontroleerd

Galvo - Laser Arduino gecontroleerd

Arduino gecontroleerd galvo laser. De servo aangedreven spiegels sturen de verlaten een fosforescerende parcours op het blad van de glow-in-the-dark vinyl UV-laser.Oorspronkelijk Gepost op notes.robives.comStap 1:Beginnen met een blad van lichtgevend
Arduino-gecontroleerde Wolf staart

Arduino-gecontroleerde Wolf staart

groeten, of moet ik zeggen, "Aaaaaooooooooooooh!" Maken van uw bekende collega wolf liefhebber graag. Je hebt een innerlijke wolf geest dat zo graag bekend maken dat u mij om te leren hoe om uw zeer eigen animatronic wolf staart, zodat u kunt ec
Huisdier Curfew: Een Arduino gecontroleerde huisdier deur

Huisdier Curfew: Een Arduino gecontroleerde huisdier deur

Het probleem: U wilt beperken van de tijd wanneer uw huisdier mee mag naar buiten te gaan. Dit kan zijn omdat de buurt niet veilig voor uw kat of kleine hond in de nacht is (plunderende coyotes voor de geest komt). Maar u wilt uw huisdier te kunnen t
Arduino gecontroleerd animatronic houten hoofd (leeslamp)

Arduino gecontroleerd animatronic houten hoofd (leeslamp)

deze kop is een leeslamp die kan worden aangepast aan de richting van de verlichting, en grijs als vereist.Dit Instructable combineert Arduino, programmering, sommige eenvoudig elektronica, snijwerk met hand en power tools, mechanische controle en ee
Arduino-gecontroleerde Smart Home

Arduino-gecontroleerde Smart Home

Dit Instructable werd geschreven door PubNub Evangelist Ian Jennings . Ian's verhaal doorloopt zijn proces van het opbouwen van een Arduino-gecontroleerde smart home model van kras.--Terug in September, onze stichter Stephen en ik spraken over manier
Arduino HVAC Servo thermostaat/Controller

Arduino HVAC Servo thermostaat/Controller

Welkom bij mijn 'groene' instructable! Ik ga u tonen hoe te gebruiken een Arduino, twee servo motoren een temperatuursensor en sommige metalen (of hout) zodat een digitale thermostaat voor een via-muur HVAC eenheid.Volgens de CB Richard Ellis (een gr
Arduino gecontroleerd vuurtoren

Arduino gecontroleerd vuurtoren

Overzicht:Ik heb vaak gedacht dat een vuurtoren zou een groot project voor een Arduino, en dus heb ik besloten om het eens te proberen met behulp van een van de lokale vuurtorens hier in Erie, Pennsylvania als inspiratie. Ik koos voor de North Pierhe
Arduino gecontroleerd CNC / 3D Printer hybride

Arduino gecontroleerd CNC / 3D Printer hybride

Moeder natuur maakt... Wij bouwen.BuildersBot zekeringen 3D printen & CNC frezen in één Builder's droom "3dprintingindustry.com"De BuilderBot is een Open ontwerp machine, die gebruik maakt van OpenSoftware en Open Hardware. Het is een produc
Arduino gecontroleerd kookwekker

Arduino gecontroleerd kookwekker

U allen moet heb meegemaakt dat je iets wordt gekookt op uw gasfornuis terwijl aan de andere kant u get drukke TV kijken of krijgen een diepe gesprek hebt dat je je realiseert op het opsporen van een geur die het was volledig verwend alleen vanwege u
Arduino-gecontroleerde gordijn

Arduino-gecontroleerde gordijn

In dit nieuwe project, we gecombineerd van elektronica en mechanica, en maakte een Arduino-gecontroleerde gordijn roller.Veel plezier met maken!Stap 1: Planning van het CircuitVoor dit circuit u hebt nodig:1. de roterende Potentiometer2. de Arduino U
Draadloos Arduino gecontroleerde Tank (nRF24L01)

Draadloos Arduino gecontroleerde Tank (nRF24L01)

Hallo!Vandaag zal ik u tonen how to build een Arduino gecontroleerde tank en een afstandsbediening. De 3d afgedrukt delen van de tank (met uitzondering van de controller, bijhouden gids en tank cover) werden ontworpen door timmiclark en kan worden ge
Arduino gecontroleerd licht dimmer

Arduino gecontroleerd licht dimmer

Waarschuwing: Sommige mensen proberen om dit met een optocoupler met zerocrossing coz rechts "dat is beter"? Sommigen horen zelfs in elektronicawinkels, het is beter om te gebruiken dergelijke een optocoupler. VERKEERDE. Dit werkt alleen met een
IoT Motion gecontroleerd servo's

IoT Motion gecontroleerd servo's

Veilige en betrouwbare real-time gegevens streaming is essentieel voor IoT. Ik heb gezien tal van demonstraties waarbij toepassingen of "drukknop hier, bracht op daar" type hardware, maar een vriend en ik wilde iets dat meer interactief was... e