Gina

Now taking OIII subs following a meridian flip. Still using 60s exposures and same gain. Here is one - stretched in Photoshop. On my new Linux desktop, PixInsight is currently calibrating flats.

The sky went poor for a while but it seems much better now. Here's the latest 60s sub in Ha.

Now concentrating on the Cygnus Loop in 3nm NB and currently capturing Ha subs. Done a bit of experimenting with gain and exposure and decided to reduce the gain by 6dB. This seems to give a slightly better image. Here is a single sub of 60s exposure and gain of 440 (44dB) T = -30°C.

This new camera with it's 16MPx sensor and 32MB images sure gathers a lot of data!! Particularly with hundreds of sub exposures of around a minute!! I have now filled up a whole 2TB HD on my new desktop PC! Will have to do some pruning. I'm going to have to be more rigorous during runs and just afterwards and immediately dump any unwanted data. Also, sets of biases, darks and flats can be dumped once they have been used to create masters. I was about to calibrate the flats I collected the other day ready to process my RGB + Ha data for M31 and making space on the SSD by moving data from there to HD when I go an HD full error!!!

Forecast is good again for tonight and I don't want to waste it. OTOH I think I'm suffering from loss of sleep and can't just stay up all night like I used to when I was younger. "Night shift" just doesn't seem to suit me I have a fair collection of subs for M31 at this FOV I reckon and rather than doing 3 or 4 sets of subs overnight I would be better off doing one continuous run or maybe two parts with a meridian flip between. Meridian flips are a nuisance and one reason I fancy a different mount - the EQ8 comes to a full stop just past the meridian. I haven't automated a meridian flip yet

Having read up on how the Ekos auto-focussing works, I'm not sure I want to use it in the way I was thinking. I was thinking of using auto-focus when changing filters (because SLR camera lenses are not apochromatic far enough into the red end of the spectrum for astro imaging without re-focussing) but I'm not sure the data will be sufficient without it taking a long time. The human eye is a lot better at determining focus than an electronic system and an alternative idea (which I've tried) is to measure the offset in focus steps between filters and then change focus by the pre-recorded amount when changing filters.

And rpi_focus.h /******************************************************************************* Copyright(c) 2014 Radek Kaczorek <rkaczorek AT gmail DOT com> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2 as published by the Free Software Foundation. . This library 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 Library General Public License for more details. . You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *******************************************************************************/ #ifndef FOCUSRPI_H #define FOCUSRPI_H #include <indifocuser.h> class FocusRpi : public INDI::Focuser { protected: private: ISwitch FocusResetS[1]; ISwitchVectorProperty FocusResetSP; ISwitch FocusParkingS[2]; ISwitchVectorProperty FocusParkingSP; INumber FocusBacklashN[1]; INumberVectorProperty FocusBacklashNP; public: FocusRpi(); virtual ~FocusRpi(); const char *getDefaultName(); virtual bool Connect(); virtual bool Disconnect(); virtual bool initProperties(); virtual bool updateProperties(); void ISGetProperties (const char *dev); virtual bool ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n); virtual bool ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n); virtual bool ISSnoopDevice(XMLEle *root); virtual bool saveConfigItems(FILE *fp); virtual IPState MoveFocuser(FocusDirection dir, int speed, int duration); virtual IPState MoveAbsFocuser(int ticks); virtual IPState MoveRelFocuser(FocusDirection dir, int ticks); virtual bool SetSpeed(int speed); }; #endif

Here is the Astroberry Focus .cpp file :- /******************************************************************************* Copyright(c) 2014 Radek Kaczorek <rkaczorek AT gmail DOT com> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License version 2 as published by the Free Software Foundation. . This library 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 Library General Public License for more details. . You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *******************************************************************************/ #include <stdio.h> #include <unistd.h> #include <memory> #include <bcm2835.h> #include "rpi_focus.h" // We declare an auto pointer to focusRpi. std::auto_ptr<FocusRpi> focusRpi(0); // Stepper motor takes 4 miliseconds to move one step = 250 steps per second (real rate = 240,905660377) // 1) focusing from min to max takes 7 evolutions // 2) PG2528-0502U step motor makes 7 * (360deg/15degperstep)*72:1 = 1728 steps per evolution // 3) MAX_STEPS for 7 evolutions should be 12096 #define MAX_STEPS 10000 // maximum steps focuser can travel from min=0 to max #define STEP_DELAY 4 // miliseconds // indicate GPIOs used - use P1_* pin numbers not gpio numbers (!!!) //RPi B+ /* #define DIR RPI_V2_GPIO_P1_07 // GPIO4 #define STEP RPI_V2_GPIO_P1_11 // GPIO17 #define M0 RPI_V2_GPIO_P1_15 // GPIO22 #define M1 RPI_V2_GPIO_P1_13 // GPIO27 #define SLEEP RPI_V2_GPIO_P1_16 // GPIO23 */ //RPi 2 #define DIR RPI_BPLUS_GPIO_J8_07 // GPIO4 #define STEP RPI_BPLUS_GPIO_J8_11 // GPIO17 #define M0 RPI_BPLUS_GPIO_J8_15 // GPIO22 #define M1 RPI_BPLUS_GPIO_J8_13 // GPIO27 #define SLEEP RPI_BPLUS_GPIO_J8_16 // GPIO23 void ISPoll(void *p); void ISInit() { static int isInit = 0; if (isInit == 1) return; if(focusRpi.get() == 0) { isInit = 1; focusRpi.reset(new FocusRpi()); } } void ISGetProperties(const char *dev) { ISInit(); focusRpi->ISGetProperties(dev); } void ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int num) { ISInit(); focusRpi->ISNewSwitch(dev, name, states, names, num); } void ISNewText( const char *dev, const char *name, char *texts[], char *names[], int num) { ISInit(); focusRpi->ISNewText(dev, name, texts, names, num); } void ISNewNumber(const char *dev, const char *name, double values[], char *names[], int num) { ISInit(); focusRpi->ISNewNumber(dev, name, values, names, num); } void ISNewBLOB (const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[], char *formats[], char *names[], int n) { INDI_UNUSED(dev); INDI_UNUSED(name); INDI_UNUSED(sizes); INDI_UNUSED(blobsizes); INDI_UNUSED(blobs); INDI_UNUSED(formats); INDI_UNUSED(names); INDI_UNUSED(n); } void ISSnoopDevice (XMLEle *root) { ISInit(); focusRpi->ISSnoopDevice(root); } FocusRpi::FocusRpi() { setVersion(2,1); } FocusRpi::~FocusRpi() { } const char * FocusRpi::getDefaultName() { return (char *)"Astroberry Focuser"; } bool FocusRpi::Connect() { if (!bcm2835_init()) { IDMessage(getDeviceName(), "Problem initiating Astroberry Focuser."); return false; } // init GPIOs std::ofstream exportgpio; exportgpio.open("/sys/class/gpio/export"); exportgpio << DIR << std::endl; exportgpio << STEP << std::endl; exportgpio << M0 << std::endl; exportgpio << M1 << std::endl; exportgpio << SLEEP << std::endl; exportgpio.close(); // Set gpios to output mode bcm2835_gpio_fsel(DIR, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(STEP, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(SLEEP, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); IDMessage(getDeviceName(), "Astroberry Focuser connected successfully."); return true; } bool FocusRpi::Disconnect() { // park focuser if ( FocusParkingS[0].s == ISS_ON ) { IDMessage(getDeviceName(), "Astroberry Focuser is parking..."); MoveAbsFocuser(FocusAbsPosN[0].min); } // close GPIOs std::ofstream unexportgpio; unexportgpio.open("/sys/class/gpio/unexport"); unexportgpio << DIR << std::endl; unexportgpio << STEP << std::endl; unexportgpio << M0 << std::endl; unexportgpio << M1 << std::endl; unexportgpio << SLEEP << std::endl; unexportgpio.close(); bcm2835_close(); IDMessage(getDeviceName(), "Astroberry Focuser disconnected successfully."); return true; } bool FocusRpi::initProperties() { INDI::Focuser::initProperties(); IUFillText(&PortT[0], "PORT", "Port","RPi GPIO"); IUFillTextVector(&PortTP,PortT,1,getDeviceName(),"DEVICE_PORT","Ports",OPTIONS_TAB,IP_RO,0,IPS_OK); IUFillNumber(&FocusAbsPosN[0],"FOCUS_ABSOLUTE_POSITION","Ticks","%0.0f",0,MAX_STEPS,(int)MAX_STEPS/100,0); IUFillNumberVector(&FocusAbsPosNP,FocusAbsPosN,1,getDeviceName(),"ABS_FOCUS_POSITION","Position",MAIN_CONTROL_TAB,IP_RW,0,IPS_OK); IUFillNumber(&PresetN[0], "Preset 1", "", "%0.0f", 0, MAX_STEPS, (int)(MAX_STEPS/100), 0); IUFillNumber(&PresetN[1], "Preset 2", "", "%0.0f", 0, MAX_STEPS, (int)(MAX_STEPS/100), 0); IUFillNumber(&PresetN[2], "Preset 3", "", "%0.0f", 0, MAX_STEPS, (int)(MAX_STEPS/100), 0); IUFillNumberVector(&PresetNP, PresetN, 3, getDeviceName(), "Presets", "Presets", "Presets", IP_RW, 0, IPS_IDLE); IUFillSwitch(&PresetGotoS[0], "Preset 1", "Preset 1", ISS_OFF); IUFillSwitch(&PresetGotoS[1], "Preset 2", "Preset 2", ISS_OFF); IUFillSwitch(&PresetGotoS[2], "Preset 3", "Preset 3", ISS_OFF); IUFillSwitchVector(&PresetGotoSP, PresetGotoS, 3, getDeviceName(), "Presets Goto", "Goto", MAIN_CONTROL_TAB,IP_RW,ISR_1OFMANY,60,IPS_OK); IUFillNumber(&FocusBacklashN[0], "FOCUS_BACKLASH_VALUE", "Steps", "%0.0f", 0, (int)(MAX_STEPS/100), (int)(MAX_STEPS/1000), 0); IUFillNumberVector(&FocusBacklashNP, FocusBacklashN, 1, getDeviceName(), "FOCUS_BACKLASH", "Backlash", OPTIONS_TAB, IP_RW, 0, IPS_IDLE); IUFillSwitch(&FocusResetS[0],"FOCUS_RESET","Reset",ISS_OFF); IUFillSwitchVector(&FocusResetSP,FocusResetS,1,getDeviceName(),"FOCUS_RESET","Position Reset",OPTIONS_TAB,IP_RW,ISR_1OFMANY,60,IPS_OK); IUFillSwitch(&FocusParkingS[0],"FOCUS_PARKON","Enable",ISS_OFF); IUFillSwitch(&FocusParkingS[1],"FOCUS_PARKOFF","Disable",ISS_OFF); IUFillSwitchVector(&FocusParkingSP,FocusParkingS,2,getDeviceName(),"FOCUS_PARK","Parking Mode",OPTIONS_TAB,IP_RW,ISR_1OFMANY,60,IPS_OK); // set capabilities SetFocuserCapability(FOCUSER_CAN_ABS_MOVE | FOCUSER_CAN_REL_MOVE); controller->mapController("Focus In", "Focus In", INDI::Controller::CONTROLLER_BUTTON, "BUTTON_1"); controller->mapController("Focus Out", "Focus Out", INDI::Controller::CONTROLLER_BUTTON, "BUTTON_2"); controller->mapController("Abort Focus", "Abort Focus", INDI::Controller::CONTROLLER_BUTTON, "BUTTON_3"); controller->initProperties(); return true; } void FocusRpi::ISGetProperties (const char *dev) { INDI::Focuser::ISGetProperties(dev); /* Add debug controls so we may debug driver if necessary */ addDebugControl(); return; } bool FocusRpi::updateProperties() { INDI::Focuser::updateProperties(); if (isConnected()) { deleteProperty(FocusSpeedNP.name); defineNumber(&FocusAbsPosNP); defineSwitch(&FocusMotionSP); defineNumber(&FocusBacklashNP); defineSwitch(&FocusParkingSP); defineSwitch(&FocusResetSP); } else { deleteProperty(FocusAbsPosNP.name); deleteProperty(FocusMotionSP.name); deleteProperty(FocusBacklashNP.name); deleteProperty(FocusParkingSP.name); deleteProperty(FocusResetSP.name); } return true; } bool FocusRpi::ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n) { // first we check if it's for our device if(strcmp(dev,getDeviceName())==0) { // handle focus absolute position if (!strcmp(name, FocusAbsPosNP.name)) { int newPos = (int) values[0]; if ( MoveAbsFocuser(newPos) == IPS_OK ) { IUUpdateNumber(&FocusAbsPosNP,values,names,n); FocusAbsPosNP.s=IPS_OK; IDSetNumber(&FocusAbsPosNP, NULL); } return true; } // handle focus relative position if (!strcmp(name, FocusRelPosNP.name)) { IUUpdateNumber(&FocusRelPosNP,values,names,n); //FOCUS_INWARD if ( FocusMotionS[0].s == ISS_ON ) MoveRelFocuser(FOCUS_INWARD, FocusRelPosN[0].value); //FOCUS_OUTWARD if ( FocusMotionS[1].s == ISS_ON ) MoveRelFocuser(FOCUS_OUTWARD, FocusRelPosN[0].value); FocusRelPosNP.s=IPS_OK; IDSetNumber(&FocusRelPosNP, NULL); return true; } // handle focus timer if (!strcmp(name, FocusTimerNP.name)) { IUUpdateNumber(&FocusTimerNP,values,names,n); //FOCUS_INWARD if ( FocusMotionS[0].s == ISS_ON ) MoveFocuser(FOCUS_INWARD, 0, FocusTimerN[0].value); //FOCUS_OUTWARD if ( FocusMotionS[1].s == ISS_ON ) MoveFocuser(FOCUS_OUTWARD, 0, FocusTimerN[0].value); FocusTimerNP.s=IPS_OK; IDSetNumber(&FocusTimerNP, NULL); return true; } // handle focus backlash if (!strcmp(name, FocusBacklashNP.name)) { IUUpdateNumber(&FocusBacklashNP,values,names,n); FocusBacklashNP.s=IPS_OK; IDSetNumber(&FocusBacklashNP, "Astroberry Focuser backlash set to %d", (int) FocusBacklashN[0].value); return true; } } return INDI::Focuser::ISNewNumber(dev,name,values,names,n); } bool FocusRpi::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n) { // first we check if it's for our device if (!strcmp(dev, getDeviceName())) { /* // handle focus motion in and out if (!strcmp(name, FocusMotionSP.name)) { IUUpdateSwitch(&FocusMotionSP, states, names, n); //FOCUS_INWARD if ( FocusMotionS[0].s == ISS_ON ) MoveRelFocuser(FOCUS_INWARD, FocusRelPosN[0].value); //FOCUS_OUTWARD if ( FocusMotionS[1].s == ISS_ON ) MoveRelFocuser(FOCUS_OUTWARD, FocusRelPosN[0].value); //FocusMotionS[0].s = ISS_OFF; //FocusMotionS[1].s = ISS_OFF; FocusMotionSP.s = IPS_OK; IDSetSwitch(&FocusMotionSP, NULL); return true; } */ // handle focus presets if (!strcmp(name, PresetGotoSP.name)) { IUUpdateSwitch(&PresetGotoSP, states, names, n); //Preset 1 if ( PresetGotoS[0].s == ISS_ON ) MoveAbsFocuser(PresetN[0].value); //Preset 2 if ( PresetGotoS[1].s == ISS_ON ) MoveAbsFocuser(PresetN[1].value); //Preset 2 if ( PresetGotoS[2].s == ISS_ON ) MoveAbsFocuser(PresetN[2].value); PresetGotoS[0].s = ISS_OFF; PresetGotoS[1].s = ISS_OFF; PresetGotoS[2].s = ISS_OFF; PresetGotoSP.s = IPS_OK; IDSetSwitch(&PresetGotoSP, NULL); return true; } // handle focus reset if(!strcmp(name, FocusResetSP.name)) { IUUpdateSwitch(&FocusResetSP, states, names, n); if ( FocusResetS[0].s == ISS_ON && FocusAbsPosN[0].value == FocusAbsPosN[0].min ) { FocusAbsPosN[0].value = (int)MAX_STEPS/100; IDSetNumber(&FocusAbsPosNP, NULL); MoveAbsFocuser(0); } FocusResetS[0].s = ISS_OFF; IDSetSwitch(&FocusResetSP, NULL); return true; } // handle parking mode if(!strcmp(name, FocusParkingSP.name)) { IUUpdateSwitch(&FocusParkingSP, states, names, n); IDSetSwitch(&FocusParkingSP, NULL); return true; } // handle focus abort - TODO if (!strcmp(name, AbortSP.name)) { IUUpdateSwitch(&AbortSP, states, names, n); AbortS[0].s = ISS_OFF; AbortSP.s = IPS_OK; IDSetSwitch(&AbortSP, NULL); return true; } } return INDI::Focuser::ISNewSwitch(dev,name,states,names,n); } bool FocusRpi::ISSnoopDevice (XMLEle *root) { controller->ISSnoopDevice(root); return INDI::Focuser::ISSnoopDevice(root); } bool FocusRpi::saveConfigItems(FILE *fp) { IUSaveConfigText(fp, &PortTP); IUSaveConfigNumber(fp, &FocusRelPosNP); IUSaveConfigNumber(fp, &PresetNP); IUSaveConfigNumber(fp, &FocusBacklashNP); IUSaveConfigSwitch(fp, &FocusParkingSP); if ( FocusParkingS[0].s == ISS_ON ) IUSaveConfigNumber(fp, &FocusAbsPosNP); controller->saveConfigItems(fp); return true; } IPState FocusRpi::MoveFocuser(FocusDirection dir, int speed, int duration) { int ticks = (int) ( duration / STEP_DELAY); return MoveRelFocuser( dir, ticks); } IPState FocusRpi::MoveRelFocuser(FocusDirection dir, int ticks) { int targetTicks = FocusAbsPosN[0].value + (ticks * (dir == FOCUS_INWARD ? -1 : 1)); return MoveAbsFocuser(targetTicks); } IPState FocusRpi::MoveAbsFocuser(int targetTicks) { if (targetTicks < FocusAbsPosN[0].min || targetTicks > FocusAbsPosN[0].max) { IDMessage(getDeviceName(), "Requested position is out of range."); return IPS_ALERT; } if (targetTicks == FocusAbsPosN[0].value) { // IDMessage(getDeviceName(), "Astroberry Focuser already in the requested position."); return IPS_OK; } // set focuser busy FocusAbsPosNP.s = IPS_BUSY; IDSetNumber(&FocusAbsPosNP, NULL); // motor wake up bcm2835_gpio_write(SLEEP, HIGH); // set full step size SetSpeed(1); // check last motion direction for backlash triggering char lastdir = bcm2835_gpio_lev(DIR); // set direction const char* direction; if (targetTicks > FocusAbsPosN[0].value) { // OUTWARD bcm2835_gpio_write(DIR, LOW); direction = " outward "; } else { // INWARD bcm2835_gpio_write(DIR, HIGH); direction = " inward "; } IDMessage(getDeviceName() , "Astroberry Focuser is moving %s", direction); // if direction changed do backlash adjustment if ( bcm2835_gpio_lev(DIR) != lastdir && FocusAbsPosN[0].value != 0 && FocusBacklashN[0].value != 0 ) { IDMessage(getDeviceName() , "Astroberry Focuser backlash compensation by %0.0f steps...", FocusBacklashN[0].value); for ( int i = 0; i < FocusBacklashN[0].value; i++ ) { // step on bcm2835_gpio_write(STEP, HIGH); // wait bcm2835_delay(STEP_DELAY/2); // step off bcm2835_gpio_write(STEP, LOW); // wait bcm2835_delay(STEP_DELAY/2); } } // process targetTicks int ticks = abs(targetTicks - FocusAbsPosN[0].value); for ( int i = 0; i < ticks; i++ ) { // step on bcm2835_gpio_write(STEP, HIGH); // wait bcm2835_delay(STEP_DELAY/2); // step off bcm2835_gpio_write(STEP, LOW); // wait bcm2835_delay(STEP_DELAY/2); // INWARD - count down if ( bcm2835_gpio_lev(DIR) == HIGH ) FocusAbsPosN[0].value -= 1; // OUTWARD - count up if ( bcm2835_gpio_lev(DIR) == LOW ) FocusAbsPosN[0].value += 1; IDSetNumber(&FocusAbsPosNP, NULL); } // motor sleep bcm2835_gpio_write(SLEEP, LOW); // update abspos value and status IDSetNumber(&FocusAbsPosNP, "Astroberry Focuser moved to position %0.0f", FocusAbsPosN[0].value); FocusAbsPosNP.s = IPS_OK; IDSetNumber(&FocusAbsPosNP, NULL); return IPS_OK; } bool FocusRpi::SetSpeed(int speed) { /* Stepper motor resolution settings (for PG2528-0502U) * 1) 1/1 - M0=0 M1=0 * 2) 1/2 - M0=1 M1=0 * 3) 1/4 - M0=floating M1=0 * 4) 1/8 - M0=0 M1=1 * 5) 1/16 - M0=1 M1=1 * 6) 1/32 - M0=floating M1=1 */ switch(speed) { case 1: // 1:1 bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(M0, LOW); bcm2835_gpio_write(M1, LOW); break; case 2: // 1:2 bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(M0, HIGH); bcm2835_gpio_write(M1, LOW); break; case 3: // 1:4 bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(M0, BCM2835_GPIO_PUD_OFF); bcm2835_gpio_write(M1, LOW); break; case 4: // 1:8 bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(M0, LOW); bcm2835_gpio_write(M1, HIGH); break; case 5: // 1:16 bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(M0, HIGH); bcm2835_gpio_write(M1, HIGH); break; case 6: // 1:32 bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_INPT); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(M0, BCM2835_GPIO_PUD_OFF); bcm2835_gpio_write(M1, HIGH); break; default: // 1:1 bcm2835_gpio_fsel(M0, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_fsel(M1, BCM2835_GPIO_FSEL_OUTP); bcm2835_gpio_write(M0, LOW); bcm2835_gpio_write(M1, LOW); break; } return true; }

I've been studying the C++ code for the focuser. For controlling my ASC focus the code will be alright as it is though could be simplified with the Ekos controls simplified to match. All I need for the ASC focus is STEP and DIRection. Fine control is all that's required as the lens can start at approximate focus. For DSO imaging it would be useful to have two speeds but I have yet to see how auto-focus works. The Astroberry Focuser code allows for 6 different speeds and uses a mode of control not available on the A4988 driver module and that is output GPIO pin floating. Now I'm wondering why such a wide range of speeds has been allowed for and hence coded. Maybe the author just wanted to provide as much control as available with the hardware. I shall look at the Ekos controls the focuser driver provides and see if all these speeds are used - I very much suspect NOT. Auto-focusing is something else to look at as I said above and would be very useful for imaging sessions.

Lists of GPIO lines used in Astroberry board and focuser - they don't clash so no need to alter The board pins are all outputs and would control relays on the associated hardware despite being called IN*. Astroberry Board Astroberry Focuser

Think I'll see if I can get the RPi working in my all sky cam. ASI187MM + focuser with Astroberry Focuser + dew heater control with Astroberry Board. I shall need to look at the Astroberry board driver C++ code to see which GPIO lines are used and modify if wanted (and recompile). I shall need to find out how to have SSH and WiFi set ready to receive commands to enable the indiserver OR how to make indiserver auto-start with required drivers chosen.

This is the final Ha sub of the series of 200 giving a total of 200 x 60s = 200m = 3h 20m total imaging time on the Ha - should be usable

Realising I still had a low gain for RGB I reset the gain to 500 and reduced the exposure to 30s and here is the result in a single sub. Small star forming zones can just be seen.

Decided to go for a goodly set of Ha subs to add to the RGB rather than mess about with filters - feeling too tired for that and to stay up very late capturing. I think I'll leave all night imaging until I get an automated setup working. Consequently, I set up for 120s Ha images at -30°C.

Set up for 150 subs of 30s that's 75m total imaging time which will finish quite early so I'll have to think what I want to do for the rest of the night - if anything. I'll have a look round the sky and see if anything springs to mind (not too close to the half moon). I could take the rig off the mount and change over to NB. If the FW held just one more filter I wouldn't have to open it up to change filters. But I guess we can't have everything...

Clear sky this evening and I'm finishing off my present RGB run on M31. Moon well out of the way. Well - 90° off axis The blue seems brighter than the red and green and I've had to reduce the exposure to 30s to avoid white clipping. Here a single blue sub 30s gain 0f 140 (14dB) an temperature of -29°C. Gamma stretched in Photoshop. Full frame.

OK so WiFi is not essential but it should work. I have the HomePlug devices I can use to provide a cable connection in the observatory if necessary but the idea of the RPi 3 was WiFi and to reduce cable count to absolute minimum.

Put micro SD card back in RPi and powered up. WiFi connection showing fine in router device list with same IP address as it should be having been set up as static BUT can't connect with Putty I need to connect with SSH/Putty as indiserver needs setting up.

Backed up onto HD of W7 desktop Tried writing the image onto another 8GB micro SD card but got an error saying the disk wasn't big enough - seems different makes have slightly different sizes. I have one or two 32BG cards if needed.

Firstly to shut down cleanly and avoid problems from just cutting the power - sudo shutdown -h -P now

Guess the next thing is to try it on the observatory but maybe I should make a backup first! Then the next job will be check out KStars and see if I can find a target.

It's suddenly become live - the Select Profile is available and I've been able to click the + button to Add Profile now set it up and it's WORKING I can slew from the settee

Now I'm trying to work out how on earth I managed to setup Ekos last time. I have the instructions but they bear no relationship to what's on my laptop in KStars/Ekos 1. Select Profile is greyed out! They don't say where the Profile Editor is

synscan. But the only difference is that the syncan is supplied with the hand controller - the mounts themselves are identical. For computer control you don't want the handset (and shouldn't try to use it) PC connects via USB to serial adapter to the socket the hand controller plugs into.

I've connected the NEQ6 to the RPi and 13v power now to see if it works So guess I need to start indiserver with the mount driver...