Puntamento Parabola

[JumpJack_]

Non è un programma che si usa tutti i giorni... ma potrebbe comunque essere utile averlo nei nostri "coltellini multiuso tecnologici", altrimenti noti come cellulari : un programma che permette di calcolare come orientare la parabola, in base alla posizione in cui ci si trova... che naturalmente verrebbe rilevata tramite GPS in caso fosse disponibile!

Tecnicamente non è difficile da realizzare, in un qualunque linguaggio: si tratta solo di usare le formule per calcolare elevazione e azimut della parabola.

Modificato 1 Settembre 2008 da JumpJack_

[Oper]

Non è un programma che si usa tutti i giorni... ma potrebbe comunque essere utile averlo nei nostri "coltellini multiuso tecnologici", altrimenti noti come cellulari : un programma che permette di calcolare come orientare la parabola, in base alla posizione in cui ci si trova... che naturalmente verrebbe rilevata tramite GPS in caso fosse disponibile!

Tecnicamente non è difficile da realizzare, in un qualunque linguaggio: si tratta solo di trovare le formule per calcolare elevazione e azimut della parabola. Da qualche parte le dovrei avere....

Su wikipedia

v1 = 6.612 * cos(LAT)*cos(LONG-SATLONG)-1

v2 = 6.612 * sqrt( 1-(cos(LAT)^2) * (cos(LONG-SATLONG))^2 )

Elevazione = atan(v1/v2)

Azimut = 180 + atan( tan(LONG-SATLONG) / sin(SATLONG) )

POLARIZZAZIONE = -atan( sin(LONG-SATLONG)/tan(LAT) );

dove:

LONG è la longitudine del luogo dove è posizionata la parabola;

SATLONG è la longitudine del satellite;

LAT è la latitudine del luogo dove è posizionata la parabola.

sqrt sta per radice quadrata

Si tratta di trovare SATLONG (per hotbird 13 gradi est)

e vedere come fornisce i valori i vari atan

Modificato 1 Settembre 2008 da Oper

[JumpJack_]

Mi è venuto in mente che si potrebbe anche aggiungere un'altra cosa al programma: una bussola!

Esiste un algoritmo per determinare la direzione del nord in base alla posizione del sole e all'ora attuale. Pero' di questo non riesco a trovare le formule!

Supponendo di disegnare sullo schermo un cerchio, col Sole posto sull'estremo superiore, vorrei disegnare una freccia che dal centro del cerchio punta verso nord: che angolo deve avere rispetto alla verticale?

Ci sono un paio di sorgenti di programmi-bussola, ma non riesco a estrapolarne l'algoritmo, sono troppo lunghi...

http://tions.net/CA256EA900408BD5/vwWWW/outdoor~01~02

http://www.qcontinuum.org/compass/

Ho anche scritto a uno degli autori ma ancora non risponde.

[naples00]

Gran bella idea... Fenomenale

[giuppe92]

La bussola sarebbe il massimo, e per di più senza gps. Ti aiuto nella ricerca!

[JumpJack_]

Trovato!

http://www.astro.uio.no/~bgranslo/aares/calculate.html

E che ci vuole!

Bisogna "solo" implementare questo sproposito di calcoli, per determinare l'azimut del sole a una certa ora!

[memoryn70]

Trovato!

http://www.astro.uio.no/~bgranslo/aares/calculate.html

E che ci vuole!

Bisogna "solo" implementare questo sproposito di calcoli, per determinare l'azimut del sole a una certa ora!

Eh già che ci vuole

Saranno un centinaio di calcoli...

Però è da sviluppare sicuro...Molto utile sarebbe

Modificato 4 Settembre 2008 da memoryn70

[JumpJack_]

Eh già che ci vuole

Saranno un centinaio di calcoli...

Però è da sviluppare sicuro...Molto utile sarebbe

il problema è che neanche tornano....

Il primo valore, d0, cioe' i giorni trascorsi dall'1/1/2000, non mi vengono ,con quella formula.

Pero' ho ficcanasato nei sorgenti javascript di una pagina web, e sono riuscito a calcolare la Julian Date corrispondente all'ora attuale (in BASIC):

