177 lines
7.4 KiB
Python
Executable File
177 lines
7.4 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Beepy: a Python standalone script
|
|
# to synchronize time on BPC-enabled wristwatches via headphones
|
|
# Depends on pyaudio and ntplib
|
|
# Created by Luxferre in 2024, released into public domain
|
|
|
|
import pyaudio, ntplib, math, array, time, datetime
|
|
|
|
OP_FREQ = 68500/5 # emitted frequency, Hz
|
|
|
|
# parity calculation helper
|
|
def calc_parity(vals):
|
|
i = 0
|
|
for val in vals:
|
|
i ^= (val & 1) ^ ((val >> 1) & 1)
|
|
return i
|
|
|
|
# internal time representation from unix time
|
|
# only fetches the fields necessary for BPC implementation
|
|
def intreptime(unixtm):
|
|
res = {}
|
|
tm = time.gmtime(unixtm)
|
|
res['year'] = tm.tm_year % 100
|
|
res['month'] = tm.tm_mon
|
|
res['mday'] = tm.tm_mday
|
|
res['hour'] = tm.tm_hour - 1
|
|
if res['hour'] < 0:
|
|
res['hour'] = 23
|
|
res['minute'] = tm.tm_min
|
|
res['second'] = tm.tm_sec
|
|
# in Python, Monday is 0; in BPC, Sunday is 7 and Monday is 1
|
|
res['wday'] = tm.tm_wday + 1
|
|
res['unix'] = int(unixtm) # save the unix time representation
|
|
return res
|
|
|
|
# time fetching part (returns China standard time)
|
|
def fetchtime(params = {}):
|
|
delta = 0.0
|
|
offset = 28800 # BPC time is UTC+8
|
|
if 'delta' in params:
|
|
delta = float(params['delta']) / 1000
|
|
if 'offset' in params: # base offset from UTC in seconds
|
|
offset = int(params['offset'])
|
|
if 'server' in params and params['server'] is not None: # NTP server set
|
|
ntpver = 3
|
|
if 'version' in params:
|
|
ntpver = params['version']
|
|
c = ntplib.NTPClient()
|
|
resp = c.request(params['server'], version=ntpver)
|
|
unixtm = resp.tx_time
|
|
else: # use current system time by default
|
|
unixtm = time.time()
|
|
unixtm += offset + delta # account for delta
|
|
return intreptime(unixtm)
|
|
|
|
# timecode generation part
|
|
# accepts the result of fetchtime function
|
|
def gentimecode(ts):
|
|
# convert ts['hour'] to am/pm (BPC variant)
|
|
pmflag = 0
|
|
ampmhr = ts['hour'] % 12
|
|
if ts['hour'] >= 12:
|
|
pmflag = 1
|
|
# init the timecode for the whole minute
|
|
timecode = [4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
4,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
4,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
|
|
# populate hour
|
|
timecode[3] = timecode[23] = timecode[43] = ampmhr >> 2
|
|
timecode[4] = timecode[24] = timecode[44] = ampmhr & 3
|
|
# populate minute
|
|
timecode[5] = timecode[25] = timecode[45] = (ts['minute'] >> 4) & 3
|
|
timecode[6] = timecode[26] = timecode[46] = (ts['minute'] >> 2) & 3
|
|
timecode[7] = timecode[27] = timecode[47] = ts['minute'] & 3
|
|
# populate weekday
|
|
timecode[8] = timecode[28] = timecode[48] = (ts['wday'] >> 2) & 1
|
|
timecode[9] = timecode[29] = timecode[49] = ts['wday'] & 3
|
|
# populate am/pm flag and first part parity
|
|
timecode[10] = (pmflag << 1) | calc_parity(timecode[1:10])
|
|
timecode[30] = (pmflag << 1) | calc_parity(timecode[21:30])
|
|
timecode[50] = (pmflag << 1) | calc_parity(timecode[41:50])
|
|
# populate day of month
|
|
timecode[11] = timecode[31] = timecode[51] = ts['mday'] >> 4
|
|
timecode[12] = timecode[32] = timecode[52] = (ts['mday'] >> 2) & 3
|
|
timecode[13] = timecode[33] = timecode[53] = ts['mday'] & 3
|
|
# populate month
|
|
timecode[14] = timecode[34] = timecode[54] = ts['month'] >> 2
|
|
timecode[15] = timecode[35] = timecode[55] = ts['month'] & 3
|
|
# populate year
|
|
yhbit = ts['year'] >> 6
|
|
timecode[16] = timecode[36] = timecode[56] = (ts['year'] >> 4) & 3
|
|
timecode[17] = timecode[37] = timecode[57] = (ts['year'] >> 2) & 3
|
|
timecode[18] = timecode[38] = timecode[58] = ts['year'] & 3
|
|
# populate the high year bit and the second part parity
|
|
timecode[19] = (yhbit << 1) | calc_parity(timecode[11:20])
|
|
timecode[39] = (yhbit << 1) | calc_parity(timecode[31:40])
|
|
timecode[59] = (yhbit << 1) | calc_parity(timecode[51:60])
|
|
return timecode
|
|
|
|
# generate an audio data chunk of specified duration
|
|
def gen_audio(duration, freq=OP_FREQ, sr=48000):
|
|
smps = int(sr * duration)
|
|
# create the sine wave array for the whole second
|
|
rawdata = []
|
|
for k in range(0, sr):
|
|
v = math.sin(2 * math.pi * k * freq / sr)
|
|
if k <= smps: # reduced power mode in the beginning
|
|
v *= 0.1
|
|
rawdata.append(int(v * 32767)) # max gain
|
|
return array.array('h', rawdata).tobytes()
|
|
|
|
# global buffers for audio data and current position
|
|
curstream = b''
|
|
streampos = 0
|
|
|
|
# bitcode transmission callback
|
|
def bitcode_transmit(in_data, frame_count, time_info, status):
|
|
global curstream, streampos
|
|
framelen = frame_count << 1 # 2 bytes per frame as we're using int16
|
|
framedata = curstream[streampos:streampos+framelen]
|
|
streampos += framelen
|
|
return (framedata, pyaudio.paContinue)
|
|
|
|
# main logic is here
|
|
def start_transmission(timeparams):
|
|
global curstream
|
|
p = pyaudio.PyAudio()
|
|
sr = timeparams['sr']
|
|
mins = timeparams['duration']
|
|
bpc_bit_chunks = [ # pregenerate the chunks
|
|
gen_audio(0.1, OP_FREQ, sr), # data bits 00
|
|
gen_audio(0.2, OP_FREQ, sr), # data bits 01
|
|
gen_audio(0.3, OP_FREQ, sr), # data bits 10
|
|
gen_audio(0.4, OP_FREQ, sr), # data bits 11
|
|
gen_audio(0, OP_FREQ, sr) # transmission start chunk
|
|
]
|
|
ts = fetchtime(timeparams) # get the current timestamp
|
|
print('Time fetched (Unix):', ts['unix'])
|
|
bitcode = gentimecode(ts)[ts['second']+1:] # slice the rest of current minute
|
|
nextmin = ts['unix'] - ts['second'] # rewind to start of the minute
|
|
for i in range(0, mins): # generate bitcode for the next N minutes
|
|
nextmin += 60 # calc the next minute
|
|
bitcode += gentimecode(intreptime(nextmin))
|
|
print("Transmitting... Press Ctrl+C to exit")
|
|
# wait for the next second to start (roughly, with all the call overhead)
|
|
time.sleep((1 - datetime.datetime.now().microsecond/1000000)/2)
|
|
# open a PyAudio stream with callback
|
|
stream = p.open(format=pyaudio.paInt16, channels=1, frames_per_buffer=16384,
|
|
rate=sr, output=True, stream_callback=bitcode_transmit)
|
|
curstream = bpc_bit_chunks[bitcode.pop(0)] # preload the first second
|
|
while stream.is_active(): # wait for the stream to finish
|
|
if len(bitcode) > 0: # feed the stream in parallel
|
|
curstream += bpc_bit_chunks[bitcode.pop(0)]
|
|
time.sleep(0.75) # feeding the stream should be faster than realtime
|
|
# close audio
|
|
stream.stop_stream()
|
|
stream.close()
|
|
p.terminate()
|
|
print("Transmission ended")
|
|
|
|
if __name__ == '__main__':
|
|
from argparse import ArgumentParser
|
|
parser = ArgumentParser(description='Beepy: an opensource longwave time synchronizer for BPC-enabled watches and clocks', epilog='(c) Luxferre 2024 --- No rights reserved <https://unlicense.org>')
|
|
parser.add_argument('-t', '--duration', type=int, default=30, help='Transmission duration (in minutes, default 30)')
|
|
parser.add_argument('-d', '--delta', type=int, default=0, help='Manual delta correction (in ms, must be determined individually, 0 by default)')
|
|
parser.add_argument('-o', '--tz-offset', type=float, default=9, help='Timezone offset from UTC to transmit (in hours, default 9 - corresponds to JST)')
|
|
parser.add_argument('-r', '--sample-rate', type=int, default=48000, help='Transmission sampling rate (in Hz, default 48000)')
|
|
parser.add_argument('-s', '--ntp-server', type=str, default=None, help='NTP server to sync from (if not specified then will sync from the local system time)')
|
|
parser.add_argument('-n', '--ntp-version', type=int, default=4, help='NTP protocol version to use (default 4)')
|
|
args = parser.parse_args()
|
|
params = { # populate parameters from the command line
|
|
'server': args.ntp_server, 'version': args.ntp_version,
|
|
'delta': args.delta, 'offset': int(args.tz_offset * 3600),
|
|
'sr': args.sample_rate, 'duration': args.duration
|
|
}
|
|
start_transmission(params)
|