Here is a 3D version with color specrogram showing th ~2.6 days period and the emission evolution:
Substracting the first spectrum, this similar graph focus on the emission only:
dimanche 3 novembre 2019
V442 And ouburst - another update
Almost a month after outburst discovery, here is a graph showing the evolution of the emission ine using my own spectra but also several from BeSS database thanks to all observers:
Here is a 3D version with color specrogram showing th ~2.6 days period and the emission evolution:
Substracting the first spectrum, this similar graph focus on the emission only:
Here is a 3D version with color specrogram showing th ~2.6 days period and the emission evolution:
Substracting the first spectrum, this similar graph focus on the emission only:
samedi 26 octobre 2019
V442 And outburst update
Here is an update of all graphs showing evolution of V442 And ourburst using BeSS spectra including my owns.
dimanche 6 octobre 2019
V442 And (again, again, again!) in outburst
V442 And is again in ourburst. Here is a comparison between a spectrum taken the night of october 5th compared to the one taken a week before.
It is great as TESS (a satelite surveying the sky for exoplanets transits) will observe it starting next week.
It is great as TESS (a satelite surveying the sky for exoplanets transits) will observe it starting next week.
Observatory in the morning after outburst discovery...
Spectrogram with BeSS spectra until oct 18th: 2.6 days period is visible as well as an increase of the emission (first spectrum substracted so only emission is shown here)
mercredi 14 août 2019
PRISM trick: display Be stars in skymap window
PRISM has a very important feature for those interested in Be stars: the bright Be stars from Be Star Spectra database are available in just few clicks.
First use the "Object to observe" feature which allow to manage a lit of targets. You can of course create your own list easily.
Once you open this module in PRISM, you can actually download the BeSS star spectra top list directly from the web:
Make sure to click the option to display the "list number". This list number is a way to have different types of objects in your target list; for BeSS stars, this is used to give the priority for observtion. L1 mens it is urgent to observe, L2 is that it would be nice to observe, and L3 that it is not mandatory to observe.
Then refresh your sky chart in PRISM and you will see those targets displayed in a specific color wth the list number (ie: priority) attached to it; in this exemple most of them are L3 but 25 Cyg and 28 Cyg are urgent to observe:
First use the "Object to observe" feature which allow to manage a lit of targets. You can of course create your own list easily.
Once you open this module in PRISM, you can actually download the BeSS star spectra top list directly from the web:
Make sure to click the option to display the "list number". This list number is a way to have different types of objects in your target list; for BeSS stars, this is used to give the priority for observtion. L1 mens it is urgent to observe, L2 is that it would be nice to observe, and L3 that it is not mandatory to observe.
Then refresh your sky chart in PRISM and you will see those targets displayed in a specific color wth the list number (ie: priority) attached to it; in this exemple most of them are L3 but 25 Cyg and 28 Cyg are urgent to observe:
PRISM trick: magnifying glass
There is a very nice feature in PRISM which magnifies part of your image. This magnifying glass is very seful to check on the guided star and how it "fits" within the fiber tip (fiber fed echelle spectrograph) or a slit of a slit-spectrograph.
The consign (lock position) can be adjusted at sub-pixel value even when autoguiding is ON - a great functionnality for astronomical spectroscopical acquisition!
The consign (lock position) can be adjusted at sub-pixel value even when autoguiding is ON - a great functionnality for astronomical spectroscopical acquisition!
lundi 5 août 2019
OHP 2019 Spectro Star Party
15th spectro star party at OHP took place august 2-7, 2019. Here are some groupe pictures (images by Olivier Garde & Valérie Desnoux):
At the same time I have been starting and monitoring my semi-autoated observations at home... but in the 1.2m dome at OHP! :
Small meteor recorded on august 5th around 2h18 UT:
At the same time I have been starting and monitoring my semi-autoated observations at home... but in the 1.2m dome at OHP! :
Small meteor recorded on august 5th around 2h18 UT:
Visit at OBE - Jim Edlin
Just before going together to OHP spectroscopy workshop, Jim Edlin visited my home and backyard observatory. Got lucky on th first night with fully automated observations.
samedi 27 juillet 2019
Semi-automated Be star spectra acquisition
I have been acquiring Be star spectra in a semi-automated way using PRISM v10 and its scripting capabilities. Here are some more details on how this works.
Main equipment is a C11 telescope on a Losmandy Titan mount with Gemini II controler. I recently updated it from Gemini I (and from origonal motors to Maxxon ones) - a huge improvement in pointing accuacy.
I connect in PRISM using ASCOM driver but connect to POTH (Ascom hub) from PRISM and setup the Gemini.Net within POTH; this seems more stable and works fine.
Here are my parameters for the Gemini.Net:
Here are some function I use in the script to control telescope:
CONNECT_OBSERVATORY Valid : connect telescope/dome
STOPTELESCOPE : stop tracking
CLOSE_TELESCOPE_DEVICES
The telescope is installed in a 2.7m Pulsar dome; I have a Dome Tracker to control the dome and PRISM interface with it directly.
I use OPEN_DOME and CLOSE_DOME in my script. I also use "DOME_SET_CONTROL 1 1" to ensure the dome is always in synch with the telescope.
I have two GemBird computer controled power plugs so I can switch equipment ON/OFF by using the Power Manager software that comes with those; I just run as an external program in my script, a nice PRISM feature; for exemple:
EXECEXTERNAL "C:\Program Files\Power Manager\pm.exe" "-on -Device3 -DomeTracker"
For the (echelle, fiber fed) spectrograph, I use a Velmann board that is handled in PRISM as a switch. Here are the functions I use for this:
Switchdesired=1
GETSWITCH Switchdesired nbSwitches ArrayName ArrayState
SETSWITCH Port1 ON
The script starts with a begining sequence that wait for the Sun's elevation; when right, it connects to the equipment, cool off the main CCD camera, runs the calibration and then starts the observing sequence. At the end, I just close equipment and dome.
To find my next target (which is repeated all night), I use a catalog of Be stars that I create in an Open Office Calc. It uses a robot file created every night in BESS database (through ARASBeAm website) that list for each Be star when it was last observed and what is the expected observing period (usually 365 days). I calculate from this a BESS priority but add my own priority too.
The catalog only list ~200 objects which are bright and isolated as my strategy is to center the brightest object in the guiding camera.
The guiding camera is a Zwo ASI174MM (a recent update from my old Atik Titan which I had lot of trouble with specially with latest Atik drivers). The field of view is great and it works very well.
To find the brightest object, I acquire an image, save it in FITS and JPEG format, bin the image 4x4 and look for brightest star:
StartExposure_EX 1 GExpTimeChamp
WaitForEndExposure_EX 1
GetLastImageExposure_EX 1 ImgChampToCenter
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_tocenter.fits"
SAVEFIT ImgChampToCenter sFullPath$
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_tocenter.jpg"
SAVEJPG ImgChampToCenter sFullPath$
BinX=4
BinY=BinX
BINNINGREDUCE ImgChampToCenter BinX BinY
BRIGHTEST_STAR ImgChampToCenter MinDynamiqueAutoguidage MaxDynamique MaxOmC PSFMin DemLargFenCentro ZoneRecherche XGuideCentro YGuideCentro
I had hard time to find the right parameters. I bin so the star are not too large and so the running time is acceptable. The MaxOmC parameter can be found when doing a centroid on an image; having it too low reject some actual stars; I use 2000 as a value now and it works.
To center the brightest star, I calculate the shift in RA/DEC. If it is close enough to the fiber ole I just start the autoguiding but if not I recalculate RA/DEC so repointing the target to recenter it.
MOVETELESCOPE AlphaNew DeltaNew
WAITFORENDMOVETELESCOPE
There seems to be a bug in Gemini.Net ASCOM because if I ask for a GoTo to the same position I ask before, it fails and goes wild. SO I have a two steps approach by pointing a position close to my target and do a second GoTo after. Even for recentering the object I am doing this two steps approach and it works.
Autoguiding is run with a single function, autoguiding needs to be predefined before in PRISM:
STARTGUIDECONSIGNE NumCam CCDNum GExpTimeBis DelayACQSec WindowSize CentroSize StarThresADU AgressRA AgressDEC RaMin RaMax DecMin DecMax Backlash CurrentDEC AlarmEnabled DeltaMoveFashion GuidePosX GuidePosY SaveImagettes DirSaveImg$ AllFrame WindowAllFrame Valid message$
Note that I am checking the hour angle, so the distance to meridian in order to stop my acquisition sequence before I cross the meridian too far.
I also run some statistics on each raw spectra image to avoid saturation and allow night to night comparison. Those are displayed and saved in a log file as well.
At the end of the target acquisition, I recalibrate the telescope on the object coordinates as it moved during the autoguiding sequence:
CALIBRATE_TELESCOPE alpha delta
Here is a link to a Youtube video taken during a full session. No comment but you can follow the observation as it progress...
Here is my current code which you can of course freely use for your own private use:
And the catalog that I use (just the first lines):
Main equipment is a C11 telescope on a Losmandy Titan mount with Gemini II controler. I recently updated it from Gemini I (and from origonal motors to Maxxon ones) - a huge improvement in pointing accuacy.
I connect in PRISM using ASCOM driver but connect to POTH (Ascom hub) from PRISM and setup the Gemini.Net within POTH; this seems more stable and works fine.
Here are my parameters for the Gemini.Net:
Here are some function I use in the script to control telescope:
CONNECT_OBSERVATORY Valid : connect telescope/dome
STOPTELESCOPE : stop tracking
CLOSE_TELESCOPE_DEVICES
The telescope is installed in a 2.7m Pulsar dome; I have a Dome Tracker to control the dome and PRISM interface with it directly.
I use OPEN_DOME and CLOSE_DOME in my script. I also use "DOME_SET_CONTROL 1 1" to ensure the dome is always in synch with the telescope.
I have two GemBird computer controled power plugs so I can switch equipment ON/OFF by using the Power Manager software that comes with those; I just run as an external program in my script, a nice PRISM feature; for exemple:
EXECEXTERNAL "C:\Program Files\Power Manager\pm.exe" "-on -Device3 -DomeTracker"
For the (echelle, fiber fed) spectrograph, I use a Velmann board that is handled in PRISM as a switch. Here are the functions I use for this:
Switchdesired=1
GETSWITCH Switchdesired nbSwitches ArrayName ArrayState
SETSWITCH Port1 ON
The script starts with a begining sequence that wait for the Sun's elevation; when right, it connects to the equipment, cool off the main CCD camera, runs the calibration and then starts the observing sequence. At the end, I just close equipment and dome.
To find my next target (which is repeated all night), I use a catalog of Be stars that I create in an Open Office Calc. It uses a robot file created every night in BESS database (through ARASBeAm website) that list for each Be star when it was last observed and what is the expected observing period (usually 365 days). I calculate from this a BESS priority but add my own priority too.
The catalog only list ~200 objects which are bright and isolated as my strategy is to center the brightest object in the guiding camera.
The guiding camera is a Zwo ASI174MM (a recent update from my old Atik Titan which I had lot of trouble with specially with latest Atik drivers). The field of view is great and it works very well.
To find the brightest object, I acquire an image, save it in FITS and JPEG format, bin the image 4x4 and look for brightest star:
StartExposure_EX 1 GExpTimeChamp
WaitForEndExposure_EX 1
GetLastImageExposure_EX 1 ImgChampToCenter
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_tocenter.fits"
SAVEFIT ImgChampToCenter sFullPath$
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_tocenter.jpg"
SAVEJPG ImgChampToCenter sFullPath$
BinX=4
BinY=BinX
BINNINGREDUCE ImgChampToCenter BinX BinY
BRIGHTEST_STAR ImgChampToCenter MinDynamiqueAutoguidage MaxDynamique MaxOmC PSFMin DemLargFenCentro ZoneRecherche XGuideCentro YGuideCentro
I had hard time to find the right parameters. I bin so the star are not too large and so the running time is acceptable. The MaxOmC parameter can be found when doing a centroid on an image; having it too low reject some actual stars; I use 2000 as a value now and it works.
To center the brightest star, I calculate the shift in RA/DEC. If it is close enough to the fiber ole I just start the autoguiding but if not I recalculate RA/DEC so repointing the target to recenter it.
MOVETELESCOPE AlphaNew DeltaNew
WAITFORENDMOVETELESCOPE
There seems to be a bug in Gemini.Net ASCOM because if I ask for a GoTo to the same position I ask before, it fails and goes wild. SO I have a two steps approach by pointing a position close to my target and do a second GoTo after. Even for recentering the object I am doing this two steps approach and it works.
Autoguiding is run with a single function, autoguiding needs to be predefined before in PRISM:
STARTGUIDECONSIGNE NumCam CCDNum GExpTimeBis DelayACQSec WindowSize CentroSize StarThresADU AgressRA AgressDEC RaMin RaMax DecMin DecMax Backlash CurrentDEC AlarmEnabled DeltaMoveFashion GuidePosX GuidePosY SaveImagettes DirSaveImg$ AllFrame WindowAllFrame Valid message$
Note that I am checking the hour angle, so the distance to meridian in order to stop my acquisition sequence before I cross the meridian too far.
I also run some statistics on each raw spectra image to avoid saturation and allow night to night comparison. Those are displayed and saved in a log file as well.
At the end of the target acquisition, I recalibrate the telescope on the object coordinates as it moved during the autoguiding sequence:
CALIBRATE_TELESCOPE alpha delta
Here is a link to a Youtube video taken during a full session. No comment but you can follow the observation as it progress...
Here is my current code which you can of course freely use for your own private use:
/////////////////////////////////////////////////////////////////////////////////
// //
// OTZ_Auto - Script to observe automatically (c) Olivier Thizy //
// //
/////////////////////////////////////////////////////////////////////////////////
//
// Some specificities to equipment used:
// -Losmandy Titan mount (upgraded witrh Maxxon motors & Germini 2 in 2019)
// Connected through Gemini.Net + POTH (mandatory for PRISM to work properly) with 2.5sec regular readout (idem)
// -echelle spectrograph with Velmann board to control calibration lamps
// -observing bright Be star as primary (only!) focus
// -Atik 460ex for spectra acquisition
// -Zwo ASI174MM (was Atik Titan) for guiding
// -Dome (controled by Dome Tracker)
// -RoboFocus
//
// Brief description of the algorythm:
// -I wait for the Sun to be below some limit (bsed on experience)
// -First I create my night's directory, copy/paste my usual CALIB files (master darks, current version of script...).
// -I connect my equipment (note that I usually switch my Power Manager ON manually because it's not stable,
// I also connect my cameras and my telescope manually because PRISM/ASCOM seems to be unstable there.
// -I lower the temperature of the main camera and wait for the Sun to be at a certain elevation.
// -I acquire (if necessary) my calibration frames for the night: a long serie of Tungsten for the blaze of the echelle spectrum,
// three LED to get the geometry of the echelle orders and three Thorium-Argon for wavelength calibration
// -I wait for th Sun's elevation to be at the level that allow observation to start
// -I load my catalog file which is created by an Excel spreadsheet where I import BeSS robot file;
// in a nutshell, the catalog file lists my ~200 Be stars targets with catalog name for PRISM to use, magnitude
// (used to calculate the guiding exposure time), the BeSS priority based on required observing period and last observation date
// (I also take into account if I have observed it myself as BeSS takes time to be validated/updated sometimes),
// a bonus priority for my favorite targets or current hot targets, individual exposure time and number of exposure to acquire.
// -Then I enter a loop for the night:
// >based on telescope position, and excluding targets below minimum elevation (40°), crossing the meridien at mid exposure
// (I always observe in the East part of the sky) and below a DEC limit (just because my pointing accuracy there is lower),
// I select my next target (of course, one that has not been observed that night so far)
// >I point the telescope to the target, wait for the dome, center target (brightest star) and then start the autoguiding
// (if no star is found, I try an astrometry and if not possible then I wait 5min with telescope tracking stopped)
// >then I start the exposure until the target is crossing the meridian or I reach the required number of exposures
// or if the Sun elevation if above the limit to end the observations --> then I go to the end of Session
// >and I loop to go to the next target...
// -End of Session: I stop telescope, I close the dome, I increase the temperature of the main camera, I close all equipment
//
// After a session, I reduce all my spectra using ISIS, the clean up all the intermediate files, create an archive and a ZIP file with
// all my spectra to upload them in BeSS database... and I wait until the sky is clear for next session!
// BUGS / ROBUSTNESS (TO DO)
// ------------------
// -improve mechanical holder for the dome sensor (ie: spring to be improved)
// -Goto with WaitForDome option failed sometimes: removed from script for now / to be checked
// -replace USB by LAN gembird: hardware ready when needed, not critical for now
// -pb with telescope connexion (hardware?): done manually for now, to check again ?
// -pb with Zwo ASI that sometimes freeze (USB link to improve?)
//
// WEATHER MANAGEMENT (TO DO)
// -------------------
// -rain detection -> wiring to dome tracker + software test to stop telescope & close everything else
// -calibrate Sentinel cloud sensor: seems very difficult to find the righ parameters, need more work on this
// -wait for good weather: tested but failed; need to be improved
// -check weather: pause
// -multiple pause: close equipment
// -sentinel relay script activation
//
// IMPROVEMENTS (TO DO)
// -------------
// -when a target not found, skip it (could try later? limit to 3 retries total?)
// -add list of targets done during last few nights to add to BeSS priority calculation (to limit same target several nights)
// -automated ISIS data reduction with Actiona external tool
// -at the end creates a simple web page with guiding image, last ARASBeAm spectrum graph and our Halpha graph
// -catalog of bright isolated stars or astrometry on the field
// -goto with star hopping or astrometry on the field
// -improve simulator mode to take into account elevation & distance to meridian at time of observation (targets.txt mode)
// -add management of star to Synch at the end of a session to "park" scope
// -split start & calib & directory setup
// -search for object$ to avoid local/global variables
// -add the ability to do calibration at the end in case weather is bad at the beginning of the session
// -check disc space at the beginning
// -add to the ARASBeAm priority calculation my own observations (not validated in BeSS yet) to avoid always doing the same targets
// -add fainter target with an astrometry mode
//
// REVISION HISTORY (WHAT HAS BEEN DONE)
// ----------------
// -05/08/2018: first "stable version", target list inside script, some bugs (telescope connexion, USB Gembird, first autoguiding).
// Lack weather management, good target catalog, star hopping method for large GoTo, etc... some comments in french.
// Based on brightest star in the field, very specific to my own equipment. 60 Be stars spectra (Halpha) acquired so far with the script.
// -15/08/2018: add printed info when star lower than HauteurMin; read targets from an external text file; simulation & total exposure time calculation
// Some functions to read a Be star catalog with BeSS priorities, my own priorities & calculate a weight to sort stars by interest. Seems to work ok.
// -19/08/2018: fix of the displayed hor angle (calculated on target and not from telescope position)
// -09/09/2018: automatic check if calibration is done; simulation removed (always done, user can stop script if he wants),
// calibration, goTo and download time added in time for session calculation, directory naming/creation done at beginning
// -15/09/2018: first test of automatic target finding based on catalog file (BeSS priorities still manual),
// elevation of the Sun calculated for end of acquisition (not begining), if object$ is not recognize: skip target,
// automatic guiding exposure based on Vmag, automatic scheduling based on priority & time allocation
// -17/09/2018: correct end of night bug with Sun's elevation calculation on limit hour angle calculation
// -27/09/2018: fixed starDeltaRA calculation when telescope close to 24h, fixed AngleHor calculation in CheckStarCatalogForVisibility
// -07/10/2018: fixed end of observersion date and add DateFrac test (Sun elevation after midnight!)
// -09/10/2018: improve stop observing time Vs begin time to avoid trying to observe too late...
// -23/10/2018: limites après méridien fortement diminuée pour éviter les pertes de GoTo
// -15/02/2019: alphaplus=alpha+0.005 (au lieu de -0.005 avant) pour améliorer le pointage
// -02/06/2019: modifications following Gemini 2 upgrade; no pointing model in Gemioni 2 or PRISM for now...
// -03/06/2019: adding AskForManualAutoGuiding option as it doens't work in PRISM with new ATIK drivers !!!
// Removing of recentering of the brightest object in the field as it doesn't work anymore in PRISM with latest update :-(
// -16/06/2019: replacing Atik Titan by Zwo ASI 178MC guiding camera
// -22/06/2019: replacing guiding camera by a Zwo ASI 174MM, added several comments & cleaning the script file
// -23/06/2019: added SHIFT_TELESCOPE to recenter the target and it works!!!
// -24/06/2019: added a two steps approach for GoTo & reecentering (due to a bug in PRISM/POTH/Gemini.Net chain somewhere...)
// Add couple of log files with stats
// -30/06/2019: switched to OTH_Catalog2 with MyName added (target list name with spaces). Checked several bugs that I can remove:
// >sometimes fails at first autoguiding, root cause not found yet, didn't happend with Zwo ASI174 so ok...
// >end of night, dome disconnected? didn't happend for long time now? seems OK...
// >at end of the night it doesn't stop early enough, need to revisit how scheduler works: better since early 2019 - ok...
// >sometimes it tries to go to a target but it is too close to meridian, loosing 5min each time (improved in eartly 2019) - ok...
// >stop telescope tracking while waiting for next target, done ok
// -07/07/2019: added an astrometry search in case target is not found (to be improved to gain time)
// >catalog file read for each target (so can be modified even when script is running)
// >if star is already close to the fiber hole, no need to recenter it so skiping it then
// -13/07/2019: BINNINGREDUCE (instead of SCALE) 4x4 for BRIGHTEST_STAR
// >add FIND_ALLSKY_POSITION (with binning 2x2) when star not found
// -14/07/2019: Move astrometry search at beginning of each target GoTo
// -17/07/2019: move back to brightest star in the field as astrometry isn't reliable yet... Pb with Gemini.Net more than PRISM scripts at the moment...
//
//
/////////////////////////////////////////////////////////////////////////////////
print "OTZ_Auto: (semi)automatic observation script (c) Olivier Thizy"
print "Version of 17/07/2019"
// Key debug/temporary parameters to control manual interventions...
// Note: for full automated observations all parameters should be to FALSE except ExposureCloudFactor which should be 1.0 (1.6 works fine too)
TRUE=1
FALSE=0
// ExposureCloudFactor: set to 1.4 but increase up to 3.0 if sky is cloudy (will increase guiding image exposure time)
ExposureCloudFactor=2.0
// CheckIfPowerManagerIsOK: set to TRUE to make a double check of the Power Manager as USB isn't always working properly
CheckIfPowerManagerIsOK=FALSE
// ConnectTelescopeManually: set to TRUE if you want to connect manually telescope/equipment in prism
ConnectTelescopeManually=FALSE
// RequestManualInitialSynch: set to TRUE if you want to manually synch telescope to first star
RequestManualInitialSynch=FALSE
// UseTargetFile: set to TRUE to use targets.txt file for the targets; otherwise script will use catalog to find automatically next target
UseTargetFile=FALSE
// SkipCalibration: set to TRUE if you do not want to look for calibration frames (and acquire them), alternative is to have a dummy "ref_thor-3.fits" file
SkipCalibration=FALSE
// AskForManualAutoGuiding: set to TRUE if you want to start & end autoguiding manually
AskForManualAutoGuiding=FALSE
// Allow for astrometry calibration to reynch in case star not found ?
AllowAstrometry=FALSE
// OpenDomeManually: Set to TRUE if you want to open dome manually (to make sure weather is OK when ready for observations)
OpenDomeManually=TRUE
//
// General parameters
//
TWOPI=2*PI
// do not point telescope past meridian
AngleHorMin=0
// minimum elevation = do not observe below... (in °); usually 40° for me
HauteurMin=45
// Maximum distance for next target (in degrees)
MaximumStarDistanceToTelescope=45.0
// Maximum DEC for targets
MaximumStarDEC=48
// parameters for guiding camera ASI174MM:
// fiber position
GuidePosX=897.5
GuidePosY=541.7
// image will be reduce by 4 in each axis to do the search for brightest star (speed up processing time)
Facteur=0.25
GuidePosXFact=897.5*Facteur
GuidePosYFact=541.7*Facteur
// scale for the pixel size, important to adjust the RA/DEC shift to center target to the fiber tip
EchelleXFact=0.46311/Facteur
EchelleYFact=EchelleXFact
EchelleXFactAstro=0.46311*2
EchelleYFactAstro=EchelleXFactAstro
MinDynamiqueAutoguidage=700
MaxDynamique=65000
// max Observed Minus Calculated, see result when doing manual centroid, usually MaxOMC=2000 works better than 900...
MaxOmC=2000
PSFMin=2
// not sure if I need to *Facteur there or not...
DemLargFenCentro=28
ZoneRecherche=DemLargFenCentro+1
// for ASI174MM in full frame bin 1x1 (image : 1936x1216)
GuidingExpFactor=2
GuidingDelayACQSec=10
GuidingCentroSize=25
GuidingStarThresADU=100
GuideXMax_2=200
// For astrometry search...
GExpTimeAstrometryChamp=45000
CatalogAst$="UCAC 2/3/4"
ChemCatalogAst$="D:\UCAC4\u4b\"
MaxStarImg=40
MaxStarCat=120
FieldAllSky=1
// For Atik 460ex camera, cooling in 16 minutes to -10°C (winter) or 0°C (summer) seems enough
minutestogodowntotemp=16
Detectortemperature=0.0
// Elevation of the sun at which we start the instrumentation (degrees converted to radians)
// I usually start equipment when Sun is below 0°, start calibration when below 4° in order to start observing when below -8°
Summer=TRUE
Season=Summer
if Season=Summer then
elevsunstartinitnight_Deg=-2.0
elevsunstartbegnight_Deg=-5.0
elevsunstartobservations_Deg=-8.0
elevsunstopobservations_Deg=-11.0
elevsunstopgoto_Deg=-13.0
else
elevsunstartinitnight_Deg=-1.0
elevsunstartbegnight_Deg=-4.0
elevsunstartobservations_Deg=-9.0
elevsunstopobservations_Deg=-9.0
elevsunstopgoto_Deg=-11.0
endif
// CCD numbers
GuidingCamNumber=1
AcqCamNumber=2
// difference between local time and UT
deltaUT=-1
// time (in milliseconds) to wait after GoTo so dome can be synch' with telescope
if AskForManualAutoGuiding=TRUE then
WaitForDomeTime=5000
else
WaitForDomeTime=90000
endif
// Sentinel weather station parameters
LimitTempCiel=-100.0
LimitMagnitudeCiel=-100.0
ValMinBelleMeteo=5
// Root directory for acquisition. Contains CALIB with catalog files & directory will be created there for each new night
//RootDirName$="D:\Acquisitions\"
RootDirName$="C:\Users\ObsBE\Documents\Acquisitions\"
// Catalog filenames
StarCatalogFileName$=RootDirName$+"CALIB\OTH_Catalog2.txt"
// Log file where exposure results will be added
ObjectLog$=RootDirName$+"CALIB\elog_objects.txt"
StatsLog$=RootDirName$+"CALIB\elog_stats.txt"
// GoTo TestCatalogFunctions:
// Check if calibration has been done already or not
GoSub CalculateNightDate:
File$=sDirSave$+"ref_thor-3.fits"
FileExists File$ StartAndCalibDone
if UseTargetFile=TRUE then
// Reading Target list
Now Date
Datetostr Date Date$
print "[" Date$ "] Reading 'targets.txt' file"
DirTargetList$="C:\Users\ObsBE\Documents\Acquisitions\CALIB\targets.txt"
Open_FileTxt_For_Read ObjectTargetFile DirTargetList$
NbTargets=1
ReadFileTXT ObjectTargetFile Target[NbTargets]$
LoopObjectTargetList:
ENDOFFILE ObjectTargetFile resultat
if resultat=FALSE then
NbTargets=NbTargets+1
ReadFileTXT ObjectTargetFile Target[NbTargets]$
GoTo LoopObjectTargetList:
EndIf
// Simulation pf the session
TotalExpTimeForTargets=0
elevsunstartbegnight=elevsunstartbegnight_Deg/TODEG
// Search for date/time Sun is ok to start observation...
Step=0.002
Now DateSessionWillBegin
LoopSearchBegTime:
GETRADECSUN DateSessionWillBegin AlphaS DeltaS sunelevation
if sunelevation>elevsunstartbegnight
DateSessionWillBegin=DateSessionWillBegin+Step
else
goTo EndLoopSearchBegTime:
endif
goTo LoopSearchBegTime:
EndLoopSearchBegTime:
for NumeroObject=1 to NbTargets
Object$=Target[NumeroObject]$
GoSub LookUpObject:
// 240sec for GoTo sequence + 30sec par pose (download)
TotalExpTimeForSession=TotalExpTimeForSession+240+(ExpSec+30)*NbExposure
TotalExpTimeForTargets=TotalExpTimeForTargets+ExpSec*NbExposure
Now Date
Datetostr Date Date$
print NumeroObject "; " Object$ "; " ExpSec "; " NbExposure
next NumeroObject
str TotalExpTimeForTargets TotalExpTimeForTargets$
TotalExpTimeForTargetsMin=(TotalExpTimeForTargets/60)
round TotalExpTimeForTargetsMin TotalExpTimeForTargetsMin
str TotalExpTimeForTargetsMin TotalExpTimeForTargetsMin$
TotalExpTimeForTargetsHours=(TotalExpTimeForTargets/3660)
frac TotalExpTimeForTargetsHours TotalExpTimeForTargetsHoursM
TotalExpTimeForTargetsHoursM=TotalExpTimeForTargetsHoursM*60
round TotalExpTimeForTargetsHoursM TotalExpTimeForTargetsHoursM
TotalExpTimeForTargetsHoursH=TotalExpTimeForTargetsHours-TotalExpTimeForTargetsHoursM/60
round TotalExpTimeForTargetsHoursH TotalExpTimeForTargetsHoursH
str TotalExpTimeForTargetsHoursH TotalExpTimeForTargetsHoursH$
str TotalExpTimeForTargetsHoursM TotalExpTimeForTargetsHoursM$
if TotalExpTimeForTargetsHoursM=0
TotalExpTimeForTargetsHoursM$="00"
endif
if TotalExpTimeForTargetsHoursM<10
TotalExpTimeForTargetsHoursM$="0"+TotalExpTimeForTargetsHoursM$
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] Total Exposure should be: " TotalExpTimeForTargets$ " sec., " TotalExpTimeForTargetsMin$ " min., " TotalExpTimeForTargetsHoursH$ "h" TotalExpTimeForTargetsHoursM$ "."
str TotalExpTimeForSession TotalExpTimeForSession$
TotalExpTimeForSessionMin=(TotalExpTimeForSession/60)
round TotalExpTimeForSessionMin TotalExpTimeForSessionMin
str TotalExpTimeForSessionMin TotalExpTimeForSessionMin$
TotalExpTimeForSessionHours=(TotalExpTimeForSession/3660)
frac TotalExpTimeForSessionHours TotalExpTimeForSessionHoursM
TotalExpTimeForSessionHoursM=TotalExpTimeForSessionHoursM*60
round TotalExpTimeForSessionHoursM TotalExpTimeForSessionHoursM
TotalExpTimeForSessionHoursH=TotalExpTimeForSessionHours-TotalExpTimeForSessionHoursM/60
round TotalExpTimeForSessionHoursH TotalExpTimeForSessionHoursH
str TotalExpTimeForSessionHoursH TotalExpTimeForSessionHoursH$
str TotalExpTimeForSessionHoursM TotalExpTimeForSessionHoursM$
if TotalExpTimeForSessionHoursM=0
TotalExpTimeForSessionHoursM$="00"
endif
if TotalExpTimeForSessionHoursM<10
TotalExpTimeForSessionHoursM$="0"+TotalExpTimeForSessionHoursM$
endif
DateEndSession=DateSessionWillBegin+TotalExpTimeForSessionMin/(24*60)
Datetostr DateSessionWillBegin DateSessionWillBegin$
Datetostr DateEndSession DateEndSession$
print "[" Date$ "] Total session should be: " TotalExpTimeForSession$ " sec., " TotalExpTimeForSessionMin$ " min., " TotalExpTimeForSessionHoursH$ "h" TotalExpTimeForSessionHoursM$ "."
print "[" Date$ "] Session from " DateSessionWillBegin$ " to " DateEndSession$ " (UT)"
Input "WAIT for you to press enter before continuing the script" Dummy$
endif
//
// START & CALIBRATION
//
if StartAndCalibDone=FALSE then
Now Date
Datetostr Date Date$
print "[" Date$ "] Starting Calibration sequence"
GoSub Start_and_Calib:
else
Now Date
Datetostr Date Date$
print "[" Date$ "] Calibration sequence already done"
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] Starting observing sequence"
// Just to test it...
//GoSub BoucleAttendBeauTemp:
// Resynch telescope on delta Her
if RequestManualInitialSynch=1 then
Input "TEST: ensure telescope is synch (& focused ?) near to first target - then press ENTER" Dummy$
else
// Synch sequence for the beginning of the bight - todo
// look for a bright star near telecope position and/or astrometry.net ?
endif
if UseTargetFile=1 then
for NumeroObject=1 to NbTargets
Object$=Target[NumeroObject]$
if NbExposure<>0 then
GoSub TakeObject:
endif
next NumeroObject
else
// Each target will be found with minimum elevation & far enough from meridian
// using a score calculation based on distance to telescope, my own priority and BeSS priorities
// BeSS: Be Star Spectra database
NumeroObject=0
LoopAcquisitionOfTargets:
stoptelescope
Now Date
Datetostr Date Date$
print "[" Date$ "] Reading target star catalog"
GoSub ReadStarCatalog:
Now Date
Datetostr Date Date$
print "[" Date$ "] number of stars in the target list : " numberofstarsintargetlist
// Check Sun elevation before continuing observing next target...
GetStdrLongitude Longitude
GetStdrLatitude Latitude
elevsunstopgoto=elevsunstopgoto_Deg/TODEG
Now Date
GETRADECSUN Date AlphaS DeltaS sunelevation
FRAC Date DateFrac
if sunelevation>elevsunstopgoto
if DateFrac<0.5
Now Date
Datetostr Date Date$
print "[" Date$ "] Sun too high to continue observing"
GoTo EndOfSession:
endif
endif
// Reset sort order & look for next target (not done during the night and highest score)
for Temp_i=1 to numberofstarsintargetlist
sortIndex[Temp_i]=Temp_i
next Temp_i
Now Date
Datetostr Date Date$
print "[" Date$ "] Calculating telescope distance for all star in catalog"
GET_TELESCOPE_POSITION Alpha2000 Delta2000 Hauteur Azimuth AngleHor
RARef=24.0*Alpha2000/(2.0*PI)
DECRef=180*Delta2000/PI
GoSub CalculateDistanceStarCatalogToRef:
Now Date
Datetostr Date Date$
print "[" Date$ "] Checking visibility for all stars in catalog"
GoSub CheckStarCatalogForVisibility:
// Need to add here a function to check when the target has been acquired (cf StatsLog$) to overwrite BeSS priority based on my own observation
Now Date
Datetostr Date Date$
print "[" Date$ "] Sorting stars in catalog"
GoSub SortStarCatalog:
Now Date
Datetostr Date Date$
print "[" Date$ "] Looking for next target..."
GoSub CalculateNightDate:
HasATargetBeenFound=0
for Temp_i=1 to numberofstarsintargetlist
Temp_j=SortIndex[Temp_i]
Temp_Prio=SortCriteria[Temp_j]
// print "Prio=" Temp_Prio " starname number : " Temp_i " is : " starFileName[Temp_j]$ " star RA in decimal : " starRA[Temp_j] " star Dec in decimal : " starDec[Temp_j] " Vmag=" starVMag[Temp_j] " Guiding Exp Time=" starGuideExposureSec[Temp_j] " BeSS=" starWeightBeSS[Temp_j] " MyPrio=" starWeightOTH[Temp_j] " Distance=" starWeightDistance[Temp_j]
if Temp_Prio>0 then
File$=sDirSave$+starFileName[Temp_j]$+"-1.fits"
FileExists File$ TargetAlreadyAcquired
Now Date
Datetostr Date Date$
print "[" Date$ "] Target " File$ "Valid?=" TargetAlreadyAcquired
if TargetAlreadyAcquired=FALSE then
print "[" Date$ "] Target confirmed : " starFileName[Temp_j]$
NumeroObject=NumeroObject+1
Now Date
Datetostr Date Date$
print "[" Date$ "] Next target (#" NumeroObject ") : " starFileName[Temp_j]$ " RA=" starRA[Temp_j] " DEC=" starDec[Temp_j] " Vmag=" starVMag[Temp_j] " Guiding Exp Time=" starGuideExposureSec[Temp_j] " BeSS=" starWeightBeSS[Temp_j] " MyPrio=" starWeightOTH[Temp_j] " Distance=" starWeightDistance[Temp_j]
Object$=starFileName[Temp_j]$
objet$=starname[Temp_j]$
myObjectName$=myobjname[Temp_j]$
GExpTime=starGuideExposureSec[Temp_j]
ExpSec=starExpTimeSec[Temp_j]
NbExposure=starNbExposure[Temp_j]
GoSub GoToTargetAndAcquisition:
File$=sDirSave$+starFileName[Temp_j]$+"-1.fits"
FileExists File$ TargetAlreadyAcquired
if TargetAlreadyAcquired=FALSE then
Now Date
Datetostr Date Date$
print "[" Date$ "] Waiting 5min for a new target to come nearby..."
stoptelescope
DelayBlock 300000
endif
GoTo LoopAcquisitionOfTargets:
endif
endif
next Temp_i
Now Date
Datetostr Date Date$
print "[" Date$ "] No target found, waiting for 5min..."
DelayBlock 300000
GoTo LoopAcquisitionOfTargets:
endif
EndOfSession:
// END OF SESSION
print "-----------------------------------------------------------"
EquipmentClosed=0
// Synch on bet And first
GoSub IsSunStillBelow:
if SunStillBelow=1 then
// Add synchronisation on a star there is needed (not really needed anymore)
else
GoSub endnight:
GoTo EndOfMainSequence:
endif
// Synch on eta Psc then
GoSub IsSunStillBelow:
if SunStillBelow=1 then
// Add synchronisation on a star there is needed (not really needed anymore)
else
GoSub endnight:
GoTo EndOfMainSequence:
endif
FinishScriptHere:
GoSub endnight:
EndOfMainSequence:
// Et message de fin...
Now Date
Datetostr Date Date$
print "[" Date$ "] That's all folks..."
sOutput$=" "
Print sOutput$
sOutput$="DDD OOO N N EEEEE"
Print sOutput$
sOutput$="D D O O N N N E "
Print sOutput$
sOutput$="D D O O N N N EEE "
Print sOutput$
sOutput$="D D O O N NN E "
Print sOutput$
sOutput$="DDD OOO N N EEEEE"
Print sOutput$
sOutput$=" "
Print sOutput$
END
/////////////////////////////////////////////////////////////////////////////////
//
// Goto a target, center object, run autoguiding and acquire spectra
//
/////////////////////////////////////////////////////////////////////////////////
GoToTargetAndAcquisition:
print "-----------------------------------------------------------"
REM Coordonnées équatoriales de l'objet en radians
GETOBJECTCOORD objet$ alpha delta
if alpha=-100
Now Date
Datetostr Date Date$
print "[" Date$ "] Object " objet$ " is not recognized by PRISM !"
return
endif
str alpha alphaRad$
str delta deltaRad$
RAD_TO_RA alpha alpha$
RAD_TO_DEC delta delta$
Now Date
Datetostr Date Date$
PRINT "[" Date$ "] " Object$ " (" objet$ ") is at coordinates :"
PRINT "[" Date$ "] RA : " alpha$ " (" alphaRad$ " radians)"
PRINT "[" Date$ "] DEC : " delta$ " (" deltaRad$ " radians)"
//Longitude du lieu = celle du site par défaut
GETSTDRLONGITUDE Longitude
// Latitude du lieu
GETSTDRLATITUDE Latitude
// Loop to wait for the target to reach proper altitude in the sky
LoopWaitHauteur:
// Date du moment :
NOW Date
// Hauteur de l'objet en radian :
GETHEIGHT alpha delta Date Longitude Latitude Hauteur
// Hauteur en degrés
Hauteur=Hauteur*TODEG
if Hauteur<HauteurMin then
stoptelescope
Now Date
Datetostr Date Date$
print "[" Date$ "] Target too low, elevation at " Hauteur " target: " HauteurMin ")"
DelayBlock 300000
Goto LoopWaitHauteur:
endif
// Look for telescope position at the end of acquisition to check if not past meridian+limit / give 50% margin to allow half exposure...
// TSL pour calculer angle horaire
SIDERALTIME Date Longitude TSL
// Angle horaire objet en radian :
COMPUTEANGLEHOR TSL alpha AngleHor
//Angle horaire en heures décimales:
AngleHor=AngleHor*12/PI
AngleHorEndOfExposure=AngleHor+((ExpSec*NbExposure)/3600.0)/2.0
AngleHorLimit=0.0
// si DEC<45°: 10min supplémentaires
if delta<(45.0/180.*3.1415) then
AngleHorLimit=0.0/60.0
endif
// si DEC<30°: 20min supplémentaires -> 15min
if delta<(30.0/180.*3.1415) then
AngleHorLimit=0.0/60.0
endif
// si DEC<25°: 1h10 supplémentaires -> diminué à 20min par sécurité
if delta<(25.0/180.*3.1415) then
AngleHorLimit=0.0/60.0
endif
// si DEC<6°: 1h45 supplémentaires -> diminué à 30min par sécurité?
if delta<(6.0/180.*3.1415) then
AngleHorLimit=0.0/60.0
endif
if AngleHorEndOfExposure>AngleHorLimit
Now Date
Datetostr Date Date$
print "[" Date$ "] Target at mid sequence will be at hour angle: " AngleHorEndOfExposure " so target skipped"
return
endif
// Pointage ou non ?
If AngleHor<AngleHorMin then
If Hauteur>HauteurMin then
str Hauteur Hauteur$
Now Date
Datetostr Date Date$
print "[" Date$ "] GoTo Target at Elevation : " Hauteur$ "°"
WaitForDome=1
alphaplus=alpha+0.003
deltaplus=delta+0.003
if alphaplus>TwoPI then
alphaplus=alphaplus-2*PI
endif
MoveTelescope alphaplus deltaplus
WaitForEndMoveTelescope
DelayBlock WaitForDomeTime
alphaplus=alphaplus-0.003
deltaplus=deltaplus-0.003
if alphaplus<0 then
alphaplus=alphaplus+2*PI
endif
MoveTelescope alphaplus deltaplus
WaitForEndMoveTelescope
DelayBlock 10000
Else
Now Date
Datetostr Date Date$
print "[" Date$ "] Target too low"
return
EndIf
Else
Now Date
Datetostr Date Date$
print "[" Date$ "] Target too close to meridian"
return
EndIf
Now Date
Datetostr Date Date$
print "[" Date$ "] Telescope at target position now"
// Wait for the dome
//Now Date
//Datetostr Date Date$
//print "[" Date$ "] Waiting for the dome"
//DelayBlock WaitForDomeTime
//Now Date
//Datetostr Date Date$
//print "[" Date$ "] Dome should be at telescope position now"
GoSub CalculateNightDate:
// First do a long exposure and an astrometry to resynch telescope
if AllowAstrometry=TRUE then
Now Date
Datetostr Date Date$
print "[" Date$ "] Acquiring a long exposure and trying an astrometry first"
StartExposure_EX 1 GExpTimeAstrometryChamp
WaitForEndExposure_EX 1
GetLastImageExposure_EX 1 ImgChampToCenter
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_astrometry.fits"
SAVEFIT ImgChampToCenter sFullPath$
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_astrometry.jpg"
SAVEJPG ImgChampToCenter sFullPath$
BinX=2
BinY=BinX
BINNINGREDUCE ImgChampToCenter BinX BinY
FIND_ALLSKY_POSITION ImgChampToCenter MaxStarImg MaxStarCat FieldAllSky CatalogAst$ Valid
if Valid=TRUE then
GetAlpha ImgChampToCenter AD
GetDelta ImgChampToCenter DC
// STR DC DC$
// STR AD AD$
RAD_TO_RA AD AD$
RAD_TO_DEC DC DC$
Now Date
Datetostr Date Date$
print "[" Date$ "] Astrometry OK, resynchronizing telescope at RA=" AD$ ", DEC=" DC$
// Check if I was close enough to the target and GoTo again if necessary
DeltaADPixel=3600*180*(alpha-AD)/(PI*EchelleXFactAstro)
if DeltaADPixel<0 then
DeltaADPixel=-DeltaADPixel
endif
DeltaDCPixel=3600*180*(delta-DC)/(PI*EchelleYFactAstro)
if DeltaDCPixel<0 then
DeltaDCPixel=-DeltaDCPixel
endif
AmICloseEnough=FALSE
MarginMax=(GuideXMax_2-ZoneRecherche)
if DeltaADPixel<MarginMax then
if DeltaDCPixel<MarginMax then
AmICloseEnough=TRUE
endif
endif
STR DeltaADPixel DeltaADPixel$
STR DeltaDCPixel DeltaDCPixel$
if AmICloseEnough=TRUE then
Now Date
Datetostr Date Date$
print "[" Date$ "] Telescope close enough to target (dX=" DeltaADPixel$ ", dY=" DeltaDCPixel$ ") so skipping a new GoTo now"
else
Now Date
Datetostr Date Date$
print "[" Date$ "] Telescope too far from target (dX=" DeltaADPixel$ ", dY=" DeltaDCPixel$ ") / GoTo target again"
alphaplus=alpha+0.003
deltaplus=delta+0.003
if alphaplus>TwoPI then
alphaplus=alphaplus-2*PI
endif
MoveTelescope alphaplus deltaplus
WaitForEndMoveTelescope
DelayBlock 10000
alphaplus=alphaplus-0.003
deltaplus=deltaplus-0.003
if alphaplus<0 then
alphaplus=alphaplus+2*PI
endif
MoveTelescope alphaplus deltaplus
WaitForEndMoveTelescope
DelayBlock 10000
endif
else
Now Date
Datetostr Date Date$
print "[" Date$ "] Astrometry didn't work"
endif
CLOSE ImgChampToCenter
endif
// if AmICloseEnough=TRUE then
// Now Date
// Datetostr Date Date$
// print "[" Date$ "] and no need to search for brigthest star"
// else
// Centering the brightest star on the consign (fiber hole) position
GExpTimeMilSec=GExpTime*1000
GExpTimeChamp=GExpTimeMilSec*5
StartExposure_EX 1 GExpTimeChamp
WaitForEndExposure_EX 1
GetLastImageExposure_EX 1 ImgChampToCenter
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_tocenter.fits"
SAVEFIT ImgChampToCenter sFullPath$
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_tocenter.jpg"
SAVEJPG ImgChampToCenter sFullPath$
Now Date
Datetostr Date Date$
print "[" Date$ "] Looking for beightest star in the field"
BinX=4
BinY=BinX
BINNINGREDUCE ImgChampToCenter BinX BinY
// Alternative to limit number of stars to look for: BRIGHTEST_STAR2 Img SeuilMin SeuilMax OmC PSFMin DemiLargeur SearchField MaxPoints Xcentro Ycentro
BRIGHTEST_STAR ImgChampToCenter MinDynamiqueAutoguidage MaxDynamique MaxOmC PSFMin DemLargFenCentro ZoneRecherche XGuideCentro YGuideCentro
if YGuideCentro<0 then
XGuideCentro=-1
endif
if XGuideCentro<0 then
Now Date
Datetostr Date Date$
print "[" Date$ "] Star not found... Skipping target for now"
CLOSE ImgChampToCenter
return
endif
str XGuideCentro XStar$
str YGuideCentro YStar$
Now Date
Datetostr Date Date$
print "[" Date$ "] Star found at position (taking into account 'Facteur') " XStar$ ", " YStar$
str GuidePosXFact GuidePosX$
str GuidePosYFact GuidePosY$
// margin (GuideXMax_2-ZoneRecherche)
MarginX=(GuidePosXFact-XGuideCentro)
MarginY=(GuidePosYFact-YGuideCentro)
if MarginX<0 then
MarginX=0-MarginX
endif
if MarginY<0 then
MarginY=0-MarginY
endif
if MarginX<MarginY then
Margin=MarginY/Facteur
else
Margin=MarginX/Facteur
endif
MarginMax=(GuideXMax_2-ZoneRecherche)
if Margin<MarginMax then
Now Date
Datetostr Date Date$
print "[" Date$ "] Taget close to fiber, no need to center it and go to autoguiding directly"
else
Now Date
Datetostr Date Date$
print "[" Date$ "] Centering at Fiber position at (incl. Facteur) " GuidePosX$ ", " GuidePosY$
// OFFSET_TELESCOPE ImgChampToCenter XGuideCentro YGuideCentro GuidePosX GuidePosYDecale
GET_TELESCOPE_POSITION RA2000 DEC2000 Haut Azi AHor
// str RA2000 RA$
// str DEC2000 DEC$
RAD_TO_RA RA2000 RA$
RAD_TO_DEC DEC2000 DEC$
print "[" Date$ "] RA2000=" RA$ ", DEC2000=" DEC$
// For some reason I have to substract 14.3 arcsec in my RA position to be OK... ASCOM or Gemini.Net problem ???
AlphaNew=alphaplus-(GuidePosXFact-XGuideCentro)*EchelleXFact/3600*3.1415/180
DeltaNew=deltaplus-(GuidePosYFact-YGuideCentro)*EchelleYFact/3600*3.1415/180
// str alphaplus RA$
// str deltaplus DEC$
RAD_TO_RA alphaplus RA$
RAD_TO_DEC deltaplus DEC$
print "[" Date$ "] AlphaPlus=" RA$ ", DecPlus=" DEC$
str AlphaNew RA$
str DeltaNew DEC$
RAD_TO_RA AlphaNew RA$
RAD_TO_DEC DeltaNew DEC$
print "[" Date$ "] AlphaNew=" RA$ ", Dec.New=" DEC$
print "[" Date$ "] Shifting Telescope (two steps approach)"
// GoTo nearby (to work around a bug in ASCOM / POTH / Gemini.Net)
AlphaNew=AlphaNew+0.003
DeltaNew=DeltaNew+0.003
if AlphaNew>TwoPI then
AlphaNew=AlphaNew-2*PI
endif
MoveTelescope AlphaNew DeltaNew
WAITFORENDMOVETELESCOPE
DelayBlock 2000
// Then GoTo the right position (should be very close to fiber now...
AlphaNew=AlphaNew-0.003
DeltaNew=DeltaNew-0.003
if AlphaNew<0 then
AlphaNew=AlphaNew+2*PI
endif
MoveTelescope AlphaNew DeltaNew
WAITFORENDMOVETELESCOPE
DelayBlock 2000
endif
CLOSE ImgChampToCenter
if AskForManualAutoGuiding=TRUE then
Input "Wait for Dome, Center target and then press ENTER" Dummy$
endif
GExpTimeChamp=GExpTimeMilSec*40
if GExpTimeChamp>60000 then
GExpTimeChamp=60000
endif
StartExposure_EX 1 GExpTimeChamp
WaitForEndExposure_EX 1
GetLastImageExposure_EX 1 ImgChamp
// Sauvegarde de l'image de guidage surexposée (FITS et JPG)
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+".fits"
SAVEFIT ImgChamp sFullPath$
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+".jpg"
SAVEJPG ImgChamp sFullPath$
CLOSE ImgChamp
if AskForManualAutoGuiding=TRUE then
Input "Start autoguiding manually - then press ENTER" Dummy$
else
DelayBlock 5000
// Run autoguiding
TRUE=1
FALSE=0
NumCam=1
CCDNum=1
// GExpTime=0.5
DelayACQSec=GuidingDelayACQSec
WindowSize=GuideXMax_2
CentroSize=GuidingCentroSize
StarThresADU=GuidingStarThresADU
AgressRA=0.7
AgressDEC=0.7
RaMin=3.0
RaMax=GuideXMax_2
DecMin=3.0
DecMax=GuideXMax_2
Backlash=0
CurrentDEC=FALSE
AlarmEnabled=FALSE
DeltaMoveFashion=FALSE
// GuidePosX=291.0
// GuidePosY=213.0
SaveImagettes=FALSE
DirSaveImg$="c:\ccd"
AllFrame=TRUE
WindowAllFrame=400
WaitForScript=60
GExpTimeBis=GExpTime*GuidingExpFactor
str GExpTimeBis GExpTimeBis$
Now Date
Datetostr Date Date$
print "[" Date$ "] Autoguidage ON (ExpTime: " GExpTimeBis "ms)"
STARTGUIDECONSIGNE NumCam CCDNum GExpTimeBis DelayACQSec WindowSize CentroSize StarThresADU AgressRA AgressDEC RaMin RaMax DecMin DecMax Backlash CurrentDEC AlarmEnabled DeltaMoveFashion GuidePosX GuidePosY SaveImagettes DirSaveImg$ AllFrame WindowAllFrame Valid message$
DelayBlock 5000
endif
//str Valid Valid$
//Now Date
//Datetostr Date Date$
//print "[" Date$ "] Valid: " Valid$ " / Status: " message$
/////////////////////
// Acquiring Target
/////////////////////
ExpTime=ExpSec*1000
REM StatWindow Img X1 Y1 X2 Y2 Mean Quadratic_mean Stddev Max Min Flux Median
HaX1=864
HaY1=1710
HaX2=984
HaY2=1722
ContX1=1543
ContY1=1640
ContX2=1588
ContY2=1189
WinPosX=500
WinPosY=100
WinSizeX=1000
WinSizeY=1000
str ExpSec ExpSec$
str NbExposure NbExposure$
sOutput$="Starting sequence for Target: "+Object$+" ("+NbExposure$+" x "+ExpSec$+" seconds)"
Now Date
Datetostr Date Date$
print "[" Date$ "] " sOutput$
sOutput$="Target filename: "+Object$
Now Date
Datetostr Date Date$
print "[" Date$ "] " sOutput$
GetStdrLongitude Longitude
GetStdrLatitude Latitude
Now Date
Datetostr Date Date$
print "[" Date$ "] Longitude = " Longitude*TODEG " Latitude = " Latitude*TODEG
Now Date
GETRADECSUN Date AlphaS DeltaS sunelevation
Datetostr Date Date$
RAD_TO_DEC sunelevation ElevationS$
GET_TELESCOPE_POSITION Alpha2000 Delta2000 Hauteur Azimuth AngleHor
// TSL pour calculer angle horaire
SIDERALTIME Date Longitude TSL
// Angle horaire objet en radian :
COMPUTEANGLEHOR TSL alpha AngleHor
Hauteur=Hauteur*TODEG
AngleHor=AngleHor*TODEG/15.0
round Hauteur Hauteur
AngleHor=AngleHor*10.0
round AngleHor AngleHor
AngleHor=AngleHor/10.0
str Hauteur Hauteur$
str AngleHor AngleHor$
print "[" Date$ "] Sun at " ElevationS$ "°, Telescope at " Hauteur$ "° & Hour Angle: " AngleHor "h"
MaxHaAvg=0
MaxContAvg=0
NbMeasures=0
For i=1 NbExposure
// Ensure proper Dome tracking - just to make sure...
DOME_SET_CONTROL 1 1
GoSub CanIContontinueToObserve:
if ContinueObservations=0 then
Now Date
Datetostr Date Date$
print "[" Date$ "] Sun too high, stopping observations"
GoTo EndOfGoToTargetAndAcquisition:
endif
StartExposure_EX 2 ExpTime
WaitForEndExposure_EX 2
GetLastImageExposure_EX 2 img
STR i i$
sFullPath$=sDirSave$+Object$+"-"+i$+".fits"
SAVEFIT img sFullPath$
StatWindow Img HaX1 HaY1 HaX2 HaY2 Mean Quadratic_mean Stddev Max Min Flux Median
MaxHa=Max-Min
MaxHaAvg=MaxHaAvg+MaxHa
NbMeasures=NbMeasures+1
str MaxHa MaxHa$
StatWindow Img ContX1 ContY1 ContX2 ContY2 Mean Quadratic_mean Stddev Max Min Flux Median
MaxCont=Max-Min
MaxContAvg=MaxContAvg+MaxCont
str MaxCont MaxCont$
sOutput$=">>> "+i$+" <<< : Max. Ha="+MaxHa$+" / Continuum="+MaxCont$
Now Date
Datetostr Date Date$
print "[" Date$ "] " sOutput$
GetStdrLongitude Longitude
GetStdrLatitude Latitude
Now Date
GETRADECSUN Date AlphaS DeltaS sunelevation
Datetostr Date Date$
RAD_TO_DEC sunelevation ElevationS$
GET_TELESCOPE_POSITION Alpha2000 Delta2000 Hauteur Azimuth AngleHor
// TSL pour calculer angle horaire
SIDERALTIME Date Longitude TSL
// Angle horaire objet en radian :
COMPUTEANGLEHOR TSL alpha AngleHor
//Angle horaire en heures décimales:
//AngleHor=AngleHor*12/PI
Hauteur=Hauteur*TODEG
AngleHor=AngleHor*TODEG/15.0
round Hauteur Hauteur
AngleHor=AngleHor*10.0
round AngleHor AngleHor
AngleHor=AngleHor/10.0
str Hauteur Hauteur$
str AngleHor AngleHor$
print "[" Date$ "] Sun at " ElevationS$ "°, Telescope at " Hauteur$ "° & Hour Angle: " AngleHor "h"
SetWindowPos img WinPosX WinPosY
SizeWindowX img WinSizeX
SizeWindowY img WinSizeY
Close img
DelayBlock 3000
Next i
EndOfGoToTargetAndAcquisition:
if NbMeasures>0 then
MaxHaAvg=MaxHaAvg/NbMeasures
round MaxHaAvg MaxHaAvg
MaxContAvg=MaxContAvg/NbMeasures
round MaxContAvg MaxContAvg
str MaxHaAvg MaxHaAvg$
str MaxContAvg MaxContAvg$
Now Date
Datetostr Date Date$
print "[" Date$ "] STATISTICS: Halpha at " MaxHaAvg$ ", continuum at: " MaxContAvg$
str NbMeasures NbMeasures$
// save stats
Open_FileTxt_For_Append fichier StatsLog$
if MaxHaAvg>MaxContAvg then
StatsMax=MaxHaAvg/1000.0
else
StatsMax=MaxContAvg/1000.0
endif
str StatsMax StatsMax$
texte$=DateStats$+";"+myObjectName$+";"+ExpSec$+";"+NbMeasures$+";"+Hauteur$+";"+StatsMax$
WRITEFILETXT fichier texte$
CLOSEFILETXT fichier
// save just BeSS object name (usually HD #) & date (goal is to avoid redoing them the following nights depending on BeSS required period... work in progress)
Open_FileTxt_For_Append fichier ObjectLog$
texte$=Objet$+";"+Date$
WRITEFILETXT fichier texte$
CLOSEFILETXT fichier
endif
if AskForManualAutoGuiding=TRUE then
Now Date
Datetostr Date Date$
print "[" Date$ "] ===="
print "[" Date$ "] =============================="
print "[" Date$ "] ========================="
print "[" Date$ "] =============================="
print "[" Date$ "] ===="
Input "Please STOP autoguiding manually - then press ENTER" Dummy$
else
Now Date
Datetostr Date Date$
print "[" Date$ "] Stopping autoguiding"
StopGuide_Ex 1 1
endif
GExpTimeChamp=GExpTimeMilSec*40
if GExpTimeChamp>60000 then
GExpTimeChamp=60000
endif
StartExposure_EX 1 GExpTimeChamp
WaitForEndExposure_EX 1
GetLastImageExposure_EX 1 ImgChamp
// Sauvegarde de l'image de guidage surexposée après séquence(FITS et JPG)
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_after.fits"
SAVEFIT ImgChamp sFullPath$
sFullPath$=sDirSave$+"ZWO_ASI174MM_"+Object$+"_after.jpg"
SAVEJPG ImgChamp sFullPath$
CLOSE ImgChamp
// Synchronise télescope sur la cible pointée (car ça a bougé pendant l'autoguidage)
Now Date
Datetostr Date Date$
print "[" Date$ "] Resynch telescope on position for " Object$ " (" objet$ ")"
CALIBRATE_TELESCOPE alpha delta
DelayBlock 15000
return
/////////////////////////////////////////////////////////////////////////////////
//
// Start_and_Calib - Routine to begin the night: connecting equipment, spectral calibration, opening dome...
//
/////////////////////////////////////////////////////////////////////////////////
Start_and_Calib:
// Switch ON Gembird USB & LAN multiplug
if CheckIfPowerManagerIsOK=1 then
Input "Please check Power Manager is ON, OK and connect to USB socket - then press ENTER" Dummy$
else
ExecExternal "C:\Program Files\Power Manager\pm.exe" ""
delayBlock 3000
Now Date
Datetostr Date Date$
print "[" Date$ "] Power Manager started"
endif
REM Switch ON the power for the mount, dome & focuser
Now Date
Datetostr Date Date$
print "[" Date$ "] Switching mount, dome & robofocus ON"
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-on -Device3 -Mount"
delayBlock 1000
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-on -Device3 -DomeTrackerd"
delayBlock 1000
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-on -Device3 -RoboFocus"
if ConnectTelescopeManually=1 then
Input "Please connect Telescope/Dome/Focuser in PRISM... and press ENTER" Dummy$
else
delayBlock 15000
Now Date
Datetostr Date Date$
print "[" Date$ "] Connecting to Telescope/Dome/Focuser"
CONNECT_OBSERVATORY Valid
delayBlock 30000
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] Stopping the sidereal tracking"
stoptelescope
Now Date
Datetostr Date Date$
print "[" Date$ "] Set dome moving on telescope tracking & GoTo"
DOME_SET_CONTROL 1 1
delayBlock 3000
REM *** calculating night's directory
GoSub CalculateNightDate:
createdir sDirSave$
createdir sDirSave$+"CALIB"
ExecExternal "C:\Users\ObsBE\Documents\Acquisitions\CALIB\CopyDirs.bat" sDirSave$+"CALIB"
ExecExternal "C:\Users\ObsBE\Documents\Acquisitions\CALIB\CopyZip.bat" sDirSave$+"Resultats"
createdir sDirSave$+"Poubelle"
createdir sDirSave$+"Raw"
createdir sDirSave$+"Resultats"
Now Date
Datetostr Date Date$
print "[" Date$ "] Tonight directory is: "+sDirSave$
REM *** Waiting for the Sun to be below "elevsunstartinitnight" to start initialising CCD
GetStdrLongitude Longitude
GetStdrLatitude Latitude
REM print "Longitude = " Longitude*TODEG " Latitude = " Latitude*TODEG
elevsunstartinitnight=elevsunstartinitnight_Deg/TODEG
beginnighttime:
Now Date
Datetostr Date Date$
GETRADECSUN Date AlphaS DeltaS sunelevation
RAD_TO_DEC sunelevation ElevationS$
if sunelevation>0
position$="above"
else
position$="below"
endif
print "[" Date$ "] Sun at " ElevationS$ position$ " horizon (Tgt: " elevsunstartinitnight_Deg "°)"
if sunelevation>elevsunstartinitnight
delayBlock 60000
goto beginnighttime:
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] The sun is now " ElevationS$ " degrees below horizon, starting up camera and mount"
REM Switch ON Gembird LAN multiplug: calibration unit & Atik460 CCD camera
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-on -GemBirdLAN -Atik460"
Now Date
Datetostr Date Date$
print "[" Date$ "] Atik 460 camera power ON now"
delayBlock 10000
REM *** Initialisations CCDs
Now Date
Datetostr Date Date$
print "[" Date$ "] Connect/Initialise guiding (#1) & acquisition (#2) cameras; cooling the main one"
GoSub init_camera:
elevsunstartbegnight=elevsunstartbegnight_Deg/TODEG
REM *** Waiting for the sun to be below "elevsunstartbegnight", then start telescope & open dome
waittillstarttime:
Now Date
GETRADECSUN Date AlphaS DeltaS sunelevation
Datetostr Date Date$
RAD_TO_DEC sunelevation ElevationS$
if sunelevation>0
position$="above"
else
position$="below"
endif
print "[" Date$ "] Sun at " ElevationS$ position$ " horizon (Tgt: " elevsunstartbegnight_Deg "°)"
if sunelevation>elevsunstartbegnight
delayBlock 60000
goto waittillstarttime:
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] The sun is now " ElevationS$ " degrees below horizon, starting the observations"
REM echelle calibration
REM Switch ON Gembird LAN multiplug: calibration unit
Now Date
Datetostr Date Date$
print "[" Date$ "] Switch calibration unit ON & start spectral calibration"
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-on -GemBirdLAN -Calib"
delayBlock 3000
if SkipCalibration=0
GoSub AcquireCalibration:
endif
REM Switch OFF Gembird LAN multiplug: calibration unit
delayBlock 3000
Now Date
Datetostr Date Date$
print "[" Date$ "] Switch calibration unit OFF"
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-off -GemBirdLAN -Calib"
REM *** Waiting for the Sun to be below "elevsunstartobservations" to start observations
GetStdrLongitude Longitude
GetStdrLatitude Latitude
REM print "Longitude = " Longitude*TODEG " Latitude = " Latitude*TODEG
elevsunstartobservations=elevsunstartobservations_Deg/TODEG
beginobservationtime:
Now Date
GETRADECSUN Date AlphaS DeltaS sunelevation
Datetostr Date Date$
RAD_TO_DEC sunelevation ElevationS$
if sunelevation>0
position$="above"
else
position$="below"
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] Sun at " ElevationS$ position$ " horizon (Tgt: " elevsunstartobservations_Deg "°)"
if sunelevation>elevsunstartobservations
delayBlock 60000
goto beginobservationtime:
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] The sun is now " ElevationS$ " degrees below horizon, ready to start observations"
// Open DOME and start observations !
if OpenDomeManually=1 then
Input "Please open Dome when ready - then press ENTER" Dummy$
else
Open_Dome
DelayBlock 30000
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] Dome is now open"
return
/////////////////////////////////////////////////////////////////////////////////
//
// Subroutine to initialize the camera, contains informations and settings of the camera
//
/////////////////////////////////////////////////////////////////////////////////
init_camera:
Now Date
Datetostr Date Date$
print "[" Date$ "] Connecting the Zwo ASI178MC guiding camera (1)"
cameraerror$=""
INIT_CCD_CAMERA_EX GuidingCamNumber Valid cameraerror$
if Valid=2 then
nbinning=1
SetBinningX_Ex GuidingCamNumber nBinning
SetBinningY_Ex GuidingCamNumber nBinning
else
Now Date
Datetostr Date Date$
print "[" Date$ "] ERREUR initialisation camera 1: Atik Titan"
print cameraerror$
EXIT
endif
REM We start the camera
Now Date
Datetostr Date Date$
print "[" Date$ "] Connecting the Atik 460ex camera (2)"
Detector_number=2
CameraChannel=1
cameraerror$=""
INIT_CCD_CAMERA_EX AcqCamNumber Valid cameraerror$
if Valid=2 then
nbinning=1
SetBinningX_Ex AcqCamNumber nBinning
SetBinningY_Ex AcqCamNumber nBinning
for i=1 to minutestogodowntotemp
GetCCDTemperature_Ex AcqCamNumber CameraChannel Starttemperature
deltaT=Detectortemperature-Starttemperature
deltaTperminute=deltaT/minutestogodowntotemp
Now Date
Datetostr Date Date$
print "[" Date$ "] Going from " Starttemperature " to " Detectortemperature " we need to cool " deltaTperminute " degrees per minute"
Currenttemperature=Starttemperature+(deltaTperminute*i)
round Currenttemperature Currenttemperature
if Currenttemperature<Detectortemperature+0.2 then
goto endcooling1:
else
SetCCDTemperature_Ex AcqCamNumber CameraChannel Currenttemperature
Now Date
Datetostr Date Date$
print "[" Date$ "] " i " minute, CCD going down to " Currenttemperature " degrees"
delayBlock 60000
endif
next i
else
REM The camera didn't initialize correctly
Now Date
Datetostr Date Date$
print "[" Date$ "] ERREUR initialisation camera 2: Atik 460ex"
print cameraerror$
EXIT
endif
endcooling1:
Now Date
Datetostr Date Date$
print "[" Date$ "] END COOLING"
SetCCDTemperature_Ex AcqCamNumber CameraChannel Detectortemperature
return
/////////////////////////////////////////////////////////////////////////////////
//
// Initializing the telescope / NOT USED...
//
/////////////////////////////////////////////////////////////////////////////////
init_telescope:
print "Connecting to the telescope"
OPEN_TELESCOPE_DEVICES 0 0
print "Connected"
print "stopping the sidereal tracking..."
stoptelescope
return
/////////////////////////////////////////////////////////////////////////////////
//
// End of night, closing telescope, camera, etc...
//
/////////////////////////////////////////////////////////////////////////////////
endnight:
REM We have to see how to bring the camera back to ambient temperature before closing it.
Now Date
Datetostr Date Date$
print "[" Date$ "] Observing is finished, so closing the telescope..."
REM Closing the telescope
//CLOSE_TELESCOPE_DEVICES
close_dome
delayBlock 20000
stoptelescope
delayBlock 10000
// A ajouter: prévoir le cas de la calibration en fin de nuit si météo mauvaise en début de nuit...
//GoSub AcquireCalibration:
Now Date
Datetostr Date Date$
print "[" Date$ "] Setting main camera temperature to positive (10°C) & wait 2 minutes"
Currenttemperature=20
CameraChannel=1
SetCCDTemperature_Ex AcqCamNumber CameraChannel Currenttemperature
delayBlock 120000
Now Date
Datetostr Date Date$
print "[" Date$ "] Closing cameras connexion"
CLOSE_CCD_CAMERA_EX 1
delayBlock 2000
CLOSE_CCD_CAMERA_EX 2
close_dome
delayBlock 20000
CLOSE_TELESCOPE_DEVICES
Now Date
Datetostr Date Date$
print "[" Date$ "] Telescope tracking stopped & dome closed, equipment closed"
Now Date
Datetostr Date Date$
print "[" Date$ "] Switching OFF mount, dome, robofocus and CCD cameras"
REM Switch OFF the power for the mount, dome & focuser
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-off -Device3 -Mount"
delayBlock 2000
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-off -Device3 -DomeTracker"
delayBlock 2000
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-off -Device3 -RoboFocus"
delayBlock 2000
REM Switch OFF Gembird LAN multiplug: calibration unit & Atik460 CCD camera
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-off -GemBirdLAN -Calib"
delayBlock 2000
ExecExternal "C:\Program Files\Power Manager\pm.exe" "-off -GemBirdLAN -Atik460"
delayBlock 2000
Now Date
Datetostr Date Date$
print "[" Date$ "] End of night sequence done"
return
/////////////////////////////////////////////////////////////////////////////////
//
// Acquire calibration for the echelle spectrograph
//
/////////////////////////////////////////////////////////////////////////////////
AcquireCalibration:
REM Penser à enlever la sauvegarde automatique dans PRISM avant de lancer le script!
Object$="ref"
PoseThAr=60000
PoseTung=2800
PoseLEDs=2800
ON=1
OFF=0
Port1=1
Port2=2
Port3=3
Port4=4
Switchdesired=1
// Recupere l'etat des swiches d'un coup dans une table
GETSWITCH Switchdesired nbSwitches ArrayName ArrayState
sOutput$="Dir: "+sDirSave$
Now Date
Datetostr Date Date$
print "[" Date$ "] " sOutput$
sOutput$="Object: "+Object$
print "[" Date$ "] " sOutput$
REM =================
REM Miroir + Tungsten
REM =================
SETSWITCH Port1 ON
DelayBlock 1000
SETSWITCH Port4 ON
DelayBlock 1000
For i=1 33
STR i i$
StartExposure_EX AcqCamNumber PoseTung
sFullPath$=sDirSave$+Object$+"_tung-"+i$+".fits"
sOutput$="Tungsten: "+Object$+"_tung-"+i$+".fits"
Now Date
Datetostr Date Date$
print "[" Date$ "] " sOutput$
WaitForEndExposure_EX AcqCamNumber
GetLastImageExposure_EX AcqCamNumber img
SAVEFIT img sFullPath$
Close img
Next i
REM =================
REM LEDs + Tungsten
REM =================
SETSWITCH Port2 ON
DelayBlock 1000
For i=1 3
STR i i$
StartExposure_EX AcqCamNumber PoseLEDs
sFullPath$=sDirSave$+Object$+"_led-"+i$+".fits"
sOutput$="Flat: "+Object$+"_led-"+i$+".fits"
Now Date
Datetostr Date Date$
print "[" Date$ "] " sOutput$
WaitForEndExposure_EX AcqCamNumber
GetLastImageExposure_EX AcqCamNumber img
SAVEFIT img sFullPath$
Close img
Next i
DelayBlock 2000
SETSWITCH Port2 OFF
DelayBlock 2000
SETSWITCH Port4 OFF
DelayBlock 2000
REM =================
REM ThAr
REM =================
SETSWITCH Port3 ON
DelayBlock 3000
For i=1 3
STR i i$
StartExposure_EX AcqCamNumber PoseThAr
sFullPath$=sDirSave$+Object$+"_thor-"+i$+".fits"
sOutput$="ThAr: "+Object$+"_thor-"+i$+".fits"
Now Date
Datetostr Date Date$
print "[" Date$ "] " sOutput$
WaitForEndExposure_EX AcqCamNumber
DelayBlock 1000
GetLastImageExposure_EX AcqCamNumber img
DelayBlock 1000
SAVEFIT img sFullPath$
Close img
DelayBlock 1000
Next i
DelayBlock 3000
SETSWITCH Port3 OFF
DelayBlock 1000
SETSWITCH Port1 OFF
DelayBlock 1000
REM sOutput$="That's all folks"
REM Print sOutput$
return
/////////////////////////////////////////////////////////////////////////////////
//
// Check if I can continue to observe another 20min based on Sun position & telescope Vs meridian
//
/////////////////////////////////////////////////////////////////////////////////
CanIContontinueToObserve:
NOW Date
GET_TELESCOPE_POSITION RA2000 DEC2000 Haut Azi AHor
GETSTDRLONGITUDE Longitude
GETSTDRLATITUDE Latitude
GETHEIGHT RA2000 DEC2000 Date Longitude Latitude Hauteur
// Hauteur en degrés
Hauteur=Hauteur*TODEG
if Hauteur<HauteurMin then
Now Date
Datetostr Date Date$
print "[" Date$ "] Target too low"
ContinueObservations=0
return
endif
DateEndOfObs=Date+ExpSec/(3600.0*24.0)
// TSL pour calculer angle horaire
SIDERALTIME DateEndOfObs Longitude TSL
// Angle horaire objet en radian :
COMPUTEANGLEHOR TSL RA2000 AngleHor
//Angle horaire en heures décimales:
AngleHor=AngleHor*12/PI
AngleHorLimit=0.0
// si DEC<45°: 10min supplémentaires
if DEC2000<0.75 then
AngleHorLimit=10.0/60.0
endif
// si DEC<30°: 20min supplémentaires -> 15min
if DEC2000<0.5 then
AngleHorLimit=15.0/60.0
endif
// si DEC<25°: 1h10 supplémentaires -> 20min
if DEC2000<0.44 then
AngleHorLimit=20.0/60.0
endif
// si DEC<6°: 1h45 supplémentaires -> 30 min
if DEC2000>0.1 then
AngleHorLimit=30.0/60.0
endif
if AngleHor>AngleHorLimit
Now Date
Datetostr Date Date$
print "[" Date$ "] Target will be too close to meridian (telescope too close to pier) at the end of next exposure"
ContinueObservations=0
return
endif
// Check Sun elevation
GetStdrLongitude Longitude
GetStdrLatitude Latitude
elevsunstartobservations=elevsunstartobservations_Deg/TODEG
Now Date
DateEndOfObs=Date+ExpSec/(3600.0*24.0)
GETRADECSUN DateEndOfObs AlphaS DeltaS sunelevation
Datetostr Date Date$
Frac DateEndOfObs DateFrac
RAD_TO_DEC sunelevation ElevationS$
if sunelevation>elevsunstartobservations
if DateFrac<0.5
Now Date
Datetostr Date Date$
print "[" Date$ "] Sun too high to continue observing"
ContinueObservations=0
return
endif
endif
ContinueObservations=1
return
/////////////////////////////////////////////////////////////////////////////////
//
// Check if Sun is still below horizon limit, check if observations can continu...
//
/////////////////////////////////////////////////////////////////////////////////
IsSunStillBelow:
// Check Sun elevation
GetStdrLongitude Longitude
GetStdrLatitude Latitude
elevsunstopobservations=elevsunstopobservations_Deg/TODEG
Now Date
GETRADECSUN Date AlphaS DeltaS sunelevation
Datetostr Date Date$
Frac Date DateFrac
RAD_TO_DEC sunelevation ElevationS$
if sunelevation>elevsunstopobservations
if DateFrac<0.5 then
Now Date
Datetostr Date Date$
print "[" Date$ "] Sun too high to continue observing"
SunStillBelow=1
ContinueObservations=0
return
endif
endif
SunStillBelow=1
ContinueObservations=1
return
/////////////////////////////////////////////////////////////////////////////////
//
// Wait several minutes (for long waiting time)...
//
/////////////////////////////////////////////////////////////////////////////////
WaitForMinutes:
//MinutesToWait=5
str MinutesToWait MinutesToWait$
Now Date
Datetostr Date Date$
print "[" Date$ "] Start waiting for " MinutesToWait$ " minutes"
Now DateBegin
WaitForMinutesLoop:
Now Date
Ecart=(Date-DateBegin)*24.0*60.0
if Ecart<MinutesToWait then
goto WaitForMinutesLoop:
endif
Now Date
Datetostr Date Date$
print "[" Date$ "] Fin (MinutesToWait=" MinutesToWait ")"
return
/////////////////////////////////////////////////////////////////////////////////
//
// CATALOG / Look up for Object$ parameters in terms of single exposure time, Nb of exposures...
//
/////////////////////////////////////////////////////////////////////////////////
// Initially used (with longuer list), now using an external file with target list...
LookUpObject:
NbExposure=0
if Object$="QRVul" then
objet$="hd192685"
GExpTime=0.5
ExpSec=1200
NbExposure=3
endif
if Object$="V442And" then
objet$="hd6226"
GExpTime=0.75
ExpSec=1200
NbExposure=6
endif
return
/////////////////////////////////////////////////////////////////////////////////
//
// TakeObject: acquire spectra of Object$
//
/////////////////////////////////////////////////////////////////////////////////
TakeObject:
GoSub LookUpObject:
GExpTime=GExpTime*ExposureCloudFactor
GoSub GoToTargetAndAcquisition:
GoSub IsSunStillBelow:
if SunStillBelow=0 then
if StarToSynchForObject$="" then
// Add synchronisation on a star there is needed (not really needed anymore)
endif
GoTo EndOfSession:
endif
return
/////////////////////////////////////////////////////////////////////////////////
//
// Meteo.pgm: Sentinel weather station management (T.Lemoult)
//
/////////////////////////////////////////////////////////////////////////////////
// Note: doesn't work yet, to be improved later...
ReadMeteo:
//Print "Donnees de la station meteo Sentinel:"
pathSentinel$="C:\Users\ObsBE\Documents\Sentinel\Datas\infodata.txt"
Open_FileTxt_For_Read fichier pathSentinel$
for i=1 7
ReadFileTXT fichier ligneDummy$
next i
ReadFileTXT fichier ligneTempExt$
CUTSTR ligneTempExt$ "=" 2 out$
val out$ TempExt
ReadFileTXT fichier ligneHumidity$
CUTSTR ligneHumidity$ "=" 2 out$
val out$ Humidity
//print "Humidity=" out$
ReadFileTXT fichier ligneDummy$
ReadFileTXT fichier ligneDummy$
ReadFileTXT fichier ligneTempSkyIR$
CUTSTR ligneTempSkyIR$ "=" 2 out$
val out$ TempskyIR
//print "TempskyIR=" out$
ReadFileTXT fichier ligneTempDetectorIR$
CUTSTR ligneTempDetectorIR$ "=" 2 out$
val out$ TempDetectorIR
//print "TempDetectorIR=" out$
ReadFileTXT fichier ligneRainFall$
CUTSTR ligneRainFall$ "=" 2 out$
if Out$="No" then
RainFall=0
RainFall$="N"
ELSE
RainFall=1
RainFall$="Y"
ENDIF
//print "RainFall=" out$
ReadFileTXT fichier ligneWindSpeedGust$
CUTSTR ligneWindSpeedGust$ "=" 2 out$
val out$ WindSpeedGust
//print "WindSpeedGust=" out$
ReadFileTXT fichier ligneDummy$
ReadFileTXT fichier ligneDummy$
ReadFileTXT fichier ligneDummy$
ReadFileTXT fichier ligneDummy$
ReadFileTXT fichier ligneLightLevel$
CUTSTR ligneLightLevel$ "=" 2 out$
val out$ LightLevel
//print "LightLevel=" out$
tempCiel=TempSkyIR-TempExt
STR tempCiel tempCiel$
//print "calcul temperature ciel =" tempCiel$
////////////////////////
if (tempCiel<LimitTempCiel) then
if RainFall=0 then
if LightLevel>LimitMagnitudeCiel
BeauTemp=1
ELSE
BeauTemp=0
ENDIF
ELSE
BeauTemp=0
ENDIF
ELSE
BeauTemp=0
ENDIF
// Beautemp est obtenus en regardant que la derniere valeur du Sentinel.
if BeauTemp=1 then
CompteurBeauTemp=CompteurBeauTemp+1
ELSE
CompteurBeauTemp=0
ENDIF
// MeteoOK donne un résultat filtree..
if CompteurBeauTemp>ValMinBelleMeteo then
// Print "Il fait beau depuis un moment.. On va pouvoir observer"
MeteoOK=1
else
MeteoOK=0
IF (BeauTemp=1) then
// Print "Si le beau temps se maintien, on pourra observer"
ELSE
// Print "Il ne fait pas assez beau pour observer"
ENDIF
ENDIF
CLOSEFILETXT fichier
return
// Other weather function - to be improved/checked...
BoucleAttendBeauTemp:
Now Date
Datetostr Date Date$
print "[" Date$ "] Waiting for good weather. Sky temp=" tempCiel$ " (" LimitTempCiel "), Rain=" RainFall$
GOSUB ReadMeteo:
DELAYBLOCK 60000
if MeteoOK=0 THEN
GOTO BoucleAttendBeauTemp:
ENDIF
return
/////////////////////////////////////////////////////////////////////////////////
//
// calculating night's date (from A. Maury)
//
/////////////////////////////////////////////////////////////////////////////////
CalculateNightDate:
NOW year month day hour minute second MS
lengthmonth[1]=31
REM bissextile years
yearfrac=year/4
frac yearfrac bissextile
if bissextile=0 then
lengthmonth[2]=29
else
lengthmonth[2]=28
endif
lengthmonth[3]=31
lengthmonth[4]=30
lengthmonth[5]=31
lengthmonth[6]=30
lengthmonth[7]=31
lengthmonth[8]=31
lengthmonth[9]=30
lengthmonth[10]=31
lengthmonth[11]=30
lengthmonth[12]=31
if hour<12 then
if day=1 then
if month=1 then
year=year-1
month=12
day=31
else
month=month-1
endif
day=lengthmonth[month]
else
day=day-1
endif
endif
str year year$
str month month$
if month<10 then
month$="0"+month$
endif
str day day$
if day<10 then
day$="0"+day$
endif
CurrentDate$=year$+month$+day$
DateStats$=day$+"/"+month$+"/"+year$
// set directory to save file and copy CALIB files in
sDirSave$="C:\Users\ObsBE\Documents\Acquisitions\"+CurrentDate$+"_eShel101_Atik460-1x1_38420_Revel\"
return
/////////////////////////////////////////////////////////////////////////////////
//
// Read my own Be Star Catalog + top target list (inspired from A. Maury)
//
/////////////////////////////////////////////////////////////////////////////////
ReadStarCatalog:
// start with Be star catalog (my own one, selection among BeSS catalog)
Open_FileTxt_For_Read StarCatalog StarCatalogFileName$
numberofstarsintargetlist=0
// Dummy (title) first line
ReadFileTxt StarCatalog line$
readnextline:
ENDOFFILE StarCatalog result
if result=FALSE then
numberofstarsintargetlist=numberofstarsintargetlist+1
REM we have not arrived till the end of the file
ReadFileTxt StarCatalog line$
REM we split the line
CUTSTR line$ ";" 1 starname[numberofstarsintargetlist]$
CUTSTR line$ ";" 2 myobjname[numberofstarsintargetlist]$
// myobjname[numberofstarsintargetlist]$=starname[numberofstarsintargetlist]$
CUTSTR line$ ";" 3 starRAH$
CUTSTR line$ ";" 4 starRAM$
CUTSTR line$ ";" 5 starDecD$
CUTSTR line$ ";" 6 starDecM$
CUTSTR line$ ";" 7 starFileName[numberofstarsintargetlist]$
CUTSTR line$ ";" 8 starVMag$
CUTSTR line$ ";" 9 starOTHPriority$
CUTSTR line$ ";" 10 starBeSSPriority$
CUTSTR line$ ";" 11 starExpTimeSec$
CUTSTR line$ ";" 12 starNbExposure$
val starRAH$ starRAH
val starRAM$ starRAM
val starDecD$ starDecD
val starDecM$ starDecM
starRA[numberofstarsintargetlist]=starRAH+(starRAM/60)
if starDecD<0 then
starDec[numberofstarsintargetlist]=starDecD-(starDecM/60)
else
starDec[numberofstarsintargetlist]=starDecD+(starDecM/60)
endif
val starVMag$ starVMag[numberofstarsintargetlist]
// Calculate the typical guiding exposure time for a Be star with this VMag (empiric formulae!)
PowerVal=starVMag[numberofstarsintargetlist]-4.0)/2.5
Power 10.0 PowerVal
starGuideExposureSec[numberofstarsintargetlist]=0.045*PowerVal*100.0*ExposureCloudFactor
round starGuideExposureSec[numberofstarsintargetlist] starGuideExposureSec[numberofstarsintargetlist]
starGuideExposureSec[numberofstarsintargetlist]=starGuideExposureSec[numberofstarsintargetlist]/100.0
numberofimages[numberofstarsintargetlist]=0
val starBeSSPriority$ starWeightBeSS[numberofstarsintargetlist]
val starOTHPriority$ starWeightOTH[numberofstarsintargetlist]
starWeightDistance[numberofstarsintargetlist]=0
sortIndex[numberofstarsintargetlist]=numberofstarsintargetlist
SortCriteria[numberofstarsintargetlist]=starWeightBeSS[numberofstarsintargetlist]+starWeightOTH[numberofstarsintargetlist]+starWeightDistance[numberofstarsintargetlist]
val starExpTimeSec$ starExpTimeSec[numberofstarsintargetlist]
val starNbExposure$ starNbExposure[numberofstarsintargetlist]
goto readnextline:
endif
closefiletxt StarCatalog
// print "number of stars in the target list : " numberofstarsintargetlist
Return
/////////////////////////////////////////////////////////////////////////////////
//
// Calculate the distance from (RARef/DECRef) for all targets in Star Catalog & add a weight factor
//
/////////////////////////////////////////////////////////////////////////////////
CalculateDistanceStarCatalogToRef:
for Temp_i=1 to numberofstarsintargetlist
starDeltaRA=(starRA[Temp_i]-RARef)*15.0
if starDeltaRA<-180.0 then
starDeltaRA=starDeltaRA+360.0
endif
if starDeltaRA>180.0 then
starDeltaRA=360.0-starDeltaRA
endif
starDeltaDEC=starDec[Temp_i]-DECRef
starDistance=(starDeltaRA*starDeltaRA)+(starDeltaDEC*starDeltaDEC)
sqr starDistance starDistance
if starDistance>MaximumStarDistanceToTelescope then
starDistance=MaximumStarDistanceToTelescope
endif
// CarreNum=(MaximumStarDistanceToTelescope-starDistance)*(MaximumStarDistanceToTelescope-starDistance)
// CarreDen=MaximumStarDistanceToTelescope*MaximumStarDistanceToTelescope
// starWeightDistance[Temp_i]=300.0*CarreNum/CarreDen
starWeightDistance[Temp_i]=300.0*(MaximumStarDistanceToTelescope-starDistance)/MaximumStarDistanceToTelescope
round starWeightDistance[Temp_i] starWeightDistance[Temp_i]
if starWeightDistance[Temp_i]<>0 then
SortCriteria[Temp_i]=starWeightBeSS[Temp_i]*2+starWeightOTH[Temp_i]+starWeightDistance[Temp_i]
else
SortCriteria[Temp_i]=0
endif
// Avoid going above DEC limit
if starDEC[Temp_i]>MaximumStarDEC then
SortCriteria[Temp_i]=0
endif
next Temp_i
return
/////////////////////////////////////////////////////////////////////////////////
//
// Check the star catalog with elevation, distance to meridian+safety limit
//
/////////////////////////////////////////////////////////////////////////////////
CheckStarCatalogForVisibility:
NOW Date
for Temp_i=1 to numberofstarsintargetlist
// GET_TELESCOPE_POSITION RA2000 DEC2000 Haut Azi AHor
GETSTDRLONGITUDE Longitude
GETSTDRLATITUDE Latitude
RATemp=starRA[Temp_i]/12*PI
DECTemp=starDEC[Temp_i]/180*PI
GETHEIGHT RATemp DECTemp Date Longitude Latitude Hauteur
// Hauteur en degrés
Hauteur=Hauteur*TODEG
if Hauteur<HauteurMin then
SortCriteria[Temp_i]=0
endif
// TSL pour calculer angle horaire
SIDERALTIME Date Longitude TSL
// Angle horaire objet en radian :
COMPUTEANGLEHOR TSL RATemp AngleHor
//Angle horaire en heures décimales, on ajoute la moitié du temps de pose
AngleHor=AngleHor*12/PI+(starExpTimeSec[Temp_i]*starNbExposure[Temp_i]/7200.0))
AngleHorLimit=0.0
// si DEC<45°: 10min supplémentaires /2
if starDEC[Temp_i]<45 then
AngleHorLimit=0.0/60.0
endif
// si DEC<30°: 15min supplémentaires /2
if starDEC[Temp_i]<30 then
AngleHorLimit=0.0/60.0
endif
// si DEC<25°: 20 supplémentaires /2
if starDEC[Temp_i]<25 then
AngleHorLimit=0.0/60.0
endif
// si DEC<6°: 30 supplémentaires /2
if starDEC[Temp_i]<6 then
AngleHorLimit=0.0/60.0
endif
if AngleHor>AngleHorLimit
SortCriteria[Temp_i]=0
endif
// if Temp_i=133 then
// print "DEBUG: AnleHor (V442 And)=" AngleHor
// print "DEBUG: AnleHorLimit=" AngleHorLimit
// print "DEBUG: Haueur=" Hauteur
// print "DEBUG: HauterMin=" HauteurMin
// print "DEBUG RA=" RATemp
// print "DEBUG RA=" DECTemp
// endif
next Temp_i
return
/////////////////////////////////////////////////////////////////////////////////
//
// Sort star catalog : sort my star catalog based on a weight criteria (usually sum of different criteria)
//
/////////////////////////////////////////////////////////////////////////////////
SortStarCatalog:
// SortIndex[]: table of index to sort
// numberofstarsintargetlist: number of index to sort
// SortCriteria[]: criteria (numerical) to use to sort, from highest to lowest number
// advance the position through the entire array
// (could do j < n-1 because single element is also min element)
for Sort_j=1 to numberofstarsintargetlist
// find the min element in the unsorted a[j .. n-1]
// assume the min is the first element
Sort_iMax=Sort_j
// test against elements after j to find the smallest
Sort_i_start=Sort_j+1
for Sort_i=Sort_i_start to numberofstarsintargetlist
// if this element is less, then it is the new minimum */
if SortCriteria[SortIndex[Sort_i]]>SortCriteria[SortIndex[Sort_iMax]] then
// found new maximum; remember its index
Sort_iMax=Sort_i
endif
next Sort_i
if (Sort_iMax<>Sort_j)
SortTemp=SortIndex[Sort_j]
SortIndex[Sort_j]=SortIndex[Sort_iMax]
SortIndex[Sort_iMax]=SortTemp
endif
next NumeroObject
return
/////////////////////////////////////////////////////////////////////////////////
//
// Testing: read catalog, calculate distance to V442 And & sort by weighted criteria -> look for next target?
//
/////////////////////////////////////////////////////////////////////////////////
// DO NOT USE - FOR TESTING PURPOSES ONLY...
TestCatalogFunctions:
GoSub ReadStarCatalog:
print "number of stars in the target list : " numberofstarsintargetlist
// QR Vul
RARef=20.0+15.0/60.0
DECRef=25.0/35.0
// lam Cyg
RARef=20.78
DECRef=36.48
// V442 And
RARef=1.05
DECRef=47.63
// lam Cyg
RARef=20.78
DECRef=36.48
// 28 Cyg
RARef=19.98
DECRef=37.03
GET_TELESCOPE_POSITION Alpha2000 Delta2000 Hauteur Azimuth AngleHor
RARef=Alpha2000
DECRef=Delta2000
GoSub CalculateDistanceStarCatalogToRef:
GoSub CheckStarCatalogForVisibility:
GoSub SortStarCatalog:
for Temp_i=1 to numberofstarsintargetlist
Temp_j=SortIndex[Temp_i]
Temp_Prio=SortCriteria[Temp_j]
if Temp_Prio>-1 then
print "Prio=" Temp_Prio " starname number : " Temp_i " is : " starFileName[Temp_j]$ " star RA in decimal : " starRA[Temp_j] " star Dec in decimal : " starDec[Temp_j] " Vmag=" starVMag[Temp_j] " Guiding Exp Time=" starGuideExposureSec[Temp_j] " BeSS=" starWeightBeSS[Temp_j] " MyPrio=" starWeightOTH[Temp_j] " Distance=" starWeightDistance[Temp_j]
endif
next Temp_i
END
return
/////////////////////////////////////////////////////////////////////////////////
//
// ReadObsC2A - download ARASBeAm BeSS target files to get priorities from it/ Need wget.exe to work.
//
/////////////////////////////////////////////////////////////////////////////////
ReadObsC2A:
execexternal "C:\Users\ObsBE\Documents\Acquisitions\CALIB\wget.exe" "http://arasbeam.free.fr/robot/ObsC2A.txt"
ObsC2A$="C:\Users\ObsBE\Documents\Acquisitions\CALIB\ObsC2A.txt"
Open_FileTxt_For_Read ObsC2A ObsC2A$
NbObsC2A=0
// Dummy (title) first line
ReadFileTxt ObsC2A line$
readnextline:
ENDOFFILE ObsC2A result
if result=FALSE then
NbObsC2A=NbObsC2A+1
REM we have not arrived till the end of the file
ReadFileTxt ObsC2A line$
REM we split the line
Deb=16
Fin=6
SUBSTRING line$ Deb Fin objet$
print line$
print objet$
goto readnextline:
endif
closefiletxt ObsC2A
Return
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// END OF SCRIPT //
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
And the catalog that I use (just the first lines):
BeSSName;MyName;RA;RAm;DEC;DECm;FileName;VMag;OTHPriority;BeSSPriority;ExpSec;NbExposure
HD103287;gam Uma;+11;53;+53;41;gamUma;2.44;0;17;600;4
HD5394;gam Cas;+00;56;+60;43;gamCas;2.47;0;80;60;20
HD58715;bet CMi;+07;27;+08;17;betCMi;2.89;0;32;600;4
HD37202;zet Tau;+05;37;+21;08;zetTau;3.03;0;100;450;4
HD205021;ALFIRK;+21;28;+70;33;ALFIRK;3.22;0;100;600;4
HD11415;eps Cas;+01;54;+63;40;epsCas;3.34;0;3;450;3
HD35411;eta Ori;+05;24;-02;23;etaOri;3.38;0;100;600;4
HD174638;bet Lyr;+18;50;+33;21;betLyr;3.52;0;3;600;4
HD217675;omi And;+23;01;+42;19;omiAnd;3.63;100;2;800;4
HD166014;omi Her;+18;07;+28;45;omiHer;3.84;0;2;900;4
HD109387;kap Dra;+12;33;+69;47;kapDra;3.88;0;6;900;4
HD199629;nu Cyg;+20;57;+41;10;nuCyg;3.94;0;1;900;4
HD25940;48 Per;+04;08;+47;42;48Per;4;0;28;900;4
HD24912;xi Per;+03;58;+35;47;xiPer;4.06;0;100;900;4
HD10516;phi Per;+01;43;+50;41;phiPer;4.09;0;33;900;4
HD45542;nu Gem;+06;28;+20;12;nuGem;4.14;0;31;900;4
HD138749;tet CrB;+15;32;+31;21;tetCrB;4.15;0;24;900;3
HD6811;phi And;+01;09;+47;14;phiAnd;4.25;0;4;600;4
HD22192;psi Per;+03;36;+48;11;psiPer;4.31;0;55;900;3
HD30739;2 Ori;+04;50;+08;54;2Ori;4.35;0;34;900;6
HD202904;ups Cyg;+21;17;+34;53;upsCyg;4.43;0;1;600;4
HD98058;phi Leo;+11;16;-03;39;phiLeo;4.47;0;24;900;4
HD4180;omi Cas;+00;44;+48;17;omiCas;4.48;0;70;600;6
HD217891;bet Psc;+23;03;+03;49;betPsc;4.49;0;1;600;4
HD37490;ome Ori;+05;39;+04;07;omeOri;4.57;0;47;900;4
HD47839;15 Mon;+06;40;+09;53;15Mon;4.64;0;37;900;4
HD209409;omi Aqr;+22;03;-02;09;omiAqr;4.7;0;69;900;4
HD20336;BK Cam;+03;19;+65;39;BKCam;4.73;0;20;900;4
HD200120;59 Cyg;+20;59;+47;31;59Cyg;4.74;0;20;900;4
HD198183;lam Cyg;+20;47;+36;29;lamCyg;4.75;0;10;900;3
HD192685;QR Vul;+20;15;+25;35;QRVul;4.76;40;29;900;3
HD164284;66 Oph;+18;00;+04;22;66Oph;4.78;100;17;900;3
HD212571;pi Aqr;+22;25;+01;22;piAqr;4.79;60;100;600;4
HD212076;31 Peg;+22;21;+12;12;31Peg;4.81;0;5;1200;4
HD35439;25 Ori;+05;24;+01;50;25Ori;4.87;0;100;1200;4
HD187811;12 Vul;+19;51;+22;36;12Vul;4.89;0;8;1200;4
HD191610;28 Cyg;+20;09;+36;50;28Cyg;4.93;0;67;900;3
HD24479;HD24479;+03;57;+63;04;HD24479;4.95;0;26;1200;4
HD42545;69 Ori;+06;12;+16;07;69Ori;4.95;0;100;1200;4
HD52918;19 Mon;+07;02;-04;14;19Mon;4.99;0;44;1200;4
Inscription à :
Articles (Atom)