if m < 2 then
y=y-1
m=m+12
end if
A= int(y/100)
B= 2- A + Int(A/4)
Day = Day + Hr/24 + Min/(24*60) + Sec/(24*60*60)
JD = Int(365.25*y) + Int(30.6001 * (m+ 1))+B + Day + 1720994.5 ' Julian date
JD0 = JD - Hr/24 + Min/(24*60) + Sec/(24*60*60) ' GMT Julian date
JD2000 = 2451544.5  ' Julian date since 2000

La Julian Date serve per calcolare il Sidereal Time (da cui poi si ricava la posizione del sole), ma al momento non ci riesco.

Questo dovrebbe essere l'algoritmo, tratto da qui:

function calcST(jdi) {
// calculate the siderial time at Greenwich in degrees at 0hUT
t1 = (jdi-2451545.0)/36525;
var st = 100.46061837+36000.77053608*t1+0.000387933*t1*t1-t1*t1*t1/38710000;
// correct for other time and time zone 
// remember that julian day is for 0h UT (add in time plus time zone (negative =west))
// The following gives the UT for the time, t in time zone tzone
ut = (t-tzone)
// example if tzone = -4 hours and time = 15 hours (3 pm) then UT = 15+4 = 19 hours (remember st is in degrees)
st = st + 1.002738*ut*15
// Now calculate local siderial time which is your longitude less than the st at greenwich
st = st+lngtd
// Reduce the angle to 0-360
with(Math)  {	
if (st < 0) {
	n = floor(abs(st/360));
	st += ((n+1)*360);
	};
var hr = floor(st/15);
	var mn = floor((st % 15)*4);
var sc = round((st-(hr*15)-(mn/4))*240);
if (hr > 24) {
	n = floor(hr/24); 
	hr = hr - n*24;
	};
siderial = ""+hr+"h"+mn+"m"+sc+"s";

}
return siderial;
}

"jdi" non dovrebbe essere altro che JD0, calcolato prima.

[JumpJack_]

Forse questa funzione consente di fare tutto in un colpo solo... ma ho dei problemi a capirla/convertirla, chi mi dà una mano?!?

function azimuth(lg,la,ye,mo,da,ho,mi,zo)
{
with (Math) {
var uu=ut(ho,mi,zo);
var jj=jd(ye,mo,da,uu);
var T=jj/36525;
var k=PI/180.0;
var M=357.5291+35999.0503*T-0.0001559*T*T-0.00000045*T*T*T
M=M % 360
var Lo=280.46645+36000.76983*T+0.0003032*T*T
Lo=Lo % 360
var DL=(1.9146-0.004817*T-0.000014*T*T)*sin(k*M)+(0.019993-0.000101*T)*sin(k*2*M)+0.00029*sin(k*3*M)
var L=Lo+DL
var eps=23.43999-0.013*T
var delta=(1/k)*asin(sin(L*k)*sin(eps*k))
var RA=(1/k)*atan2(cos(eps*k)*sin(L*k),cos(L*k))
RA=(RA+360) % 360
var GMST=280.46061837+360.98564736629*jj+0.000387933*T*T-T*T*T/38710000
GMST=(GMST+360) % 360
var LMST=GMST+lg
var H=LMST-RA
var eqt=(Lo-RA)*4
var azm=(1/k)*atan2(-sin(H*k),cos(la*k)*tan(delta*k)-sin(la*k)*cos(H*k))
azm=(azm+360) % 360
return azm
}
}

}
function jd(y,m,d,u)
{
return (367*y)-Math.floor((7/4)*(Math.floor((m+9)/12)+y))+Math.floor(275*m/9)+d-730531.5+(u/24)
}

function ut(h,m,z)
{
return (h-z+m/60);
}

Questa è la pagina:

http://www.geocities.com/senol_gulgonul/sun/

[JumpJack_]

Sono riuscito a venirne a capo... barando!

A districarmi nelle centinaia di formule e versioni diverse che ho trovato in giro non ci sono riuscito... ma poi mi sono reso conto che NON mi serviva a niente!!

Si', perche' per poter usare il cellulare per trovare il nord.... bisogna VEDERE fisicamente il sole... quindi non c'e' nessun bisogno di CALCOLARE dove sia.

In realtà, non è strettamente necessario il cellulare, basta un orologio a lancette, ma col cellulare si puo' semplificare la cosa.

Ecco il sorgente:

import graphics, e32, appuifw
from math import pi,cos,sin


#Define the exit function
app_lock=e32.Ao_lock()

def quit():
app_lock.signal()

def NorthAngle(h,m,s):
hd=0.0
hd=hd+h+m/60.0+s/3600.0 # Ora in formato decimale
#print "hd=",hd
hd=(hd/12.0-int(hd/12.0))*12.0 # modulo 12
#print hd
ang=hd*360/12.0 # angolo corrispondente all'ora
#print ang
bis=ang/2.0 #' bisettrice = sud
#print bis
if h<=12:
  north=bis+180 # nord=bisettrice+180 di mattina,
else:
  north=bis # =bisettrice di pomeriggio
print h,m,s,"= orol:",north,ang
north=450-north ' Da cerchio-orologio a cerchio-trigonometrico
ang=450-ang ' Da cerchio-orologio a cerchio-trigonometrico
print "trigo:",north,ang
north=north*pi/180.0 # Converte in radianti
ang=ang*pi/180.0 # Converte in radianti
return north,ang	

appuifw.app.exit_key_handler=quit

canvas=appuifw.Canvas()
appuifw.app.body=canvas
appuifw.app.screen="normal"

#Line
nfactor=80
hfactor=20
#for i in range(0,24):
n,h=NorthAngle(16,0,0)
print n,h
x=cos(n)*nfactor
y=sin(n)*nfactor
print cos(n)*nfactor,sin(n)*nfactor
canvas.line((88,72,88+x,72-y), 0)

x=cos(h)*hfactor
y=sin(h)*hfactor
print cos(n)*hfactor,sin(n)*hfactor
canvas.line((88,72,88+x,72-y), 2)
e32.ao_sleep(2)

Il programmino disegna due righe: quando quella piccola punta verso il sole, quella grande punta verso nord. Da qui si puo' poi disegnare tutta la bussola, ovviamente.

...solo che al momento l'orario va scritto a mano nel sorgente, perche' nn so usare la funzione TIME (non so nemmeno se esiste, dov'e',...)

Aiuti?Idee?

[Oper]

Conoscendo le posizioni a casa mia, se indico le 8 di mattino che so esattamente dove si trova il sole, (so anche dove è il nord), la linea grande mi tira a sud.

Praticamente la grande punta sempre a sud con tutti gli orari che imposto.

[edit]

nel calcolo di x e y devi prendere il valore negativo:

x= - cos(n)*nfactor

y= - sin(n)*nfactor

e nella funzione NorthAngle(h,m,s)

if h<12:

e non <=

così mi funziona.

Ho anche aggiunto l'ora corrente che viene passata alla funzione e viene mostrata a schermo.

Queto è il listato modifica per vedere meglio le 2 linee:

import graphics, e32, appuifw, sys, time
from math import pi,cos,sin


#Define the exit function
app_lock=e32.Ao_lock()

def quit():
app_lock.signal()
sys.exit()

def NorthAngle(h,m,s):
hd=0.0
hd=hd+h+m/60.0+s/3600.0 # Ora in formato decimale
#print "hd=",hd
hd=(hd/12.0-int(hd/12.0))*12.0 # modulo 12
#print hd
ang=hd*360/12.0 # angolo corrispondente all'ora
#print ang
bis=ang/2.0 #' bisettrice = sud
#print bis
if h<12:
  north=bis+180 # nord=bisettrice+180 di mattina,
else:
  north=bis # =bisettrice di pomeriggio
print h,m,s,"= orol:",north,ang
north=450-north # Da cerchio-orologio a cerchio-trigonometrico
ang=450-ang # Da cerchio-orologio a cerchio-trigonometrico
print "trigo:",north,ang
north=north*pi/180.0 # Converte in radianti
ang=ang*pi/180.0 # Converte in radianti
return north,ang

