Implement server-side TimeSlot calculation

src/frontend/assets/index.html

@@ -214,7 +214,7 @@ <h3>Status</h3>
             </div>
             <div class="timeslots">
               <span v-for="(timeslot, index) in status.timeslots">
-                <div class="timeslot" v-bind:class="{ 'enabled': timeslot, 'active': index == activeTimeslot}">
+                <div class="timeslot" v-bind:class="{ 'enabled': timeslot, 'active': index == status.timeslot}">
                   {{index.toString(16).toUpperCase()}}
                 </div>
               </span>

src/frontend/assets/main.js

@@ -2,7 +2,6 @@ var vm = new Vue({
     el: "#wrapper",
     created() {
         this.connect();
-        this.update_timeslot();
     },
     data: {
         connected: false,
@@ -17,7 +16,6 @@ var vm = new Vue({
             raspager: {}
         },
         status: {},
-        activeTimeslot: 0,
         message: "",
         addr: localStorage ? (localStorage.pager_addr || 0) : 0
     },
@@ -102,13 +100,6 @@ var vm = new Vue({
 
             this.send(req);
             this.message = "";
-        },
-        update_timeslot: function(event) {
-            var date = Date.now();
-            var timeslot = (Math.floor(date / 100) / 64) & 0b1111;
-            var next_timeslot = (((Math.floor(date / 100) / 64) + 1) * 64) * 100;
-            this.activeTimeslot = timeslot;
-            setTimeout(this.update_timeslot, next_timeslot - date);
         }
     }
 });

src/main.rs

@@ -50,6 +50,8 @@ fn main() {
     let mut config = Config::load();
     let scheduler = Scheduler::new(&config);
 
+    thread::spawn(timeslot_updater);
+
     let mut restart = true;
     while restart {
         let (stop_conn, conn_thread) = Connection::start(config.clone(), scheduler.clone());
@@ -125,3 +127,11 @@ fn main() {
     info!("Terminating... 73!");
     thread::sleep(time::Duration::from_millis(1000));
 }
+
+pub fn timeslot_updater() {
+    loop {
+        let timeslot = pocsag::TimeSlot::current();
+        status!(timeslot: timeslot);
+        thread::sleep(timeslot.next().duration_until());
+    }
+}

src/pocsag/mod.rs

@@ -7,7 +7,7 @@ pub mod encoding;
 pub use self::generator::Generator;
 pub use self::message::{Message, MessageSpeed, MessageType, MessageFunc};
 pub use self::scheduler::Scheduler;
-pub use self::timeslots::TimeSlots;
+pub use self::timeslots::{TimeSlots, TimeSlot};
 pub use self::encoding::Encoding;
 
 pub trait MessageProvider {

src/pocsag/timeslots.rs

@@ -14,7 +14,7 @@ fn deciseconds(duration: Duration) -> u64 {
     seconds * 10 + deciseconds
 }
 
-#[derive(PartialEq)]
+#[derive(Serialize, Clone, Copy, PartialEq)]
 pub struct TimeSlot(usize);
 
 impl TimeSlot {
@@ -29,6 +29,10 @@ impl TimeSlot {
         *self == TimeSlot::current()
     }
 
+    pub fn next(&self) -> TimeSlot {
+        TimeSlot((self.0 + 1) % 16)
+    }
+
     pub fn duration_until(&self) -> Duration {
         let now = unix_time();
         let now_decis = deciseconds(now);

src/status.rs

@@ -1,5 +1,5 @@
 use std::sync::{Mutex, RwLock};
-use pocsag::TimeSlots;
+use pocsag::{TimeSlots, TimeSlot};
 use frontend::Responder;
 
 lazy_static! {
@@ -11,15 +11,17 @@ lazy_static! {
 pub struct Status {
     pub connected: bool,
     pub transmitting: bool,
-    pub timeslots: TimeSlots
+    pub timeslots: TimeSlots,
+    pub timeslot: TimeSlot
 }
 
 impl Status {
     pub fn new() -> Status {
         Status {
             connected: false,
             transmitting: false,
-            timeslots: TimeSlots::new()
+            timeslots: TimeSlots::new(),
+            timeslot: TimeSlot::current()
         }
     }
 }