Join Us for the First Kinoma Create Webinar!

Andy Carle
  

Andy Carle

December 17, 2014

Please join us for the first Kinoma Create webinar this Thursday, Dec 18, from 1–2pm PST! Click here for the date and time in your time zone.

Kinoma-Create_facing-left-w-stand-web-res

We’ll start with a quick unboxing, follow that with a demonstration of how to run sample apps in the simulator and on Kinoma Create, and then tour a code sample or two to illustrate how Kinoma apps are structured. At the end of the webinar we’ll do an open Q&A.

If there’s anything specific you’d like us to cover, let us know before the webinar starts at team@kinoma.com.

If you haven’t had a chance to try your Kinoma Create, this is a perfect opportunity to take it for a spin with the team that built it.

Thanks, and we hope you can join us!

— The Kinoma Team

Hacking at Tokyo Maker Faire

Peter Hoddie
  

Peter Hoddie

November 26, 2014

The Kinoma team attended Maker Faire Tokyo 2014 at Tokyo Big Sight to introduce Kinoma Create to the maker community in Japan. Among the many exhibits, was a very cool board for adding touchless gestures to projects. You wave your hand above the Hover board, or tap it, to trigger events.

hover-hand

 

The creators of Hover have done a good job providing software to integrate Hover with various prototyping kits including Arduino, Raspberry Pi, and Spark Core. I wanted to have Hover work with Kinoma Create, so I bought one at the show Sunday.

Monday I used the Hover Python code for Raspberry Pi as a model to create a JavaScript BLL for Kinoma Create. Eram and Jonathan from the Hover team were helpful during Maker Faire, taking time to help me understand how their I2C interface works.

I’m satisfied with how BLL came out. It is about 80 lines of JavaScript following the same structure as the original Python library. The original Hover library returns events as a byte value the  application parses using bit operations to determine the gesture or hover event. In our BLL, events are returned as human readable strings like “swipe to left” and “touch center” because that feels more natural in JavaScript and is easier for developers while debugging.

//@module
exports.pins = {
    ts: {type: "Digital", direction: "input"},
    reset: {type: "Digital", direction: "output"},
    data: {type: "I2C", address: 0x42},
}

exports.configure = function(configuration) {
    this.ts.init();
    this.reset.init();
    this.data.init();

    this.reset.write(0);
    this.reset.direction = "input";

    sensorUtils.delay(3);
}

exports.close = function() {
    this.ts.close();
    this.reset.close();
    this.data.close();
}

exports.read = function() {
    var data;

    if (0 == getStatus.call(this)) {
        data = getEvent.call(this);
        setRelease.call(this);
    }
    return data;
}

function getStatus() {
    if (this.ts.read())
        return 1;

    this.ts.direction = "output";
    this.ts.write(0);
    return 0;
}

function getEvent() {
    try {
        var busData = this.data.readBlockDataSMB(0, 18, "Array");
    }
    catch (e) {
        return undefined;
    }

    var gestureEvent = busData[10];
    if (gestureEvent > 1) {
        switch (gestureEvent) {
            case  2: return "swipe to right";
            case  3: return "swipe to left";
            case  4: return "swipe up";
            case  5: return "swipe down";
            default: return "Mystery swipe 0x" + gestureEvent.toString(16);
        }
    }

    var touchEvent = ((busData[14] & 0xE0) >>> 5) | ((busData[15] & 0x03) << 3);     if (touchEvent > 0) {
        switch (touchEvent) {
            case  1: return "touch bottom";
            case  2: return "touch left";
            case  4: return "touch top";
            case  8: return "touch right";
            case 16: return "touch center";
            default: return "Mystery touch 0x" + busData[14].toString(16) + ", 0x" + busData[15].toString(16);
        }
    }
}

function setRelease() {
    this.ts.write(1);
    this.ts.direction = "input";
}

 

The Hover board hardware interface requires the BLL to toggle Digital pins between Input and Output for each gesture. This is supported in our Kinoma pins service, but the code is a little verbose:

this.reset.close();
this.reset = PINS.create({type: "Digital", pin: configuration.pins.reset.pin, direction: "input"});
this.reset.init();

To make this operation more compact, we added the ability to set the direction of a Digital pin directly. This enhancement will be in the forthcoming software update to Kinoma Create and Kinoma Studio.

this.reset.direction = "input";

My colleague Patrick Soquet wrote together a sample application that uses the events from the Hover BLL to render a smoothly animated user interface (in Kinoma green and white) that displays both gestures and touch events on Kinoma Create. The screen built into Kinoma Create makes it easy to visualize the results of sensors like Hover, so even simple sensor tests like this one are fun to play with.

//@program

var touchSkin = new Skin({ fill: ["#00FFFFFF", "white" ] } );
var arrowsTexture = new Texture("./arrows.png");
var arrowsSkin = new Skin({ texture: arrowsTexture, x:0, y:0, width:200, height:200, variants:200, states:200 } );

var FadeBehavior = function(content, data) {
	Behavior.call(this, content, data);
}
FadeBehavior.prototype = Object.create(Behavior.prototype, {
	onCreate: { value: function(content, data) {
		content.duration = 1500;
	}},
	onTimeChanged: { value: function(content) {
		content.state = 1 - content.fraction;
	}},
});

var Screen = Container.template(function($) { return {
	left:0, right:0, top:0, bottom:0, skin: new Skin({ fill: "#76b321" }),
	contents: [
		Content($, { anchor:"touch left", behavior:new FadeBehavior, left:0, width:20, top:0, bottom:0, skin: touchSkin }),
		Content($, { anchor:"touch top", behavior:new FadeBehavior, left:20, right:20, top:0, height:20, skin: touchSkin }),
		Content($, { anchor:"touch right", behavior:new FadeBehavior, width:20, right:0, top:0, bottom:0, skin: touchSkin }),
		Content($, { anchor:"touch bottom", behavior:new FadeBehavior, left:20, right:20, height:20, bottom:0, skin: touchSkin }),
		Content($, { anchor:"touch center", behavior:new FadeBehavior, left:20, right:20, top:20, bottom:20, skin: touchSkin }),
		Content($, { anchor:"swipe to right", behavior:new FadeBehavior, skin: arrowsSkin, variant:0 }),
		Content($, { anchor:"swipe to left", behavior:new FadeBehavior, skin: arrowsSkin, variant:1 }),
		Content($, { anchor:"swipe down", behavior:new FadeBehavior, skin: arrowsSkin, variant:2 }),
		Content($, { anchor:"swipe up", behavior:new FadeBehavior, skin: arrowsSkin, variant:3 }),
	]
}});

Handler.bind("/hoverData", {
	onInvoke: function(handler, message) {
		var data = model.data;
		var it = message.requestObject;
		if (model.current != it) {
			model.current = it;
			for (var anchor in data)
				data[anchor].state = 0;
			var content = data[it];
			content.state = 1;
			content.time = 0;
			content.start();
		}
	}
});

var model = application.behavior = Object.create(Object.prototype, {
	onLaunch: { value: function(content) {
        var message = new MessageWithObject("pins:configure", {
            hover: {
                require: "hover",
                pins: {
                    ts: {pin: 23},
                    reset: {pin: 24},
                    data: {sda: 27, clock: 29}
                }
            }});
        application.invoke(message);

        message = new MessageWithObject("pins:/hover/read?repeat=on&callback=/hoverData&interval=16");
        application.invoke(message);

		this.current = "";
		this.data = { };
 		application.add(new Screen(this.data));
	}},
});

 

Since Kinoma Create is battery powered, we walked our project over to the Hover table to share our success in getting our products working together. Unfortunately, they had left early to catch their flight home. We used their table to make a video to show them, which you can see too, here:

While we were shooting the video, several show attendees stopped by the table to check out our little project and wave their hands over it. They all walked away smiling.

This is part of why I go to Maker Faire. It isn’t just a place to be inspired by cool project and learn new techniques. It is a place to interact directly with the makers, which can be the springboard for new creations, large and small.

Kinoma Create Officially Launched!

Rachel Bennett
  

Rachel Bennett

November 7, 2014

Kinoma Create officially launched with a week of activities: conferences, public speaking, exhibiting, and celebrating. It was the culmination of months of listening to early adopters, iterating the product, priming the pump with industry event participation, refining the development tools, and building out the developer support system.

When you have the backing of enthusiastic crowdfunders, and you’re as committed to completely rethinking product prototyping as we are, it’s all a labor of love!

IOTAconf

We kicked off launch week with participation in IOTAconf at Moscone Center in San Francisco. Our booth was immensely popular with attendees excited about applying their JavaScript skills for a better way to experiment in hardware.

Claire and Sean at table

Andy Carle, Kinoma Create product lead, delivered a talk titled, “Mind the Gap: JavaScript for IoT, from Concept to Production.” IOTAconf attendees joined this session to get inspired by prototyping and design iteration, and to learn how JavaScript is taking its rightful place as a framework for IoT product development.

IMG_8804

Gigaom Structure Connect

Over at the Mission Bay Conference Center, the team launched Kinoma Create as part of Gigaom Structure Connect. Peter Hoddie took to the main stage to share our firsthand “How We Built It” experience, focusing on the critical prototyping phase of creating a product. Our talk was foreshadowed in a by-lined article penned for Gigaom’s editorial site.

Screen Shot 2014-11-06 at 6.12.49 PM

Marvell was a proud sponsor of Garage@Connect, a program within the event that showcased startup companies and their very new product concepts. As part of this, Peter introduced Garage@Connect to attendees, encouraging them to consider the garage–a storied place of tech innovation–as a state of mind rather than a physical location.

Screen Shot 2014-11-06 at 6.01.41 PM

Screen Shot 2014-11-06 at 6.04.09 PM

Throughout the event, we were able to talk one-on-one with attendees who visited our table. Many were interested in Kinoma Create as a product from Marvell, offering them a path from prototype to mass production.

IMG_7890

The launch of Kinoma Create also got the attention of the media, and we were able to conduct several press interviews while at the event.

IMG_7913

Gigaom Structure Connect was a valued opportunity to connect directly with those interested in a complete re-think of IoT product prototyping.

We closed out the event by participating on a panel with other speakers.

Kinoma Create cake

Topping off a very active launch week, the team hosted a little celebration with the wider Marvell team that in various ways contributed to the making of Kinoma Create.

And what better way to celebrate than with a cake that looked exactly like the device?

IMG_7936

Team photo cropped

Thank you, all, for being part of Kinoma Create’s launch.

Next, we’ll see you at Maker Faire Tokyo!

Aloha from the Kinoma Team

Andy Carle
  

Andy Carle

November 6, 2014

Life’s a beach!

We headed to Waikiki for UIST 2014: the User Interface Software and Technology Symposium put on by the Association for Computing Machinery.

Student Innovation Contest

We sponsored the UIST Student Innovation Contest, covering the travel grants for undergraduate teams competing in the contest, and funding prizes awarded to contest winners.

PicFrame mop

PicFrame mop

PicFrame mop

PicFrame mop

PicFrame mop

In total, 27 teams competed, with participants ranging from high school students to PhD candidates. They gathered from around the world to show off projects built using Kinoma Create. The theme of the contest was household technology, and teams had a little over a month to build their prototypes.

Entries ranged from the eminently practical to the somewhat absurd.

Among our personal favorite projects were:

  • A mop that turns cleaning into a game of searching for coins and squishing bugs (kudos on the enthusiastic mopping demonstration…for three hours straight!)
  • A recipe organizer based on hands-free gestures and voice recognition
  • Automated drawers that open and close themselves based on what you need at that moment
  • A system for scheduling reminders at specific locations around your house
  • A toaster that can toast custom designs on to a piece of bread
  • Assistive technology that tells visually impaired users which appliances and lights are turned on in their house before they leave or go to bed

Check back to the Kinoma blog soon for a video recap of the event!

This event was a major milestone for the Kinoma team. It marks the largest set of outside projects ever built using Kinoma Create. We were thrilled to see all the creativity and enthusiasm that the students brought to their projects and the platform.

UIST logo

Demonstration Reception

At UIST, we were also able to all attendees to Kinoma Create during the Demonstration Reception.

Demo reception John Sloan

We can’t wait to see what all of you will make with your Kinoma Create!

Kinoma in the sand

Friend-to-Friend Car Sharing Service Designed with Kinoma Create

Rachel Bennett
  

Rachel Bennett

October 2, 2014

Yohei Onishi, an early Kinoma Create adopter, recently competed in the AT&T Hackathon @ Super Mobility Week – Code for Car & Home. The hackathon aimed to develop new applications for the connected car and home industry.

atthackathon-logo

This team selected Kinoma Create as their development platform for this event based on its:

  • Built in Wi-Fi, used to communicate with both server and mobile applications
  • Color display with touch interface, used to implement an interactive user interface for drivers

ATT Home Car hackathon 2014 08

Overall, they found the Kinoma software helped them to quickly develop a prototype using its hardware programming capabilities, and user interface modules, both through JavaScript. They were able to quickly get started by referencing the many Kinoma example applications on Github.

Their impressions of Kinoma Studio, the development environment for Kinoma Create, was that it was straightforward, and made it easy to prototype on their computer and then test completed applications on Kinoma Create.

“Programmers who are familiar with Java Script may find it easy to write new applications while Hardware programmers like flexibility of programmable pins,” they wrote in recap of their experience with Kinoma Create at the hackathon.

You can read a full report of their development and hackathon experience on their blog.