appuifw.app.exit_key_handler=quit

canvas=appuifw.Canvas()
appuifw.app.body=canvas
appuifw.app.screen="normal"

#Line
nfactor=80
hfactor=40
#for i in range(0,24):
data=time.ctime()
val=data.split()
_ora=int(val[3][:2])
_min=int(val[3][3:5])
_sec=int(val[3][6:8])

n,h=NorthAngle(_ora,_min,_sec)
print n,h
x=-cos(n)*nfactor
y=-sin(n)*nfactor
print cos(n)*nfactor,sin(n)*nfactor
canvas.line((88,72,88+x,72-y), 0x000000,0x000000,2)

x=cos(h)*hfactor
y=sin(h)*hfactor
print cos(n)*hfactor,sin(n)*hfactor
canvas.line((88,72,88+x,72-y), 0xFF0000,0xFF0000,4)

canvas.text((1,140),u''+val[3])
e32.ao_sleep(2)

Modificato 5 Settembre 2008 da Oper

[memoryn70]

Provo subito ...

[memoryn70]

Provo subito ...

Molto bene! A me cosi funziona!

[JumpJack_]

Grazie per i suggerimenti, avevo giusto bisogno di sapere:

- come leggere l'ora

- come disegnare linee di colore diverso

- come scrivere testo sullo schermo grafico

Pero' non ho provato la tua versione, perche' nel frattempo ho fatto altre modifiche alla mia, come la visualizzazione della direzione della parabola. Ma... sei sicuro che funzioni bene la tua?!? Non capisco perche' inverti anche il segno di X. Di Y va bene perche' l'origine è in alto, ma di X.... Boh, pero' la mia la devo ancora provare "sul campo", finora l'ho solo provata "al banco". ;-)

Adesso vedo di aggiungere un paio di icone per indicare qual è la linea del sole e quale quella della parabola... e poi dovro' cercare di tradurre il tutto in una midlet!

[Oper]

Io nel frattempo ho fatto un programma a se che funziona solo da bussola alla faccia di SunCompass che è a pagamento

Se è il caso lo pubblico. Dimmi tu.

L'ho un po reso grafico (ma non più di tanto).

[JumpJack_]

Ok, ecco il programma finale:

Mettete le icone che preferite per sole e parabola in c:\nokia\images, purche si chiamino parab.png e sun.png

# pySatFinder - freeware program by Luca Cassioli 2008
# Feel free to modify the source at your wish, as long
# as you keep me informed if you publish it:
# jumpjack at libero  dot it
#
# This program allows finding out right direction where to point toward
# a satellite dish, given dish position, without requiring a compass
# and any printed table: just input your longitude and satellite longitude,
# position phone horizontally and point the sun-line toward the sun: the
# line labeled with the parabolic antenna gives the direction where to
# point your antenna.
#
# Program can be extended to retrieve location from GPS receiver.
#
# ALGORITHM
# To find North without a compass, you just need a clock:
# - point the HOUR hand towards sun (*)
# - if time is past 12, SOUTH(**) is indicated by bisector of angle among hand and 12:00 position
# - if time is before 12, add 180° to bisector value.
# (*) This method is usally used to determine SOUTH direction, as Sun is never
# on North in northern level: at 12:00 it's exactly on South.
# (**) You can use a little stick placed vertically near the clock to determine
# sun direction from shadow direction.

import graphics, e32, appuifw
from math import pi,cos,sin,tan,atan
from time import *
from e32db import format_time
from graphics import Image

# Default values
LONG=12
SATLONG=13

# Constant values
nfactor=55
hfactor=55
CenterX = 90
CenterY = 70
radius = nfactor
DisplayTime= ""


#Define the exit function
app_lock=e32.Ao_lock()

def quit():
   app_lock.signal()

def automask(im):
#(Found on [url="http://snippets.dzone.com/posts/show/1383)"]http://snippets.dzone.com/posts/show/1383)[/url]
 width, height = im.size
 mask = Image.new(im.size, '1') # black and white
 tran = im.getpixel((0,0))[0]   # transparent top-left
 for y in range(height):
     line = im.getpixel([(x, y) for x in range(width)])
     for x in range(width):
         if line[x] == tran:
             mask.point((x,y), 0)  # mask on the point
 return mask

def NorthAngle():
   global DisplayTime
   t = time()
   h=int(strftime('%H'))
   m=int(strftime('%M'))
   s=int(strftime('%S'))    

   DisplayTime=repr(h)+":"+repr(m)+":"+repr(s)

   hd=0.0
   hd=hd+h+m/60.0+s/3600.0 # Ora in formato decimale
   #print "hd=",hd
   hd=(hd/12.0-int(hd/12.0))*12.0 # modulo 12
   #print hd
   ang=hd*360/12.0 # angolo corrispondente all'ora
   #print ang
   bis=ang/2.0 # bisettrice = sud
   #print bis
   if h<12:
     north=bis # nord=bisettrice di mattina,
   else:
     north=bis+180 # =bisettrice+180 di pomeriggio
   #print h,int(ang),int(bis),int(north),
   #print h,m,s,"= orol:",int(north),int(ang)
   north=450-north # Da cerchio-orologio a cerchio-trigonometrico
   ang=450-ang # Da cerchio-orologio a cerchio-trigonometrico
   #print int(ang),int(north)
   #print "trigo:",int(north),int(ang)
   north=north*pi/180.0 # Converte in radianti
   ang=ang*pi/180.0 # Converte in radianti
   return north,ang    

def circle(c,x,y,radius=5, outline=0, fill=0x2222ff, width=1):
     c.ellipse((x-radius, y-radius, x+radius, y+radius), outline, fill, width) 

def DrawArrows():
 global LONG,SATLONG,CenterX,CenterY,radius,nfactor,hfactor,pi,DisplayTime

 ###################################################
 # Find north direction and current-time direction
 north,hourangle=NorthAngle()
 ###################################################

 circle(canvas,CenterX,CenterY,radius)

 # Load icons
 pic_sun=graphics.Image.open("c:\\nokia\\images\\sun.png")
 pic_par=graphics.Image.open("c:\\nokia\\images\\parab.png")

 # Draw North line
 x=cos(north)*nfactor
 y=sin(north)*nfactor
 canvas.line((CenterX,CenterY,CenterX+x,CenterY-y), 0x000000,0x000000,4)
 # Place letter outside of the circle (taht's why "nfactor+10"):
 canvas.text((CenterX+cos(north)*(nfactor+10),CenterY+sin(north)*(nfactor+10)),u'N')

 # Draw current time line (it must point toward sun)
 x=cos(hourangle)*hfactor
 y=sin(hourangle)*hfactor
 canvas.line((CenterX,CenterY,CenterX+x,CenterY-y) , 0xFF0000,0xFF0000,2)
 mask=automask(pic_sun)
 canvas.blit(pic_sun,target=(CenterX+x,CenterY-y),mask=mask)  


 LONG=LONG*pi/180
 SATLONG=SATLONG*pi/180
 AzimutParabola = pi + atan( tan(LONG-SATLONG) / sin(SATLONG) )
 #print "AZP=",AzimutParabola*180/pi
 AzimutParabolaNord=north-AzimutParabola
 #print "AZP=",AzimutParabolaNord*180/pi

 # Draw antenna direction line
 x=cos(AzimutParabolaNord)*nfactor
 y=sin(AzimutParabolaNord)*nfactor
 canvas.line((CenterX,CenterY,CenterX+x,CenterY-y) , 0xFF0000,0xFF0000,6)
 mask=automask(pic_par)
 canvas.blit(pic_par,target=(CenterX+x,CenterY-y),mask=mask)

 canvas.text((1,11),u'Time:')
 canvas.text((1,21),u''+DisplayTime)
 canvas.text((1,38),u'Antenna:')
 canvas.text((1,48),u''+repr(int(AzimutParabola*180/pi)))




# Definer GUI
appuifw.app.exit_key_handler=quit
canvas=appuifw.Canvas()
appuifw.app.body=canvas
appuifw.app.screen="normal"
appuifw.app.menu=[(u"Refresh",DrawArrows)]



# Ask user input
LONG=appuifw.query(u'Enter your longitude', 'number',LONG)
SATLONG=appuifw.query(u'Enter Sat longitude (hotbird=13)', 'number',SATLONG)
LONG=int(LONG)
SATLONG=int(SATLONG)
e32.ao_sleep(1) # Wait a bit to prevent dialog from deleting image!

DrawArrows()

app_lock.wait() 

nota: qualcuno sa perche' quando ridisegno lo schemo, il cerchio non compare?!?

Oper, pubblica pure quello che ti pare!

Modificato 6 Settembre 2008 da JumpJack_

[Oper]

...

Oper, pubblica pure quello che ti pare!

Questo è quello che ho fatto io:

si chiama PyCompass e simula solamente la bussola-

Modificato 6 Settembre 2008 da Oper

[Oper]

Ho ancora adattato il programma della bussola aggiungendo la parte relativa alla parabola e ho creato anche un filedi opzioni con i dati relativi alle longitudini.

Però una cosa mi lascia perplesso:

come la mettiamo con l'ora legale e l'ora solare? si tratta di un'ora in più o in meno e quindi il puntamento dovrebbe andare a farsi benedire.

Che ne pensi Jump ?

[edit]

ancora una cosa non mi convince:

nella funzione DrawArrows usi:

LONG=LONG*pi/180

SATLONG=SATLONG*pi/180

ma dopo il refresh, tali valori cambiano, infatti da 193 il valore passa a 192 (saranno gli arrotondamenti).

Allora ho inserito

LONG=orig_LONG*pi/180

SATLONG=orig_SATLONG*pi/180

dove i valori orig_LONG e orig_SATLONG vengono caricati solo quando si cambiano i parametri.

Modificato 7 Settembre 2008 da Oper

[JumpJack_]

Ho ancora adattato il programma della bussola aggiungendo la parte relativa alla parabola e ho creato anche un filedi opzioni con i dati relativi alle longitudini.

Però una cosa mi lascia perplesso:

come la mettiamo con l'ora legale e l'ora solare? si tratta di un'ora in più o in meno e quindi il puntamento dovrebbe andare a farsi benedire.

Che ne pensi Jump ?

Penso che stai facendo un ottimo lavoro... e quindi mi sa che lo lascio continuare a te!

Quanto all'ora legale, bisognerà prevedere un'immissione dell'utente per specificare se è attiva o no: se è attiva, vuol dire che l'orologio segna un'ora in piu', quindi bisogna adeguare il programma di conseguenza.

[edit]

ancora una cosa non mi convince:

nella funzione DrawArrows usi:

LONG=LONG*pi/180

SATLONG=SATLONG*pi/180

ma dopo il refresh, tali valori cambiano, infatti da 193 il valore passa a 192 (saranno gli arrotondamenti).

Allora ho inserito

LONG=orig_LONG*pi/180

SATLONG=orig_SATLONG*pi/180

dove i valori orig_LONG e orig_SATLONG vengono caricati solo quando si cambiano i parametri.

A dire il vero, non serve a niente che LONG e SATLONG vengano ricalcolati a ogni refresh, meglio mettere l'assegnazione direttamente fuori, a inizio programma.

Pero' devo ancora capire perche' col refresh non mi si ridisegna il cerchio...

Senti, ma saresti capace anche di aggiungere la parte che legge le coordinate dal GPS? Io so farlo per il gps bluetooth esterno, ma non ho ancora capito come usare la libreria generica che permette di usare indipendentemente il GPS interno o esterno:

https://www.iyouit.eu/portal/Software.aspx

Altra cosa: avevo sbagliato l'algoritmo: non è la X che deve cambiare segno, è solo che ho invertito tra mattina e pomeriggio nell'aggiungere i 180° alla bisettrice. Di mattina, la bisettrice tra ora attuale e mezzodi' indica il NORD, mentre al pomeriggio indica il SUD! (contando l'angolo sempre in senso orario a partire dalle 12).

Infine: credo che nell'emisfero sud tutto questo funzioni al contrario, quindi bisognerà tener conto anche della LATITUDINE.

