-         

Ergebnis 1 bis 1 von 1

Thema: Motor Library wechseln

  1. #1

    Motor Library wechseln

    Anzeige

    SMARTPHONES & TABLETS-bis zu 77% RABATT-Kostenlose Lieferung-Aktuell | Cool | Unentbehrlich
    Hallo,

    Ich habe folgendes Problem. Ich baue gerade für mein Teleskop ein Filterrad.
    Mit diesem Filterrad ist es möglich mit der s/w CCD Kamera Farbaufnahmen zu machen.
    In diesem Rad sind dazu 5 Filter angebracht. Zu jedem Filter ist ein Magnet zur Positionsermittlung vorhanden. Vier Filter mit Nördlicher Ausrichtung ,und zum Indexieren des Nullpunktes bzw. dem ersten Filter mit Südlicher Ausrichtung. Erfaßt werden sie über einen Hall Sensor. Zur Hardware habe ich einen Arduino Uno und einen baugleichen Adafruit Stepper/Servo Shield.
    Gesteuert wird das ganze dann über ein Plugin für das Aufnahmeprogramm.
    Ich habe schon die komplette Firmware für das Arduino und auch das Plugin, leider arbeitet die Firmware mit der Stepper Library. Und so wie es aussieht kann ich mit dem Motorshield nur die AFMotor Library nutzen. Leider bin ich beim Programmieren noch ein blutiger Anfänger, aber wenn ich jetzt anfange ein eigenes Programm samt Plugin zu schreiben vergehen wohl Jahre. Bin seit mittlerweile 2 Wochen durchgängig schon am Lernen, aber irgendwie stellen sich mir mehr fragen als ich Antworten bekomme.
    Klar möchte ich nebenbei ein wenig Programmieren lernen, aber Ich würde gerne dieses Filterrad auch noch recht schnell fertigbekommen. Bin eigentlich mehr der Basteler als Programmierer Big Grin
    Ich hoffe mir kann da jemand helfen.
    Dabei noch ein Foto vom aktuellen Baustatus sowie der Originalcode

    Viele Grüße

    Micha


    /*
    * Filterwheel
    * Provides for control of a five position filter wheel.
    *
    * Copyright (C) 2014 Howard Dutton
    *
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
    *
    * This program is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    * GNU General Public License for more details.
    *
    * You should have received a copy of the GNU General Public License
    * along with this program. If not, see <http://www.gnu.org/licenses/>.
    *
    *
    *
    * Revision History
    *
    * Date Version Comment
    * 03-16-2014 1.0 Adaptation of Camera/Filterwheel driver to filterwheel only
    * 05-26-2014 1.1 Added code at adjust the stepping granularity
    *
    * Author: Howard Dutton
    * http://www.stellarjourney.com
    *
    *
    */

    #include "stdio.h";
    #include "EEPROM.h";
    #include <Stepper.h>

    #define fullRotation 280 // enough slots to hold reading a bit more than once around the wheel (for finding index/calibration), keep under about 1000
    #define stepGranularity 8 // number of half-steps per slot

    boolean debug = false;
    boolean override = false;

    Stepper myStepper(96,2,3,4,5,true); // Note: the Stepper library in the Arduino enviroment needs to be replaced with a half-stepping version
    // this can be found at http://code.google.com/p/arduino/issues/detail?id=139 and might need to be modified
    // by replacing the line #include "WProgram.h" with #include "Arduino.h"

    int hallAnalogPin =1; // analog in A1

    int filter_position =0; // filter position control
    int filters_to_pass =0; // number of filters to pass to arrive at the destination
    int filter_destination =0; //
    int filter_offset =0; // moves +/- once we find the correct filter to center it
    int filter_hysteresis =0; // ignore this many readings when the filter wheel begins to rotate (prevents false counts)

    boolean standardFilter =false; // keep track of filter wheel state
    boolean indexFilter =false;
    int Moving =0;
    int calibrateFilters =0;
    boolean zeroFilters =false;

    int G =512; // for processing magnetic gauss readings
    int G1 =512; // for determination of filter positions
    int neutralG =100;
    int southG =75;
    int northG =125;
    int thresholdGS;
    int thresholdGN;
    byte GA[fullRotation]; // holds a series of gauss readings for calibration of the filter wheel

    char inChar;
    char buffer[80]; // storage for command
    int bufferPtr =0; // current location in buffer
    char buffer2[3]; // two letter command code
    char buffer3[13]; // numeric tail
    boolean commandError; // command status

    void setup() // run once, when the sketch starts
    {
    int l;

    // slow pwm down
    TCCR1B = TCCR1B & 0b11111000 | 0x01; // clock divided by 1024

    // get the Stepper ready
    myStepper.setSpeed(20);

    // make the ADC use our external voltage reference
    analogReference(EXTERNAL);

    // enable serial communications
    Serial.begin(9600);
    Serial.flush();

    // retrieve the last filter position
    filter_position=EEPROM.read(0);
    if (filter_position<0) filter_position=0;
    if (filter_position>4) filter_position=0;
    filter_destination=filter_position;
    filters_to_pass=0;

    // retrieve the filter offset position
    filter_offset=EEPROM.read(1)-10;
    if (filter_offset<-10) filter_offset=-10;
    if (filter_offset> 10) filter_offset= 10;

    // retrieve the last filter wheel calibration
    southG =EEPROM_readInt(20);
    northG =EEPROM_readInt(22);
    neutralG=EEPROM_readInt(24);

    // prepare the command buffers
    buffer[0]=0;
    buffer2[0]=0;
    buffer3[0]=0;
    }

    void loop()
    {
    bool input_ready = false;
    int dummy;
    int State;
    int T;
    int i;
    int L;
    int tr_count_actual;
    char Temp[80];

    // build serial input:
    if (Serial.available() > 0) {

    // get incoming byte:
    inChar = Serial.read();

    // and build up a command
    buffer[bufferPtr]=toupper(inChar);
    bufferPtr++;
    buffer[bufferPtr]=(char)0;
    if (bufferPtr>7 { bufferPtr=78; } // limit maximum command length to avoid overflow

    // process command
    if (inChar==(char)13) {
    buffer[bufferPtr-1]=0; // erase the cr
    strncpy(buffer2,buffer,2); // get the two letter command
    strncpy(buffer3,&buffer[2],12); // get the optional numeric tail

    commandError=false;

    // ask for version
    if (strcmp(buffer2,"V?") == 0) {
    if (strlen(buffer3)==0) { Serial.println("On-Cue Filter Wheel V1.0"); } else commandError=true;
    } else

    // set current filter 1
    if (strcmp(buffer2,"F1") == 0) {
    if ((strlen(buffer3)==0) && (!Moving)) {
    if (filter_position!=0) { filters_to_pass=toPass(0,filter_position); filter_destination=0; filter_hysteresis=10; Moving=300; }
    Serial.println("Selecting Filter #1");
    } else commandError=true;
    } else
    // set current filter 2
    if (strcmp(buffer2,"F2") == 0) {
    if ((strlen(buffer3)==0) && (!Moving)) {
    if (filter_position!=1) { filters_to_pass=toPass(1,filter_position); filter_destination=1; filter_hysteresis=10; Moving=300; }
    Serial.println("Selecting Filter #2");
    } else commandError=true;
    } else
    // set current filter 3
    if (strcmp(buffer2,"F3") == 0) {
    if ((strlen(buffer3)==0) && (!Moving)) {
    if (filter_position!=2) { filters_to_pass=toPass(2,filter_position); filter_destination=2; filter_hysteresis=10; Moving=300; }
    Serial.println("Selecting Filter #3");
    } else commandError=true;
    } else
    // set current filter 4
    if (strcmp(buffer2,"F4") == 0) {
    if ((strlen(buffer3)==0) && (!Moving)) {
    if (filter_position!=3) { filters_to_pass=toPass(3,filter_position); filter_destination=3; filter_hysteresis=10; Moving=300; }
    Serial.println("Selecting Filter #4");
    } else commandError=true;
    } else
    // set current filter 5
    if (strcmp(buffer2,"F5") == 0) {
    if ((strlen(buffer3)==0) && (!Moving)) {
    if (filter_position!=4) { filters_to_pass=toPass(4,filter_position); filter_destination=4; filter_hysteresis=10; Moving=300; }
    Serial.println("Selecting Filter #5");
    } else commandError=true;
    } else
    // ask for current filter position
    if (strcmp(buffer2,"F?") == 0) {
    if (strlen(buffer3)==0) {
    if ((filter_position!=filter_destination) || (Moving)) {
    sprintf(Temp,"Filter: ?");
    } else {
    if (debug) {
    sprintf(Temp,"Filter: %d, Offset: %d, thresholdGN: %d, neutralG: %d, thresholdGS: %d", filter_position, filter_offset, thresholdGN, neutralG, thresholdGS);
    } else {
    int fp=filter_position+2; if (fp>4) fp=fp-4;
    sprintf(Temp,"Filter: %d", fp);
    }
    }
    Serial.println(Temp);
    } else commandError=true;
    } else
    // ask to calibrate filter wheel
    if (strcmp(buffer2,"FC") == 0) {
    if ((strlen(buffer3)==0) && (!Moving)) { calibrateFilters=fullRotation; Moving=300; filter_hysteresis=0; Serial.println("Ok"); } else commandError=true;
    } else
    // ask to seek zero position on filter wheel
    if (strcmp(buffer2,"FZ") == 0) {
    if ((strlen(buffer3)==0) && (!Moving)) { zeroFilters=fullRotation; Moving=300; filter_hysteresis=6; Serial.println("Ok"); } else commandError=true;
    } else
    // tweek filter wheel +
    if (strcmp(buffer2,"F+") == 0) {
    if (strlen(buffer3)==0) {
    if (filter_offset<9) { filter_offset++; EEPROM.write(1,filter_offset+10); Serial.println("Filter Offset Adjusted +1"); } else commandError=true;
    } else commandError=true;
    } else
    // tweek filter wheel -
    if (strcmp(buffer2,"F-") == 0) {
    if (strlen(buffer3)==0) {
    if (filter_offset>-9) { filter_offset--; EEPROM.write(1,filter_offset+10); Serial.println("Filter Offset Adjusted -1"); } else commandError=true;
    } else commandError=true;
    } else

    // debug mode on
    if (strcmp(buffer2,"D+") == 0) {
    if (strlen(buffer3)==0) { debug=true; Serial.println("Debug mode on"); } else commandError=true;
    } else
    // debug mode off
    if (strcmp(buffer2,"D-") == 0) {
    if (strlen(buffer3)==0) { debug=false; Serial.println("Debug mode off"); } else commandError=true;
    } else {
    // command not recognized
    commandError=true;
    Serial.println("Error");
    }

    // clear the last command
    bufferPtr=0; buffer[bufferPtr]=0;
    }
    }

    // Hall-effect filter wheel sensor
    // Some initial values observed were
    // SouthG = 794
    // NeutralG = 635
    // NorthG = 584
    G=analogRead(hallAnalogPin);
    thresholdGN=(neutralG-((neutralG-northG)/2)); // ex. 635-584 = +51, 51/4 = 15, 635-15 = 620;
    thresholdGS=(neutralG-((neutralG-southG)/2)); // ex. 635-794 = -159, -159/4 = -40, 635+40 = 675;
    if ((G<thresholdGN) && (G1>=thresholdGN) && !filter_hysteresis) { indexFilter =true; } else { indexFilter=false; }
    if ((G>thresholdGS) && (G1<=thresholdGS) && !filter_hysteresis) { standardFilter=true; } else { standardFilter=false; }
    G1=G;

    if (debug) {
    if (indexFilter) { Serial.print("I="); Serial.println(G); }
    if (standardFilter) { Serial.print("S="); Serial.println(G); }
    if (filter_hysteresis) { Serial.print("H="); Serial.println(G); }
    }

    if (filter_hysteresis>0) filter_hysteresis--;

    if (Moving) {
    // Three modes of operation, mode 1: filter positioning
    if ((!zeroFilters) && (!calibrateFilters)) {
    // Standard or index filter found
    if (standardFilter || indexFilter) {
    if (filters_to_pass>0) filters_to_pass--;
    }
    // Move filter to the new position
    if (filters_to_pass>0) {
    if (Moving>0) Moving--;
    myStepper.step(stepGranularity);
    } else {
    if (filter_position!=filter_destination) {
    filter_position=filter_destination;
    EEPROM.write(0,filter_position);
    }
    myStepper.step(filter_offset*stepGranularity);
    filter_hysteresis=false;
    Moving =false;
    }
    }

    // Three modes of operation, mode 2: homing
    if ((zeroFilters) && (!calibrateFilters)) {
    // Index filter found
    if (indexFilter) {
    filter_position=0; filter_destination=0;
    EEPROM.write(0,filter_position);
    myStepper.step(filter_offset*stepGranularity));
    Moving=false;
    } else {
    // move filter to a new position
    if (zeroFilters>0) zeroFilters--;
    if (Moving>0) Moving--;
    myStepper.step(stepGranularity);
    }
    }

    // Three modes of operation, mode 3: calibration
    if ((!zeroFilters) && (calibrateFilters)) {
    if (calibrateFilters>2) {
    // save a series of readings from all around the wheel
    if (calibrateFilters>1) calibrateFilters--;
    if (Moving>0) Moving--;
    myStepper.step(stepGranularity);
    GA[calibrateFilters]=(G>>2);
    } else {
    // sort the list of readings, ascending
    int l;
    int m;
    for (l=1; l<fullRotation-1; l++) {
    for (m=1; m<fullRotation-1; m++) {
    if (GA[l]>GA[m]) { G=GA[l]; GA[l]=GA[m]; GA[m]=G; }
    }
    }

    // take an average of readings from the lowest, middle, and highest
    southG =((GA[2]+GA[3]+GA[4])/3)<<2;
    neutralG=((GA[fullRotation/2-1]+GA[fullRotation/2]+GA[fullRotation/2+1])/3)<<2;
    northG =((GA[fullRotation-3]+GA[fullRotation-4]+GA[fullRotation-5])/3)<<2;

    if (debug) {
    Serial.println("Cal complete:");
    for (l=1; l<fullRotation-1; l++) { Serial.println(GA[l]<<2); }
    Serial.println("");
    sprintf(Temp,"Sav: SouthG=%d NeutralG=%d NorthG=%d",southG,neutralG,northG);
    Serial.println(Temp);
    }

    // and save them for later
    EEPROM_writeInt(20,southG);
    EEPROM_writeInt(22,northG);
    EEPROM_writeInt(24,neutralG);

    calibrateFilters=false;
    Moving =false;
    }
    }
    } else {
    filter_hysteresis=false;
    zeroFilters =false;
    Moving =false;
    calibrateFilters=false;
    filters_to_pass=0;
    }
    }

    // get the numeric tail of the command
    boolean intTail2(int *val,int *dec, int low, int high) {
    int l;
    int i;
    int hasDecimal;
    boolean isNumeric;
    long temp;

    l = strlen(buffer3);
    if (l>0) {
    // check to make sure we have a number
    isNumeric=true; for (i=0; i++; i<l) { if (((buffer3[i]<'0') || (buffer3[i]>'9')) && (buffer3[i]!='.')) { isNumeric=false; } }

    // check that only one digit is after the decimal point, if any decimal point is found
    hasDecimal=0; for (i=0; i++; i<l) { if (buffer3[i]=='.') { hasDecimal++; } }
    if (hasDecimal>1) { isNumeric=false; }
    if ((hasDecimal==1) && (buffer3[l-2]!='.')) { isNumeric=false; }

    // record and strip the decimal if present
    *dec=0;
    if (hasDecimal) { *dec=(int)buffer[l-1]-48; buffer[l-2]=0; }

    // convert to an integer
    *val=0;
    if (isNumeric) {
    temp=atoi(buffer3);
    if ((temp>=low) and (temp<=high)) { *val=temp; return true; } else return false;
    } else return false;

    } else return false;
    }

    // calculate how many filters to pass from current position
    int toPass(int filterDestination, int filterPosition) {
    int l;
    l=filterDestination-filterPosition;
    // if (l<0) l=4+l; // for a 4-position wheel
    if (l<0) l=5+l;
    return l;
    }

    // write int numbers into EEPROM
    void EEPROM_writeInt(int i,int l) {
    byte *lPtr;
    lPtr = (byte*)&l;
    EEPROM.write(i+0,*lPtr); lPtr++;
    EEPROM.write(i+1,*lPtr);
    }

    // read int numbers from EEPROM
    int EEPROM_readInt(int i) {
    int l;
    byte *lPtr;
    lPtr = (byte*)&l;
    *lPtr=EEPROM.read(i+0); lPtr++;
    *lPtr=EEPROM.read(i+1);
    return l;
    }
    Miniaturansichten angehängter Grafiken Miniaturansichten angehängter Grafiken Filterrad.jpg  

Ähnliche Themen

  1. Motor ohne Library starten
    Von Andi1888 im Forum Asuro
    Antworten: 7
    Letzter Beitrag: 14.03.2014, 14:16
  2. Drehrichtung eines DC-Motors wechseln
    Von Andri im Forum Elektronik
    Antworten: 17
    Letzter Beitrag: 30.01.2014, 14:30
  3. wechseln der Drehrichtung eines Motors
    Von Stephan_M. im Forum Elektronik
    Antworten: 3
    Letzter Beitrag: 01.11.2009, 11:05
  4. Projekt: Open Source Library / Firmware für RN- Motor Boards
    Von fwallenwein im Forum Open Source Software Projekte
    Antworten: 43
    Letzter Beitrag: 30.10.2006, 20:56
  5. Anfängerfrage: Polarität wechseln
    Von CopyConstructor im Forum Elektronik
    Antworten: 13
    Letzter Beitrag: 21.08.2006, 18:12

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •