Ejemplo n.º 1
0
/**
 * Set the digital gain in the MT9V022.
 * Sets the tiled digital gain to 2x what the default is.
 */
dc1394error_t FFMVCCD::setDigitalGain(ISState state)
{
    dc1394error_t err;
    unsigned int val;

    if (state == ISS_OFF)
    {
        err = writeMicronReg(0x80, 0xF4);
        err = readMicronReg(0x80, &val);
        if (err == DC1394_SUCCESS)
        {
            IDMessage(getDeviceName(), "Turned off digital gain boost. Tiled Digital Gain = 0x%x", val);
        }
        else
        {
            IDMessage(getDeviceName(), "readMicronReg failed!");
        }
    }
    else
    {
        err = writeMicronReg(0x80, 0xF8);
        err = readMicronReg(0x80, &val);
        if (err == DC1394_SUCCESS)
        {
            IDMessage(getDeviceName(), "Turned on digital gain boost. Tiled Digital Gain = 0x%x", val);
        }
        else
        {
            IDMessage(getDeviceName(), "readMicronReg failed!");
        }
    }
    return DC1394_SUCCESS;
}
Ejemplo n.º 2
0
bool NFocus::Connect()
{
    int connectrc=0;
    char errorMsg[MAXRBUF];


    if (isDebug())
        IDLog("connecting to %s\n",PortT[0].text);

    if ( (connectrc = tty_connect(PortT[0].text, 9600, 8, 0, 1, &PortFD)) != TTY_OK)
    {
        tty_error_msg(connectrc, errorMsg, MAXRBUF);

        if (isDebug())
            IDLog("Failed to connect o port %s. Error: %s", PortT[0].text, errorMsg);

        IDMessage(getDeviceName(), "Failed to connect to port %s. Error: %s", PortT[0].text, errorMsg);

        return false;

    }


    IDMessage(getDeviceName(), "Nfocus is online. Getting focus parameters...");

    return true;
}
Ejemplo n.º 3
0
/**
 * Set the ADC reference voltage for the MT9V022.
 * Decreasing the reference voltage will, in effect, increase the gain.
 * The default Vref_ADC is 1.4V (4). We will bump it down to 1.0V (0).
 */
dc1394error_t FFMVCCD::setGainVref(ISState state)
{
    dc1394error_t err;
    unsigned int val;

    if (state == ISS_OFF)
    {
        err = writeMicronReg(0x2C, 4);
        err = readMicronReg(0x2C, &val);
        if (err == DC1394_SUCCESS)
        {
            IDMessage(getDeviceName(), "Turned off Gain boost. VREF_ADC = 0x%x", val);
        }
        else
        {
            IDMessage(getDeviceName(), "readMicronReg failed!");
        }
    }
    else
    {
        err = writeMicronReg(0x2C, 0);
        err = readMicronReg(0x2C, &val);
        if (err == DC1394_SUCCESS)
        {
            IDMessage(getDeviceName(), "Turned on Gain boost. VREF_ADC = 0x%x", val);
        }
        else
        {
            IDMessage(getDeviceName(), "readMicronReg failed!");
        }
    }
    return DC1394_SUCCESS;
}
Ejemplo n.º 4
0
/**
 * Download image from FireFly
 */
void FFMVCCD::grabImage()
{
   dc1394error_t err;
   dc1394video_frame_t *frame;
   uint32_t uheight, uwidth;
   int sub;
   uint16_t val;
   struct timeval start, end;

   // Let's get a pointer to the frame buffer
   uint8_t * image = PrimaryCCD.getFrameBuffer();

   // Get width and height
   int width = PrimaryCCD.getSubW() / PrimaryCCD.getBinX();
   int height = PrimaryCCD.getSubH() / PrimaryCCD.getBinY();

   memset(image, 0, PrimaryCCD.getFrameBufferSize());


   /*-----------------------------------------------------------------------
    *  stop data transmission
    *-----------------------------------------------------------------------*/


   gettimeofday(&start, NULL);
   for (sub = 0; sub < sub_count; ++sub) {
       IDMessage(getDeviceName(), "Getting sub %d of %d", sub, sub_count);
       err=dc1394_capture_dequeue(dcam, DC1394_CAPTURE_POLICY_WAIT, &frame);
       if (err != DC1394_SUCCESS) {
              IDMessage(getDeviceName(), "Could not capture frame");
       }
       dc1394_get_image_size_from_video_mode(dcam,DC1394_VIDEO_MODE_640x480_MONO16, &uwidth, &uheight);

       if (DC1394_TRUE == dc1394_capture_is_frame_corrupt(dcam, frame)) {
              IDMessage(getDeviceName(), "Corrupt frame!");
              continue;
       }
       // Fill buffer with random pattern
       for (int i=0; i < height ; i++) {
           for (int j=0; j < width; j++) {
               /* Detect unsigned overflow */
               val = ((uint16_t *) image)[i*width+j] + ntohs(((uint16_t*) (frame->image))[i*width+j]);
               if (val > ((uint16_t *) image)[i*width+j]) {
                   ((uint16_t *) image)[i*width+j] = val;
               } else {
                   ((uint16_t *) image)[i*width+j] = 0xFFFF;
               }
           }
       }

       dc1394_capture_enqueue(dcam, frame);
   }
   err=dc1394_video_set_transmission(dcam,DC1394_OFF);
   IDMessage(getDeviceName(), "Download complete.");
   gettimeofday(&end, NULL);
   IDMessage(getDeviceName(), "Download took %d uS", (int) ((end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec)));

   // Let INDI::CCD know we're done filling the image buffer
   ExposureComplete(&PrimaryCCD);
}
Ejemplo n.º 5
0
/********************************
** Client is asking us to establish connection to the device
*********************************/
bool Cindi_iidc::Connect() {
    dc1394camera_list_t *list;
    dc1394error_t err;

    dc1394 = dc1394_new();
    if (!dc1394) {
        return false;
    }

    /* init bus and connect to the camera */
    err = dc1394_camera_enumerate(dc1394, &list);
    if (err != DC1394_SUCCESS) {
        IDMessage(getDeviceName(), "Could not find DC1394 cameras!");
        return false;
    }
    if (!list->num) {
        IDMessage(getDeviceName(), "No DC1394 cameras found!");
        return false;
    }
    dcam = dc1394_camera_new(dc1394, list->ids[0].guid);
    if (!dcam) {
        IDMessage(getDeviceName(), "Unable to connect to camera!");
        return false;
    }

    /* Reset camera */
    err = dc1394_camera_reset(dcam);
    if (err != DC1394_SUCCESS) {
        IDMessage(getDeviceName(), "Unable to reset camera!");
        return false;
    }

    IDMessage(getDeviceName(), "indi-iidc connected successfully!");
    return true;
}
Ejemplo n.º 6
0
bool AAGCloudWatcher::Connect() {
  if (cwc == NULL) {
    ITextVectorProperty *tvp = getText("serial");

    if (!tvp) {
      return false;
    }

  //  IDLog("%s\n", tvp->tp[0].text);

    cwc = new CloudWatcherController(tvp->tp[0].text, false);

    int check = cwc->checkCloudWatcher();

    if (check) {
      IDMessage(getDefaultName(), "Connected to AAG Cloud Watcher\n");

      sendConstants();

      IEAddTimer(1., ISPoll, this);  // Create a timer to send parameters
    } else {
      IDMessage(getDefaultName(), "Could not connect to AAG Cloud Watcher. Check port and / or cable.\n");

      delete cwc;

      cwc = NULL;

      return false;
    }
  }

  return true;
}
Ejemplo n.º 7
0
IPState FocusSim::MoveAbsFocuser(uint32_t targetTicks)
{
    if (targetTicks < FocusAbsPosN[0].min || targetTicks > FocusAbsPosN[0].max)
    {
        IDMessage(getDeviceName(), "Error, requested absolute position is out of range.");
        return IPS_ALERT;
    }

    double mid = (FocusAbsPosN[0].max - FocusAbsPosN[0].min)/2;

    IDMessage(getDeviceName() , "Focuser is moving to requested position...");

    // Limit to +/- 10 from initTicks
    ticks = initTicks + (targetTicks - mid) / 5000.0;

    if (isDebug())
        IDLog("Current ticks: %g\n", ticks);

    // simulate delay in motion as the focuser moves to the new position

    usleep( abs(targetTicks - FocusAbsPosN[0].value) * FOCUS_MOTION_DELAY);

    FocusAbsPosN[0].value = targetTicks;

    FWHMN[0].value = 0.5625*ticks*ticks +  SeeingN[0].value;

    if (FWHMN[0].value < SeeingN[0].value)
        FWHMN[0].value = SeeingN[0].value;

    IDSetNumber(&FWHMNP, NULL);

    return IPS_OK;

}
Ejemplo n.º 8
0
Archivo: ieqpro.cpp Proyecto: mp77/indi
bool IEQPro::Goto(double r,double d)
{
    targetRA=r;
    targetDEC=d;
    char RAStr[64], DecStr[64];

    fs_sexa(RAStr, targetRA, 2, 3600);
    fs_sexa(DecStr, targetDEC, 2, 3600);

    if (set_ieqpro_ra(PortFD, r) == false || set_ieqpro_dec(PortFD, d) == false)
    {
        DEBUG(INDI::Logger::DBG_ERROR, "Error setting RA/DEC.");
        return false;
    }

    if (slew_ieqpro(PortFD) == false)
    {
        DEBUG(INDI::Logger::DBG_ERROR, "Failed to slew.");
        return false;
    }

    TrackState = SCOPE_SLEWING;

    IDMessage(getDeviceName(), "Slewing to RA: %s - DEC: %s", RAStr, DecStr);
    return true;
}
Ejemplo n.º 9
0
bool ioptronHC8406::updateLocation(double latitude, double longitude, double elevation)
{
    INDI_UNUSED(elevation);

    if (isSimulation())
        return true;

    double final_longitude;

    if (longitude > 180)
        final_longitude = longitude - 360.0;
    else
        final_longitude = longitude;

    if (!isSimulation() && setioptronHC8406Longitude(final_longitude) < 0)
    {
        DEBUG(INDI::Logger::DBG_ERROR, "Error setting site longitude coordinates");
        return false;
    }

    if (!isSimulation() && setioptronHC8406Latitude(latitude) < 0)
    {
        DEBUG(INDI::Logger::DBG_ERROR, "Error setting site latitude coordinates");
        return false;
    }

    char l[32], L[32];
    fs_sexa(l, latitude, 3, 3600);
    fs_sexa(L, longitude, 4, 3600);

    IDMessage(getDeviceName(), "Site location updated to Lat %.32s - Long %.32s", l, L);

    return true;
}
Ejemplo n.º 10
0
/**************************************************************************************
** Main device loop. We check for exposure progress
***************************************************************************************/
void FFMVCCD::TimerHit()
{
    long timeleft;

    if(isConnected() == false) {
        return;  //  No need to reset timer if we are not connected anymore
    }

    if (InExposure) {
        timeleft=CalcTimeLeft();

        // Less than a 0.1 second away from exposure completion
        // This is an over simplified timing method, check CCDSimulator and ffmvCCD for better timing checks
        if (timeleft < 0.1) {
            /* We're done exposing */
            IDMessage(getDeviceName(), "Exposure done, downloading image...");

            // Set exposure left to zero
            PrimaryCCD.setExposureLeft(0);

            // We're no longer exposing...
            InExposure = false;

            /* grab and save image */
            grabImage();
        } else {
            // Just update time left in client
            PrimaryCCD.setExposureLeft(timeleft);
        }
    }

    SetTimer(POLLMS);
    return;
}
Ejemplo n.º 11
0
/**************************************************************************************
** Create a random image and return it to client
***************************************************************************************/
void SimpleDetector::grabFrame()
{
    // Set length of continuum
    int len  = PrimaryDetector.getSampleRate() * PrimaryDetector.getCaptureDuration() * PrimaryDetector.getBPS() / 8;
    PrimaryDetector.setContinuumBufferSize(len);
 
   // Let's get a pointer to the frame buffer
    uint8_t *continuum = PrimaryDetector.getContinuumBuffer();

    // Fill buffer with random pattern
    for (int i = 0; i < len; i++)
        continuum[i] = rand() % 255;

    // Set length of spectrum
    len  = 1000;
    PrimaryDetector.setSpectrumBufferSize(len);
 
   // Let's get a pointer to the frame buffer
    double *spectrum = PrimaryDetector.getSpectrumBuffer();

    // Fill buffer with random pattern
    for (int i = 0; i < len; i++)
        spectrum[i] = rand() % 255;

    IDMessage(getDeviceName(), "Download complete.");

    // Let INDI::Detector know we're done filling the image buffer
    CaptureComplete(&PrimaryDetector);
}
Ejemplo n.º 12
0
IPState NFocus::MoveRelFocuser(FocusDirection dir, uint32_t ticks)
{
    double cur_rpos = 0;
    double new_rpos = 0;
    int ret         = 0;
    bool nset       = false;

    cur_rpos = new_rpos = ticks;
    /* CHECK 2006-01-26, limits are relative to the actual position */
    nset = new_rpos >= -0xffff && new_rpos <= 0xffff;

    if (nset)
    {
        if (dir == FOCUS_OUTWARD)
        {
            if ((currentPosition + new_rpos < currentMinPosition) || (currentPosition + new_rpos > currentMaxPosition))
            {
                IDMessage(getDeviceName(), "Value out of limits %5.0f", currentPosition + new_rpos);
                return IPS_ALERT;
            }
            ret = moveNFOutward(&new_rpos);
        }
        else
        {
            if ((currentPosition - new_rpos < currentMinPosition) || (currentPosition - new_rpos > currentMaxPosition))
            {
                IDMessage(getDeviceName(), "Value out of limits %5.0f", currentPosition - new_rpos);
                return IPS_ALERT;
            }
            ret = moveNFInward(&new_rpos);
        }

        if (ret < 0)
        {
            // We have to leave here, because new_rpos is not set
            return IPS_ALERT;
        }

        currentRelativeMovement = cur_rpos;
        return IPS_OK;
    }
    {
        IDMessage(getDeviceName(), "Value out of limits.");
        return IPS_ALERT;
    }
}
Ejemplo n.º 13
0
bool JoyStick::Connect()
{
    bool rc = driver->Connect();

    if (rc)
    {
        IDMessage(getDeviceName(), "Joystick is online.");

        setupParams();

    }
    else
        IDMessage(getDeviceName(), "Error: cannot find Joystick device.");

    return rc;
    
}
Ejemplo n.º 14
0
/**************************************************************************************
** Client is asking us to establish connection to the device
***************************************************************************************/
bool SimpleDetector::Connect()
{
    IDMessage(getDeviceName(), "Simple Detector connected successfully!");

    // Let's set a timer that checks teleDetectors status every POLLMS milliseconds.
    SetTimer(POLLMS);

    return true;
}
Ejemplo n.º 15
0
/********************************
** Client is asking us to terminate connection to the device
*********************************/
bool Cindi_iidc::Disconnect() {
    if (dcam) {
        dc1394_capture_stop(dcam);
        dc1394_camera_free(dcam);
    }

    IDMessage(getDeviceName(), "indi-iidc disconnected successfully!");
    return true;
}
Ejemplo n.º 16
0
bool QFW::Handshake()
{
    if (isSimulation())
    {
        IDMessage(getDeviceName(), "Simulation: connected");
        PortFD = 1;
    }
    else
    {
        // check serial connection
        if (PortFD < 0 || isatty(PortFD) == 0)
        {
            IDMessage(getDeviceName(), "Device /dev/ttyACM0 is not available\n");
            return false;
        }
    }
    return true;
}
Ejemplo n.º 17
0
/**************************************************************************************
** Client is asking us to terminate connection to the device
***************************************************************************************/
bool FFMVCCD::Disconnect()
{
    if (dcam) {
        dc1394_capture_stop(dcam);
        dc1394_camera_free(dcam);
    }

    IDMessage(getDeviceName(), "Point Grey FireFly MV disconnected successfully!");
    return true;
}
Ejemplo n.º 18
0
int NFocus::ReadResponse(char *buf, int nbytes, int timeout)
{

  char nfocus_error[MAXRBUF];
  int bytesRead = 0;
  int totalBytesRead = 0;
  int err_code;

  if (isDebug())
      IDLog("##########################################\n")
;
  while (totalBytesRead < nbytes)
  {
      if ( (err_code = tty_read(PortFD, buf+totalBytesRead, nbytes-totalBytesRead, timeout, &bytesRead)) != TTY_OK)
      {
              tty_error_msg(err_code, nfocus_error, MAXRBUF);
              if (isDebug())
              {
                  IDLog("TTY error detected: %s\n", nfocus_error);
                  IDMessage(getDeviceName(), "TTY error detected: %s\n", nfocus_error);
              }
              return -1;
      }

      if (isDebug())
        IDLog("Bytes Read: %d\n", bytesRead);

      if (bytesRead < 0 )
      {
          if (isDebug())
            IDLog("Bytesread < 1\n");
          return -1;
      }

        totalBytesRead += bytesRead;
    }

    tcflush(PortFD, TCIOFLUSH);

   if (isDebug())
   {
       fprintf(stderr, "READ : (%s,%d), %d\n", buf, 9, totalBytesRead) ;
        fprintf(stderr, "READ : ") ;
        for(int i=0; i < 9; i++)
        {

         fprintf(stderr, "0x%2x ", (unsigned char)buf[i]) ;
        }
        fprintf(stderr, "\n") ;
   }

  return 9;
}
Ejemplo n.º 19
0
bool FishCampCCD::UpdateCCDFrame(int x, int y, int w, int h)
{
    int rc = 0;
    /* Add the X and Y offsets */
    long x_1 = x;
    long y_1 = y;

    long bin_width  = x_1 + (w / PrimaryCCD.getBinX());
    long bin_height = y_1 + (h / PrimaryCCD.getBinY());

    if (bin_width > PrimaryCCD.getXRes() / PrimaryCCD.getBinX())
    {
        IDMessage(getDeviceName(), "Error: invalid width requested %d", w);
        return false;
    }
    else if (bin_height > PrimaryCCD.getYRes() / PrimaryCCD.getBinY())
    {
        IDMessage(getDeviceName(), "Error: invalid height request %d", h);
        return false;
    }

    LOGF_DEBUG("The Final image area is (%ld, %ld), (%ld, %ld)\n", x_1, y_1, bin_width,
               bin_height);

    rc = fcUsb_cmd_setRoi(cameraNum, x_1, y_1,  x_1 + w - 1, y_1 + h - 1);

    LOGF_DEBUG("fcUsb_cmd_setRoi returns %d", rc);

    // Set UNBINNED coords
    PrimaryCCD.setFrame(x_1, y_1, w, h);

    int nbuf;
    nbuf = (bin_width * bin_height * PrimaryCCD.getBPP() / 8); //  this is pixel count
    nbuf += 512;                                               //  leave a little extra at the end
    PrimaryCCD.setFrameBufferSize(nbuf);

    LOGF_DEBUG("Setting frame buffer size to %d bytes.\n", nbuf);

    return true;
}
Ejemplo n.º 20
0
IPState NFocus::MoveRelFocuser(FocusDirection dir, uint32_t ticks)
{
      double cur_rpos=0 ;
      double new_rpos = 0 ;
      int ret=0;
      bool nset = false;

        cur_rpos= new_rpos = ticks;
        /* CHECK 2006-01-26, limits are relative to the actual position */
        nset = new_rpos >= -0xffff && new_rpos <= 0xffff;

        if (nset)
        {

          if( dir == FOCUS_OUTWARD)
          {
	    if((currentPosition + new_rpos < currentMinPosition) || (currentPosition + new_rpos > currentMaxPosition))
	    {
	      IDMessage(getDeviceName(), "Value out of limits %5.0f", currentPosition +  new_rpos);
          return IPS_ALERT;
  	    }
            ret= updateNFPositionRelativeOutward(&new_rpos) ;
	  }
          else
	  {
	    if((currentPosition - new_rpos < currentMinPosition) || (currentPosition - new_rpos > currentMaxPosition))
	    {
	      IDMessage(getDeviceName(), "Value out of limits %5.0f", currentPosition -  new_rpos);
          return IPS_ALERT;
  	    }
            ret= updateNFPositionRelativeInward(&new_rpos) ;
	  }

          if( ret < 0)
          {

            IDMessage(getDeviceName(), "Read out of the relative movement failed, trying to recover position.");
            if((ret= updateNFPosition(&currentPosition)) < 0)
            {

              IDMessage(getDeviceName(), "Unknown error while reading  Nfocus position: %d", ret);
              return IPS_ALERT;
            }

            IDMessage(getDeviceName(), "Nfocus position recovered %5.0f", currentPosition);
            // We have to leave here, because new_rpos is not set
            return IPS_ALERT;
          }

          currentRelativeMovement= cur_rpos ;
//          currentAbsoluteMovement= currentPosition;
          return IPS_OK;
        }
        {
            IDMessage(getDeviceName(), "Value out of limits.");
            return IPS_ALERT;
        }


}
Ejemplo n.º 21
0
IPState NFocus::MoveAbsFocuser(uint32_t targetTicks)
{
    int ret= -1 ;
    double new_apos = targetTicks;

    if (targetTicks < FocusAbsPosN[0].min || targetTicks > FocusAbsPosN[0].max)
    {
        IDMessage(getDeviceName(), "Error, requested absolute position is out of range.");
        return IPS_ALERT;
    }

    IDMessage(getDeviceName() , "Focuser is moving to requested position...");

    if(( ret= updateNFPositionAbsolute(&new_apos)) < 0)
    {

        IDMessage(getDeviceName(), "Read out of the absolute movement failed %3d, trying to recover position.", ret);

        for (int i=0;; i++)
        {
            if((ret= updateNFPosition(&currentPosition)) < 0)
            {
                IDMessage(getDeviceName(),"Unknown error while reading  Nfocus position: %d.", ret);
                if (i == NF_MAX_TRIES)
                    return IPS_ALERT;
                else
                    usleep(NF_MAX_DELAY);
            }
            else break;
      }

      IDMessage( getDeviceName(), "Nfocus position recovered resuming normal operation");
      /* We have to leave here, because new_apos is not set */
      return IPS_ALERT;
    }


    return IPS_OK;
}
Ejemplo n.º 22
0
bool QFW::Handshake()
{
    if (isSimulation())
    {
        IDMessage(getDeviceName(), "Simulation: connected");
        PortFD = 1;
        return true;
    }
    // check serial connection
    if (PortFD < 0 || isatty(PortFD) == 0)
    {
        IDMessage(getDeviceName(), "Device /dev/ttyACM0 is not available\n");
        return false;
    }
    // read description
    char cmd[10] = {"SN\r\n"};
    char resp[255]={0};
    if (send_command(PortFD, cmd, resp) < 2)
        return false;

    // SN should respond SN<number>, this identifies a Quantum wheel
    return strncmp(cmd, resp, 2) == 0;
}
Ejemplo n.º 23
0
bool AAGCloudWatcher::Disconnect() {
  if (cwc != NULL) {
    resetData();
    resetConstants();

    cwc->setPWMDutyCycle(1);

    delete cwc;

    cwc = NULL;

    IDMessage(getDefaultName(), "Disconnected from AAG Cloud Watcher\n");
  }
  return true;
}
Ejemplo n.º 24
0
bool IndiRpialtimu::Connect()
{
	//  using RTIMULib here allows it to use the .ini file generated by RTIMULibDemo.
	RTIMUSettings *settings = new RTIMUSettings("RTIMULib");

	imu = RTIMU::createIMU(settings);
	pressure = RTPressure::createPressure(settings);

	if ((imu == NULL) || (imu->IMUType() == RTIMU_TYPE_NULL)) {
		IDMessage(getDeviceName(), "Astroberry AltIMU fatal error - no IMU found.");
		return false;
	}

	//  This is an opportunity to manually override any settings before the call IMUInit

	//  set up IMU
	if (!imu->IMUInit())
	{
		IDMessage(getDeviceName(), "Astroberry AltIMU fatal error - problem initiating IMU.");
		return false;
	}

    //  set up pressure sensor
    if (pressure != NULL)
        pressure->pressureInit();

    //  set up for rate timer
    rateTimer = displayTimer = RTMath::currentUSecsSinceEpoch();

	// first timer run @1/100 recommended sampling rate
    SetTimer ( imu->IMUGetPollInterval() * 100 );
	
    IDMessage(getDeviceName(), "Astroberry AltIMU connected successfully.");
        	
    return true;
}
Ejemplo n.º 25
0
/**************************************************************************************
** Get the Data
***************************************************************************************/
void RadioSim::grabData()
{
	int to_read;
	int len = static_cast<int>RESOLUTION_PX(DishSize);
	double val = 0;
	int x = static_cast<int>(Ra * IMAGE_WIDTH / FOV_DEG);
	int y = static_cast<int>(Dec * IMAGE_HEIGHT / FOV_DEG);
	PrimaryDetector.setContinuumBufferSize(1);
	continuum = PrimaryDetector.getContinuumBuffer();
	for(to_read = 0; to_read < len && x + to_read < IMAGE_WIDTH; to_read++)
		val += MagickImage[x + (y * IMAGE_WIDTH) + to_read];
	continuum[0] = static_cast<unsigned char>(val / (to_read));
	IDMessage (getDeviceName(), "value: %d", continuum[0]);

	LOG_INFO("Download complete.");

	// Let INDI::Detector know we're done filling the data buffers
	CaptureComplete(&PrimaryDetector);
}
Ejemplo n.º 26
0
void ISGetProperties(const char *dev)
{
    ATIK_CCD_ISInit();

    if (iAvailableCamerasCount == 0)
    {
        IDMessage(nullptr, "No Atik cameras detected. Power on?");
        return;
    }

    for (int i = 0; i < iAvailableCamerasCount; i++)
    {
        ATIKCCD *camera = cameras[i];
        if (dev == nullptr || !strcmp(dev, camera->name))
        {
            camera->ISGetProperties(dev);
            if (dev != nullptr)
                break;
        }
    }
}
Ejemplo n.º 27
0
void ISGetProperties(const char *dev)
{
    ISInit();

    if (cameraCount == 0)
    {
        IDMessage(nullptr, "No Moravian cameras detected. Power on?");
        return;
    }

    for (int i = 0; i < cameraCount; i++)
    {
        MICCD *camera = cameras[i];
        if (!dev || !strcmp(dev, camera->name))
        {
            camera->ISGetProperties(dev);
            if (dev)
                break;
        }
    }
}
Ejemplo n.º 28
0
IPState FocusSim::MoveFocuser(FocusDirection dir, int speed, uint16_t duration)
{
    double targetTicks = (speed * duration) / (FocusSpeedN[0].max * FocusTimerN[0].max);
    double plannedTicks=ticks;
    double plannedAbsPos=0;

    if (dir == FOCUS_INWARD)
        plannedTicks -= targetTicks;
    else
        plannedTicks += targetTicks;

    if (isDebug())
        IDLog("Current ticks: %g - target Ticks: %g, plannedTicks %g\n", ticks, targetTicks, plannedTicks);

    plannedAbsPos = (plannedTicks - initTicks) * 5000 + (FocusAbsPosN[0].max - FocusAbsPosN[0].min)/2;

    if (plannedAbsPos < FocusAbsPosN[0].min || plannedAbsPos > FocusAbsPosN[0].max)
    {
        IDMessage(getDeviceName(), "Error, requested position is out of range.");
        return IPS_ALERT;
    }

    ticks = plannedTicks;
    if (isDebug())
          IDLog("Current absolute position: %g, current ticks is %g\n", plannedAbsPos, ticks);


    FWHMN[0].value = 0.5625*ticks*ticks +  SeeingN[0].value;
    FocusAbsPosN[0].value = plannedAbsPos;


    if (FWHMN[0].value < SeeingN[0].value)
        FWHMN[0].value = SeeingN[0].value;

    IDSetNumber(&FWHMNP, NULL);
    IDSetNumber(&FocusAbsPosNP, NULL);

    return IPS_OK;

}
Ejemplo n.º 29
0
int NFocus::updateNFPositionRelativeInward(double *value)
{

  char rf_cmd[32] ;
  int ret_read_tmp ;
  float temp ;
  int cont = 1;
  rf_cmd[0]= 0 ;

  int newval = (int)(currentInOutScalar * (*value));
  IDMessage(getDeviceName(),"Moving %d real steps but virtually counting %.0f\n",newval,*value);

  do {
    if ( newval > 999) { 
        strncpy(rf_cmd, ":F01999#\0", 9) ;
      newval -= 999;
    } else if(newval > 99) {
      snprintf( rf_cmd, 32, ":F01%3d#", (int) newval) ;
      newval = 0;
    } else if(newval > 9) {
      snprintf( rf_cmd, 32, ":F010%2d#", (int) newval) ;
      newval = 0;
    } else {
      snprintf( rf_cmd, 32, ":F0100%1d#", (int) newval) ;
      newval = 0;
    }
  
    if ((ret_read_tmp= SendCommand( rf_cmd)) < 0)
      return ret_read_tmp;
    
    do {
     strncpy(rf_cmd, "S\0", 2);
     if ((ret_read_tmp= SendRequest( rf_cmd)) < 0)
       return ret_read_tmp;
    } while ( (int)atoi(rf_cmd) );
  } while ( newval > 0 );
  
  currentPosition -= *value;
  return 0;
}
Ejemplo n.º 30
0
bool SynscanMount::Park()
{
    char str[20];
    int numread, bytesWritten, bytesRead;


    memset(str,0,3);
    tty_write(PortFD,"Ka",2, &bytesWritten);  //  test for an echo
    tty_read(PortFD,str,2,2, &bytesRead);  //  Read 2 bytes of response
    if(str[1] != '#')
    {
        //  this is not a correct echo
        //  so we are not talking to a mount properly
        return false;
    }
    //  Now we stop tracking
    tty_write(PortFD,"T0",2, &bytesWritten);
    numread=tty_read(PortFD,str,1,60, &bytesRead);
    if (bytesRead!=1||str[0]!='#')
    {
        if (isDebug())
            IDLog("Timeout waiting for scope to stop tracking.");
        return false;
    }

    //sprintf((char *)str,"b%08X,%08X",0x0,0x40000000);
    tty_write(PortFD,"B0000,4000",10, &bytesWritten);
    numread=tty_read(PortFD,str,1,60, &bytesRead);
    if (bytesRead!=1||str[0]!='#')
    {
        if (isDebug())
            IDLog("Timeout waiting for scope to respond to park.");
        return false;
    }

    TrackState=SCOPE_PARKING;
    IDMessage(getDeviceName(),"Parking Telescope...");
    return true;
}