River Cam (5 / 8 steg)
Steg 5: IR-Filter kontroll
En av torrakor med en NoIR kamera är att under dagen färgerna ser ganska konstigt, som gröna blad är en tung reflektor av IR ljus och hamnar ser vita. En lösning är att placera en servo driven filer framför linsen.
Layouten i diagrammet kom från ett inlägg på https://www.raspberrypi.org/forums/viewtopic.php?...
Jag skapade två Python skript till stängas med cron. Först är en den som styr filtret och kallar sunset.py för att beräkna Soluppgång och solnedgång gånger (detta senare en ändrades från http://michelanders.blogspot.co.uk/2010/12/calula... Som motionEyeOS har en låst ner filsystem att göra autostart via init.d lite av en utmaning som jag valde för att sätta en beskjuta skrivar (för att ändra katalog till sökvägen för rutinerna samt lansera Python) skjuter IRfilter_check.py rutin i cron ("crontab-e") att skjuta varje minut. (uppdatering med senare flytta till Raspbian placerade jag ett samtal till skriptet i/etc/rc.local)
IRfilter_control.py
#-----------------------------------------------------------#
# bibliotek #
#-----------------------------------------------------------#
importera RPi.GPIO som GPIO
från att importera sömn, localtime, mktime
från datetime import datetime, datum
importera sunset
importera underprocess
importera re
importera sqlite3
importera sys
#-----------------------------------------------------------#
# time2sec #
#-----------------------------------------------------------#
def time2sec (t):
skriva ut t
l = re.split(':',t)
återgå int(l[0]) * 3600 + int(l[1]) * 60 +float(l[2])
#-----------------------------------------------------------#
# exposure_level #
#-----------------------------------------------------------#
def exposure_level (sr, ss, t):
TS = time2sec(str(t))
skriva ut ts
SRS = time2sec(str(sr))
SSS = time2sec(str(ss))
om ts > sss: # då iit är efter solnedgången
period = 4 # efter solnedgången
gap = ts - sss
annat:
om ts < srs:
period = 1 # före gryningen
gap = srs - ts
annat:
mitt på dagen = (sss - srs) / 2 # inte riktigt men tillräckligt bra
om ts < middagar:
period = 2 # efter gryningen
gap = ts - srs
annat:
period = 3 # före solnedgången
gap = sss - ts
# Nu använder han gap och period arbetet ut nivåerna.
Skriv ut period
gap = gap / 60 #convert till mminutes
skriva ut gap
försök:
dbconnect = ingen
dbconnect = sqlite3.connect('light_levels.db')
markören = dbconnect.cursor()
cursor.Execute ("SELECT * FROM nivåer där period = %d och gap > %d ORDER BY gap ASC" % (period, gap))
rad = cursor.fetchone() # förhoppningsvis är nästa en i ordning som vi strategi/moveaway från sr/ss
Om raden:
ljusstyrka = rad [2]
kontrast = rad [3]
filtret = rad [4]
annat:
skriva ut "Ingen data availalble - ange standardinställningar"
ljusstyrka = 50
kontrast = 50
filtret = 1
utom sqlite3. Fel, e:
skriva ut "Fel % s:" % e.args[0]
sys.Exit(1)
Slutligen:
om dbconnect:
dbconnect.Close
skriva ut "ljusstyrka", ljusstyrka
skriva ut "kontrast", kontrast
Print "Filtrera", filtrera
skriva ut "gap", raden [1]
tillbaka (ljusstyrka, kontrast, filter)
#-----------------------------------------------------------#
# Allmänna parametrar #
#-----------------------------------------------------------#
#display inga varningar (på kommandoraden)
GPIO.setwarnings(False)
#use RPi styrelsen pin-koder
GPIO.setmode (GPIO. STYRELSEN)
#set pin 16, 18 och 22 som utgång
GPIO.setup (16, GPIO. OUT)
GPIO.setup (18, GPIO. OUT)
GPIO.setup (22, GPIO. OUT)
delay_s = 60 #delay i sekunder
# Ställ in latitud och longitud (det är möjligt att få detta på nätet,
# men jag föredrog fasta som kameran är inte rörliga)
home_lat = "51.83"
home_long = "-1.40"
welcome_mess = "From Dusk Till Dawn v2.1 (08/2014)"
skriva ut "\n"
skriva ut welcome_mess
#-----------------------------------------------------------#
# main loop #
#-----------------------------------------------------------#
medan 1:
#-----------------------------------------------------------#
# Avgöra soluppgång/solnedgång #
#-----------------------------------------------------------#
#determine föregående/nästa solnedgången och -upphov
#define solen som anmärker av intresserar
s=Sunset.Sun()
SR = s.sunrise()
SS = s.sunset()
t = datetime.utcnow().time()
skriva ut "solnedgång:", ss
skriva ut "soluppgång:", sr
# Lookup databas att få nivåer för tiden på dagen i förhållande till solen
light_level = exposure_level (sr, ss, t)
om light_level [2]: # värdet av filter är sanna och filtret måste vara på
skriva ut "Slå på IR-filter"
GPIO.output (16, GPIO. LÅG)
GPIO.output (18, GPIO. HÖG)
GPIO.output (22, GPIO. HÖG)
annat:
skriva ut "Stänga av IR-filter"
GPIO.output (16, GPIO. HÖG)
GPIO.output (18, GPIO. LÅG)
GPIO.output (22, GPIO. HÖG)
# Justera digital vinst på kameran med hjälp av databasdata
subprocess.Call ("v4l2-ctl--set-ctrl = ljusstyrka = %d kontrast = %d ' % (light_level [0], light_level[1]), skal = True)
Sleep(delay_s) #wait
Sunset.py (tog från nätet)
math importera cos, synd, acos, asin, tan
från matematik importera grader som grader, radianer som rad
från datetime importera datum, datetime, tid
klass solen:
# Beräkna Soluppgång och solnedgång baserat på ekvationer från NOAA
# http://www.srrb.noaa.gov/highlights/sunrise/calcdetails.html
#
# typisk användning, beräkning av soluppgången på den närvarande dagen:
# import datetime
# import sunrise
# s = sun(lat=81.82,long=-1.39)
# Skriv ut ("sunrise på", s.sunrise(when=datetime.datetime.now())
def __init__(self,lat=51.82,long=-1.39): # standard Long Hanborough
Self.lat=lat
Self.Long=Long
def sunrise(self,when=None):
# tillbaka tiden för soluppgång som ett datetime.time-objekt
# När är ett datetime.datetime-objekt. Om ingen ges
# en lokal tidszon antas (även sommartid
# om den finns)
om när ingen är: när = datetime.now()
Self.__preptime(when)
Self.__calc()
återgå sun.__timefromdecimalday(self.sunrise_t)
def sunset(self,when=None):
om när ingen är: när = datetime.now()
Self.__preptime(when)
Self.__calc()
återgå sun.__timefromdecimalday(self.sunset_t)
def solarnoon(self,when=None):
om när ingen är: när = datetime.now()
Self.__preptime(when)
Self.__calc()
återgå sun.__timefromdecimalday(self.solarnoon_t)
def __timefromdecimalday(day):
# Returnerar ett datetime.time objekt.
#
# dag är en decimal dag mellan 0.0 och 1.0, t.ex. middag = 0,5
#
timmar = 24,0 * dag
h = int(hours)
minuter = (timmar-h) * 60
m = int(minutes)
sekunder = (minuter-m) * 60
s = int(seconds)
återgå time(hour=h,minute=m,second=s)
def __preptime(self,when):
# Extrahera information i ett lämpligt format från när,
# ett datetime.datetime objekt.
# datetime dagar är räknade i den gregorianska kalendern
# medan beräkningarna från NOAA är utdelat som
# OpenOffice kalkylprogram med dagar numrerade från
# 1/1/1900. Skillnaden är dessa siffror tas för
# 18/12/2010
Self.Day = when.toordinal()-(734124-40529)
t=when.Time()
Self.Time= (t.hour + t.minute/60.0 + t.second/3600.0)/24.0
Self.TimeZone=0
offset=when.UTCOffset()
om inte offset är ingen:
Self.TimeZone=offset.seconds/3600.0
def __calc(self):
# Utföra faktiska beräkningarna för soluppgång, solnedgång och
# ett antal relaterade kvantiteter.
#
# Resultaten lagras i förekomstvariabler
# sunrise_t, sunset_t och solarnoon_t
timezone = self.timezone # i timmar, öst är positiva
longitud = self.long # i decimalgrader, öst är positiva
Latitude = self.lat # i decimalgrader, north är positiva
tid = self.time # procent efter midnatt, dvs noon är 0,5
dag = self.day # daynumber 1 = 1/1/1900
Jday = dag + 2415018.5 + tid-timezone/24 # julianska dagen
Jcent =(Jday-2451545)/36525 # Julian sekel
Manom = 357.52911+Jcent*(35999.05029-0.0001537*Jcent)
Mlong = 280.46646 + Jcent * (36000.76983 + Jcent * 0.0003032) % 360
Eccent = 0.016708634-Jcent*(0.000042037+0.0001537*Jcent)
Mobliq = 23+(26+((21.448-Jcent*(46.815+Jcent*(0.00059-Jcent*0.001813))) / 60) / 60
Obliq = Mobliq+0.00256*cos(rad(125.04-1934.136*Jcent))
variera = tan(rad(obliq/2))*tan(rad(obliq/2))
Seqcent = sin(rad(Manom))*(1.914602-Jcent*(0.004817+0.000014*Jcent))+sin(rad(2*Manom))*(0.019993-0.000101*Jcent)+sin(rad(3*Manom)) * 0.000289
Struelong = Mlong + Seqcent
Sapplong = Struelong-0.00569-0.00478*sin(rad(125.04-1934.136*Jcent))
deklination = deg(asin(sin(rad(obliq))*sin(rad(Sapplong)))
eqtime = 4*deg(vary*sin(2*rad(Mlong))-2*Eccent*sin(rad(Manom))+4*Eccent*vary*sin(rad(Manom))*cos(2*rad(Mlong))-0.5*vary*vary*sin(4*rad(Mlong))-1.25*Eccent*Eccent*sin(2*rad(Manom)))
hourangle = deg(acos(cos(rad(90.833))/(cos(rad(latitude))*cos(rad(declination)))-tan(rad(latitude))*tan(rad(declination)))
Self.solarnoon_t=(720-4*Longitude-eqtime+timezone*60)/1440
Self.sunrise_t =self.solarnoon_t-hourangle * 4/1440
Self.sunset_t =self.solarnoon_t+hourangle*4/1440
om __name__ == "__main__":
s=Sun(lat=52.37,Long=4.90)
Print(DateTime.today())
Print(s.Sunrise(),s.solarnoon(),s.Sunset())