This clock application takes the traditional perception of time in quarters, and changes it to thirds.  Thirds still utilize a 12 hour day, however the break down of the hour itself happens in spans of 20 minutes instead of 15.  This motif carries directly into the geometry of the clock in that it is comprised of a triangular tessellated surface.  Each solid triangle represents an hour and its outlined subdivisions represent 20 minutes.  At 12 hours the face of the watch is reset.

John’s Post

John and I happened to come up with the same idea and we figured, it was challenging enough for us to work on it together.

The clock we designed is a digital sun dial. The way it works is by getting your current latitude and longitude and calculating the plot points for an accurate sun dial specific to your location. The sun dial updates twice daily to adjust for your current location. With this site-specific sun dial the clock can also understand your orientation relative to north. That means that you can actually know your orientation relative to the sun, and you have to align your watch to the appropriate sun dial position in order to get the shadow to point to the correct time, just like a real sun dial. If the clock is not oriented properly, the sun orientation will still cast a shadow.

This clock proved very challenging and fun to work on. Current functionalities completed are the sun dial calculator and its appropriate clock face setup. The north is also implemented on to the face so that the user can know exactly what to orient the clock to. What is left to be done is the dynamic shadow responding to the sun.

I collaborated with Thomas Langerak. We were inspired by the grains of an hourglass. You can toggle between a group of smaller particles that amount to the current minutes, and a group of larger particles that amount to the current hours.

~*~*~*click 4 code*~*~**~*

This project was originally inspired by a hitchhiking trip I took with an eccentric, technophobic friend; he wanted to use our disconnect from home as an opportunity to free ourselves from the expectations of cell phones, push notifications, the internet, and, perplexingly, clocks.  He believed there was something more interesting and authentic about asking strangers for the time, and making approximations in the interim.  Not only did it free you from the obligations associated with “exact” time, it forced the operation of checking the time to be collaborative and interactive, requiring trust in a human point of contact to get a universal “grounding” in the world around you.

At the time, I wondered how this idea could possibly scale, what it would mean for *everyone* to rely on others to approximate what time it is.  I remembered a TED talk I saw once, where a speaker demonstrated that the average of guesses in a crowd for something such as the weight of an Ox or the count of a jar of jellybeans was exceptionally close to the exact one.

This led me to believe that if *everyone* was asked for the time at once, the average of their responses might be accurate, or at least interesting.  After all, what are we really doing when we’re checking the time?  Sometimes we are figuring out when to leave, when to wake up; often, we’re just trying to re-callibrate our sense of where we are in our day: How long until it gets dark? Until this movie ends? Until it’s “late”?  In these instances, we have some idea of how much time has elapsed, but we look for some concrete validation that we’re aligned with the rest of the world.

My watch face displays a time reached by consensus.  It has no sense of universal time internally, but rather asks the user at random intervals what they think the time is, and  pulls the average of all user’s approximations.  The watch then measures and displays the number of seconds since the last pull.  The result is a subjective, “universal-ish” notion of time that is governed entirely by estimation.

Originally, I wanted time to be measured in how long it had been since the user unlocked their phone, requiring an estimate on the watch before their phone screen would unlock.  However, this was only really possible using an Android device, and I have an iPhone.  I still think this would be an interesting extension, forcing users not only to stop and think before they check their notifications, but give some attention how often they are checking their phones.

Also, my watch isn’t very pretty in design.  Some work into this effort might be helpful as well.

My Pebble Watch app is a mobile version of a clock assignment I did last semester with some added features.

The clock is a twelve-handed spinning spirograph-like ball that ‘ticks’ every second. Each hand is actually a point that is connected to all of the other points by lines. By moving each hand around the face of the clock depending on the number of seconds passed in the day, complex patterns emerge. Because of this, each second of the day generates a unique pattern.

Each unique pattern is also given a unique name. For example, the second at 7:49am (and 45 seconds) is named “kicute” looks like this:

The name generation is done with a very very simple algorithm that chooses consonants and vowels back and forth. I’ve been using this little trick for years now because of it’s simplicity and the cute/exotic names it comes up with.

#include 

static Window *s_main_window;
static Layer *s_canvas_layer;
static TextLayer *name_layer;

void handle_second_tick(struct tm *tick_time, TimeUnits units_changed) {
  layer_mark_dirty(s_canvas_layer);
}

static void drawLineToFromAngle(float t, float f, GContext *ctx, GPoint center) {
  //https://github.com/pebble/pebble-sdk-examples/blob/629cd4bb6a8d4686e48889c5a3870f92e5d915b0/watchfaces/simple_analog/src/simple_analog.c
  
  GPoint p0 = GPoint(
    (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * (t / 360.0)) * (int32_t)65 / TRIG_MAX_RATIO) + center.x,
    (int16_t)( sin_lookup(TRIG_MAX_ANGLE * (t / 360.0)) * (int32_t)65 / TRIG_MAX_RATIO) + center.y
  );
  
  GPoint p1 = GPoint(
    (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * (f / 360.0)) * (int32_t)65 / TRIG_MAX_RATIO) + center.x,
    (int16_t)( sin_lookup(TRIG_MAX_ANGLE * (f / 360.0)) * (int32_t)65 / TRIG_MAX_RATIO) + center.y
  );

  graphics_context_set_stroke_color(ctx, GColorBlack);
  graphics_draw_line(ctx, p0, p1);
}

static void canvas_update_proc(Layer *this_layer, GContext *ctx) {
  GRect bounds = layer_get_bounds(this_layer);
  GPoint center = GPoint(bounds.size.w / 2, (bounds.size.h / 2) - 12);

  time_t now = time(NULL);
  struct tm *t = localtime(&now);
  int s = t->tm_sec;
  int m = t->tm_min;
  int h = t->tm_hour;
  
  // second name
  static char name[] = "XXXXXX";
  static char vowels[] = "AEIOU";
  for(int i = 1; i < 6; i+=2) {
    name[i] = vowels[(s+m*60+h*60*60 + i+10) % 5];
  }
  for(int i = 0; i < 6; i+=2) {
    name[i] = 65 + ((s+m*60+h*60*60 * (i+10)) % 25);
  }
  text_layer_set_text(name_layer, name);
  
  // mandala
  for(int i = 0; i < 360; i += 30) {
  for(int j = 0; j < 360; j += 30) {
    drawLineToFromAngle(i+s, j, ctx, center);
  }}
}

static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect window_bounds = layer_get_bounds(window_layer);

  // Create Layer
  s_canvas_layer = layer_create(GRect(0, 0, window_bounds.size.w, window_bounds.size.h));
  layer_add_child(window_layer, s_canvas_layer);
  
  // Name
  name_layer = text_layer_create(GRect(2, 140, 144, 18));
  text_layer_set_background_color(name_layer, GColorClear);
  text_layer_set_text_color(name_layer, GColorBlack);
  text_layer_set_text_alignment(name_layer, GTextAlignmentCenter);
  text_layer_set_font(name_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));

  layer_add_child(window_get_root_layer(window), text_layer_get_layer(name_layer));
  
  // Set the update_proc
  layer_set_update_proc(s_canvas_layer, canvas_update_proc);
}

static void main_window_unload(Window *window) {
  // Destroy Layer
  layer_destroy(s_canvas_layer);
}

static void init(void) {
  // Create main Window
  s_main_window = window_create();
  window_set_window_handlers(s_main_window, (WindowHandlers) {
    .load = main_window_load,
    .unload = main_window_unload,
  });
  window_stack_push(s_main_window, true);
  
  tick_timer_service_subscribe(SECOND_UNIT, &handle_second_tick);
}

static void deinit(void) {
  // Destroy main Window
  window_destroy(s_main_window);
}

int main(void) {
  init();
  app_event_loop();
  deinit();
}