[JumpJack_]

ah, mancano ancora delle cose per finire il programma, prima di aggiungere il GPS: l'ALTEZZA e lo SKEW dell'antenna (li trovi su wikipedia).

Pero' ci vorrà un'immagine che chiarisca da che parte ruotare l'antenna dell'opportuno angolo di SKEW (anche se in italia il suo valore è del tutto trascurabile).

[Oper]

La parte relativa all'ora legale e solare l'avevo già implementata proprio come ora hai suggerito. Eheheheh

Per quanto riguarda gli altri dati, (le coordinate con un dispositivo esterno GPS lo so fare - per quello interno, mai provato - ho un 6600)

attendo lumi e soprattutto formule.

P.S.

ho dato un'occhiata al tuo listato per quanto riguarda il refresh del cerchio e sinceramente non me lo so spiegare neanche io.

[JumpJack_]

Per quanto riguarda gli altri dati, (le coordinate con un dispositivo esterno GPS lo so fare - per quello interno, mai provato - ho un 6600)

attendo lumi e soprattutto formule.

ottimo, io me li aspettavo da te!

Io mi sono arenato dopo aver scoperto che con quelle librerie esistono due metodi da chiamare, di cui uno... non funziona se il GPS non ha al momento dati validi, per cui va "risvegliato" con un altro metodo!

Boh, ci ho capito molto poco... e siccome ho anch'io un 6600 (oltre a un 6680), non posso fare prove pratiche.

Ne ho discusso un po' sul nokia forum, poi me so stufato...

[Oper]

....

nota: qualcuno sa perche' quando ridisegno lo schemo, il cerchio non compare?!?

Oper, pubblica pure quello che ti pare!

Ho capito dove sta il problema:

è la chiamata alle immagini che svuota il canvas.

circle(canvas,CenterX,CenterY,radius) # Load icons

pic_sun=graphics.Image.open("c:\\nokia\\images\\sun.png")

pic_par=graphics.Image.open("c:\\nokia\\images\\parab.png")

prova così

pic_sun=graphics.Image.open("c:\\nokia\\images\\sun.png")

pic_par=graphics.Image.open("c:\\nokia\\images\\parab.png")

circle(canvas,CenterX,CenterY,radius) # Load icons

e stupisciti.

[Oper]

Guarda qua.

http://www.zeusnews.com/index.php3?ar=stampa&cod=8068

Che dici se implementiamo una cosa del genere anche per trovare determinate coordinate?

(il tecnico dei numeri sei tu )

[JumpJack_]

Ho capito dove sta il problema:

è la chiamata alle immagini che svuota il canvas.

circle(canvas,CenterX,CenterY,radius) # Load icons

pic_sun=graphics.Image.open("c:\\nokia\\images\\sun.png")

pic_par=graphics.Image.open("c:\\nokia\\images\\parab.png")

prova così

pic_sun=graphics.Image.open("c:\\nokia\\images\\sun.png")

pic_par=graphics.Image.open("c:\\nokia\\images\\parab.png")

circle(canvas,CenterX,CenterY,radius) # Load icons

e stupisciti.

questa poi è proprio assurda!!!

Guarda qua.

http://www.zeusnews.com/index.php3?ar=stampa&cod=8068

Che dici se implementiamo una cosa del genere anche per trovare determinate coordinate?

(il tecnico dei numeri sei tu )

interessante, potrebbe venirne fuori il "GPS dei poveri": imposti la destinazione, punti il sole, e ti dice da che parte devi andare!

Devo trovare le formule (se qualcuno le ha gia calcolate...) per determinare l'azimuth di un punto qualunque rispetto a un punto dato. Su un piano sarebbe facile... ma dicono che la terrà e' tonda...

mmmh... pero'.... una volta che mi sposto dal punto di cui conosco le coordinate... come faccio a sapere le nuove coordinate?

forse le posso ottenere sempre dal sole... di cui pero' dovrei calcolare anche l'altezza sull'orizzonte; quindi ci vorrebbe anche un'altra schermata....

Vabbe', una cosa per volta.

Azimuth di una posizione rispetto a un'altra.

Searching...