My watch face was inspired by the phrase ‘watch the clock’.
There are 12 eyes, each representing the hour. The hour determines which eye is opened and blinking on a two second loop. The single open eye stares where the current minute hand would be pointing on a standard analog clock. For instance, at 5:30, the last eye would be looking straight down.
I hoped that the eyes would bring the pebble to life, transform it from a smartwatch into an organism. I think I accomplished some level of this goal, though the design is still very digital and uniformly patterned. I wanted to use a frame-by-frame animation to simulate organic motion. Lastly, I chose to loop the animation to best represent time.
Upon evaluation, I feel that my clock does not make the best use of the space provided. Although the entire screen is filled with graphics, only one eye (1/12th of screen) blinks at a time.
My idea for the pebble assignment was to work with subdivision patterns to represent time. Initially, I investigated some fractal division such as an incremental cracking. But once the resolution of the display was limited I would not be able to represent small divisions, so I decided to use a voronoi diagram as the logic behind the division.
I used processing to simulate the display of pebble watch in order to evaluate how the gradients of a grayscale brute-force voronoi could be simplified for a black and white screen. These simulations show that the logic itself of the work had to be changed to fit the constraints. Firstly, I tried to use probability to simulate gray areas, but it resulted in a lost of legibility of the diagram. Then, I tried to simplify the diagram, painting only areas of equal distance for two centres. It resulted in an interesting visual effect that resembled the idea of a cracking display.
After defining the visual pattern, I tried to evaluate what would happen if each of these cells were agents that interact with the neighbours and the frame of the pebble, with forces of repulsion. As the time passes and the cells subdivide, each agent try to find a appropriate space in the area, establishing a bottom-up balance of the visual composition.
On one hand, with the dynamic behaviour of the cells, the original idea of subdivision was taken even further, but on the other hand, the implementation in the pebble watch was a difficult process, due to the brute forces algorithms underlying the diagram. The constraints involved in the implementation were related to the limited memory of the device, what imposed several limitations for the design of the Voronoi diagram. After several memory crashes, the resolution, the number of cells and the movement were reduces, what took the design one step back.
Finally, I consider that the Voronoi diagram is a very interesting device for the visualization of time. The obstacles faced in the implementation demand a careful optimization of the algorithms in order to incorporate the full potential of the design.
My name is Lauren Valley, and I have a condition called “Resting Bitch Face.”
When I’m not paying attention to the expression on my face, it often looks like I am extremely pissed off or uninterested. This condition has affected me since I was in elementary school and teachers would stop me in the hallways and tell me that “it was okay to smile.”
I am still slightly in denial about my condition so I take no measures in trying to correct it—my other condition, “Resting Bitch Mouth.” Is something I take active steps to try to fix.
My Pebble Watch face aids me in the “realization” phase of correcting my “Resting Bitch Mouth.” When I get hungry, I often respond with sassy to borderline rude remarks, and based on the hour of the day and the amount of time its been since I’ve eaten, my responses can get kind of touchy.
I have programmed my watch to display sayings based on my regular meal times.
As time passes without food, the sayings displayed range from “It’s all good” when I’ve first eaten to “FUCK MY LIFE” if I’m feeling particularly hungry.
I believe that this watch will aid my struggle in realizing my condition, and soon, the world will be a better place one resting bitch mouth at a time.
starts synced ->, synced <- bottom guy turned first.
Hi this is my poem / timer.
Each row is 30 steps, and takes 30 seconds.
The return trip included makes it 1 minute per cycle. At each 59th step of the second being, he/she turns around before the 60th step. This causes a small gap that represents a minute. Each round the characters’ gap increases once as more minutes are represented. This pattern eventually cycles though and returns to its default state. There can be a total of 60 gaps between them. Meaning that this piece can time up to exactly 1 hour.
It’s also a little poem about two friends separating and getting back together :D
At first, I just wanted to make a binary clock. I looked around for a bit and it turned out those are actually pretty mainstream. So I decided to make a Ternary clock! (This is fitting for a clock because after all, Sumerian time is pretty divisible by 3.) Here, the horizontal lines represent 0, the vertical line represents 1, and the square represents 2. I decided to make the lowest bit display on the left and the highest bit on the right, since we naturally read English text from left to right, and doing numbers this way as well makes more sense. I kind of screwed up with the seconds, so that although it goes up from 0 to 60, it isn’t in perfect sync with the minutes. I retrospect, developing for the Pebble watch was really annoying on the Android. I finally figured out why it wasn’t working with my Android phone while it did on my tablet: the Android version was outdated! (Version needs to be at least 4.2.2) Anyways, I think the end result looks kind of like the messaging system the Predator alien has on its wearable wrist device. Cool stuff.
Here is a sketch: Here are some stills:
Time: 0 hours, 40 minutes and 46 seconds.
Time: 24 hours, 10 minutes and 53 seconds.
And here is the code:
#include
//windows and layers
static Window *s_main_window;
static Layer *s_canvas_layer;
//variables to be used
int hours = 0;
int minutes = 0;
int seconds = 0;
//---CLOCK UPDATE STUFF---//
static void update_time() {
// Get a tm structure
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
static char buffer[] = "00:00";
// Write the current hours and minutes into the buffer
if(clock_is_24h_style() == true) {
// Use 24 hour format
strftime(buffer, sizeof("00:00"), "%H:%M", tick_time);
} else {
// Use 12 hour format
strftime(buffer, sizeof("00:00"), "%I:%M", tick_time);
}
//update hours and minutes
hours = (int)(buffer[0]-'0')*10+(int)(buffer[1]-'0');
minutes= (int)(buffer[3]-'0')*10+(int)(buffer[4]-'0');
//reset seconds
if(seconds == 60) {
seconds = 0;
} else {
seconds += 1;
}
//mark layer dirty for rerendering
layer_mark_dirty(s_canvas_layer);
}
static void tick_handler(struct tm *tick_time, TimeUnits units_changed) {
update_time();
}
//---CANVAS STUFF---//
void drawSymbol(int shape, int x, int y, GContext *ctx) {
//shape: 0 = horizontal line, 1 = vertical line, 2 = square
graphics_context_set_fill_color(ctx, GColorBlack);
if(shape == 0) {
graphics_fill_rect(ctx, GRect(x+6, y+16, 24, 4), 0, GCornerNone);
} else if(shape == 1) {
graphics_fill_rect(ctx, GRect(x+16, y+6, 4, 24), 0, GCornerNone);
} else if(shape == 2) {
graphics_fill_rect(ctx, GRect(x+10, y+10, 16, 16), 0, GCornerNone);
}
}
//draw the time in ternary:
static void canvas_update_proc(Layer *this_layer, GContext *ctx) {
//update time
update_time();
//get ternary hours:
int thours = hours;
for(int h = 0; h < 4; h++) {
drawSymbol(thours%3,h*36,0,ctx);
thours /= 3;
}
//get ternary minutes:
int tminutes = minutes;
for(int m = 0; m < 4; m++) {
drawSymbol(tminutes%3,m*36,36,ctx);
tminutes /= 3;
}
//get ternary seconds:
int tseconds = seconds;
for(int s = 0; s < 4; s++) {
drawSymbol(tseconds%3,s*36,72,ctx);
tseconds /= 3;
}
}
//---WNDOW STUFF---//
static void main_window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect window_bounds = layer_get_bounds(window_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);
layer_set_update_proc(s_canvas_layer, canvas_update_proc);
update_time();
}
static void main_window_unload(Window *window) {
layer_destroy(s_canvas_layer);
}
//---REQUIRED FUNCTIONS---//
static void init() {
s_main_window = window_create();
// Set handlers to manage the elements inside the Window
window_set_window_handlers(s_main_window, (WindowHandlers) {
.load = main_window_load,
.unload = main_window_unload
});
// Show the Window on the watch, with animated=true
window_stack_push(s_main_window, true);
tick_timer_service_subscribe(SECOND_UNIT, tick_handler);
}
static void deinit() {
// Destroy Window
window_destroy(s_main_window);
}
int main(void) {
init();
app_event_loop();
deinit();
}
