(require (lib "rscT.ss" "rscT"))

(define Q (make-schedule!))
(define T (make-tschedule! 60.0 0.0 (ceiling (utc!))))

(at! T
     (ceiling (utc->pulse T (utc!)))
     (lambda (p f) (inform! p) (f 1.0)))

(tschedule-reset*! T 120.0)

(tschedule-clear! T)

(at%! T 4.0 0.0 (lambda (p f) (inform! p) (f 1.0)))

(rt! T 
     (ceiling (utc->pulse T (utc!)))
     (lambda (wait!)
       (for-each! (lambda (n) (inform! n (wait! 1.0)))
		  (iota 12))))

;; Schedule immediately using delta scheduler.

(after! T 0.0 (lambda (p t f) (inform! "The time is" p t)))

;; Schedule to one pulse interval from now, then every third of a pulse.

(after! T 1.0 (lambda (p t f) (inform! "The time is" p t) (f (/ 1.0 3.0))))

;; Schedule to the next integer pulse location, then every third pulse.

(after*! T 1.0 (lambda (p t f) (inform! "The time is" p t) (f 3.0)))

(tschedule-clear! T)

;; Forward schedule many events, & reset the schedule

(for-each!
 (lambda (n) (at! T n inform!))
 (iota 12.0 (ceiling (utc->pulse T (utc!)))))

(tschedule-reset*! T 30.0)

;;;;;;;;;;;;;;;;;;;;;;;;;

(begin!

  ;; Get current time, round up to next second
  (define v (ceiling (utc!)))

  ;; Create two clocks in a 5:2 relation, starting at time v. 
  (define t (make-tschedule! 60 0 v))
  (define u (make-tschedule! 24 0 v))

  ;; Start two functions at beat zero in each clock
  (at! t 0 (lambda (pulse utc) (inform! "t" pulse utc) 1))
  (at! u 0 (lambda (pulse utc) (inform! "u" pulse utc) 1)))

(for-each (lambda (t) (edit-tschedule-ppm! t (*N 3))) (list t u))

(for-each (lambda (t) (edit-tschedule-ppm! t (*N 1/4))) (list t u))

(for-each (lambda (t) (tschedule-clear! t)) (list t u))

;;;;;;;;;;;;;;;;;;;;;;;;

(begin

  ;; Get current time, round up to next second
  (define v (ceiling (utc)))

  ;; Create two clocks, starting at time v. 
  (define t (make-tschedule! 60 0 v))
  (define u (make-tschedule! 60 0 v))

  ;; Start two functions at beat zero in each clock.  t controls u's
  ;; tempo. They should stay in sync.
  (at t 0 (lambda (pulse time) 
	    (set-tschedule-ppm! u (* (tschedule-ppm t) (randomC '(1 2 3 4 5))))
	    (inform "t" pulse time) 1))
  (at u 0 (lambda (pulse time) 
	    (inform "u" pulse time) 1)))