Index: flowtimer/Phase.py
===================================================================
--- flowtimer/Phase.py	(revision 3b764754bd07ba755789224d8bd5bd06cc9febc9)
+++ flowtimer/Phase.py	(revision f95948892cd5820277dabed16c73e484f43cc674)
@@ -8,5 +8,5 @@
     """
 
-    def __init__(self, title, duration):
+    def __init__(self, title, ticks):
         """
         creates the variables associated with that class
@@ -15,16 +15,15 @@
         :param title: Name of phase
 
-        :type duration: int
-        :param duration: Duration in seconds
+        :type ticks: int
+        :param ticks: ticks in seconds
         """
 
         self.title = title
-        self.duration = duration
+        self.initial_ticks = ticks
         self.state = "initial"
-        self.time_left = self.duration
+        self.ticks_left = ticks
 
     def to_json(self):
-        return json.dumps({"title": self.title, "duration": self.duration})
-        # return json.dumps(self.__dict__)
+        return json.dumps({"title": self.title, "duration": self.initial_ticks})
 
     def __str__(self):
@@ -36,6 +35,6 @@
         """
 
-        return ("-->" + self.title + "\nDuration=" +
-                str(self.duration) + "\n")
+        return ("-->" + self.title + "\nTicks left=" +
+                str(self.ticks_left) + "\n" + str(self.state) + "\n")
 
     def abort(self):
@@ -44,4 +43,8 @@
     def start(self):
         self.state = "running"
+
+    def reset(self):
+        self.ticks_left = self.initial_ticks
+        self.state = "initial"
 
     def pause(self):
@@ -58,8 +61,12 @@
         return self.state == "paused"
 
-    def tick(self, duration):
-        self.time_left -= duration
+    def tick(self, ticks):
+        result = self.ticks_left - ticks
 
-        if self.time_left <= 0:
-            self.time_left = 0
+        if result <= 0:
+            print("Single phase finished")
+            self.ticks_left = 0
             self.state = "finished"
+        else:
+            self.ticks_left = result
+        return result
Index: flowtimer/RecurringPhaseSequence.py
===================================================================
--- flowtimer/RecurringPhaseSequence.py	(revision 3b764754bd07ba755789224d8bd5bd06cc9febc9)
+++ flowtimer/RecurringPhaseSequence.py	(revision f95948892cd5820277dabed16c73e484f43cc674)
@@ -24,12 +24,59 @@
                            "repetitions": 3})
 
+    @classmethod
+    def default(cls):
+        return cls.from_json(cls.default_json_string())
+
     def __init__(self, phase_list, repetitions):
+        assert repetitions > 0
+        assert phase_list is not []
+        self.state = "initial"
         self.phase_list = phase_list
-        self.repetitions = repetitions
+        self.current_phase = phase_list[0]
+        self.initial_repetitions = repetitions
+        self.passes_left = repetitions
 
     def to_json(self):
         return json.dumps(self.__dict__, default=lambda each: each.to_json())
 
+    def upcoming_phases_in_pass(self):
+        index = self.phase_list.index(self.current_phase)
+        if index < len(self.phase_list) - 1:
+            return self.phase_list[index+1:]
+        return []
+
+    def ticks_left(self):
+        return (self.passes_left * sum([each.initial_ticks for each in self.phase_list]) +
+                self.current_phase.ticks_left +
+                sum([each.ticks_left for each in self.upcoming_phases_in_pass()]))
+
+    def finished(self):
+        return (self.passes_left < 1) and (not self.upcoming_phases_in_pass())
+
+    def abort(self):
+        self.current_phase.abort()
+        self.state = "finished"
+
+    def tick(self, ticks):
+        if not self.finished():
+            result = self.current_phase.tick(ticks)
+            print("Current phase", self.current_phase)
+            print("Passes left:", self.passes_left)
+            if self.current_phase.finished():
+                if self.upcoming_phases_in_pass():
+                    self.current_phase.reset()
+                    self.current_phase = self.upcoming_phases_in_pass()[0]
+                    self.current_phase.start()
+                    print("New phase:", self.current_phase)
+                    self.tick(abs(result))
+                    return True
+                self.passes_left -= 1
+                if self.finished():
+                    self.state = "finished"
+                else:
+                    self.current_phase.reset()
+                    self.current_phase = self.phase_list[0]
+        return True
+
     def unrolled(self):
         return [deepcopy(seq) for seq in [each for each in self.repetitions * self.phase_list]]
-        # return self.repetitions * self.phase_list
Index: flowtimer/Schedule.py
===================================================================
--- flowtimer/Schedule.py	(revision 3b764754bd07ba755789224d8bd5bd06cc9febc9)
+++ flowtimer/Schedule.py	(revision f95948892cd5820277dabed16c73e484f43cc674)
@@ -32,4 +32,5 @@
         if (self.current_phase.finished()) and (self.phase_list[-1] == self.current_phase):
             self.state = "finished"
+            print("Finished")
             return True
         else:
@@ -43,6 +44,7 @@
             self.current_phase = self.phase_list[index+1]
 
-    def time_left(self):
-        return self.current_phase.time_left + sum([phase.time_left for phase in self.upcoming_phases()])
+    def ticks_left(self):
+        return (self.current_phase.ticks_left +
+                sum([phase.ticks_left for phase in self.upcoming_phases()]))
 
     def upcoming_phases(self):