• New Hire: Kwyn Alice Meagher

    Wednesday, November 5, 2014

    (aka HarleyKwyn)

    11/5/2014– Kwyn Meagher

    Hey there!

    I’m Kwyn, aka HarleyKwyn, from Sunnyvale, CA, the original Silicon Valley. Unlike the majority of the Technical Machine crew, I do not hail from Olin College and instead graduated from University of California, Merced’s Materials Science and Engineering program with an emphasis in nano-technology.

    Specializing in carbon nano materials, I fabricated graphene transistors and simulated nanoscale organic photovoltaic cells using MatLab, and COMSOL. I spent the majority of my time programming simulations, which I enjoyed. However, I did not enjoy the constant uphill battle of submitting lengthy proposals. Proposal writing took up half my time and it was a gamble whether or not they would get funded. When funding was awarded it was frequently less than we needed to run our experiments. This led me to enroll in Hack Reactor once I realized the sad state of academia as a whole. So instead of climbing the ivory tower, I’ve joined the ranks of the Technical Machine team.

    While at Hack Reactor as a student and Hacker in Residence (Hack Reactor’s equivalent of a graduate program), I did a variety of projects. The first project I tackled with a group of other engineers was competing in a Kaggle competition to classify galaxies, leveraging the power of a supercomputer to give us an upper hand since none of my team had done machine learning before or written a lick of code in python. I’m proud to say that we beat out university teams in the two weeks that we spent on the project.

    My second project, and personal favorite, was Visual Interpreter, an interactive visualization of the JavaScript interpreter. Visual Interpreter hooked into a JavaScript interpreter written in JavaScript (very lisp-y). We built a visualization of the scope hierarchy and it could highlight when closure scopes were created and tell you when objects were === to each other.

    With my background in machine learning and research, it’s surprising that I originally took a strictly front-end position at Uber right after finishing Hack Reactor. I did a short stint there before I had coffee and a conversation with Jon. After our conversation it was obvious to me that my heart really belonged to Technical Machine and Tessel. My varied background in nano-engineering, teaching, and web engineering, lent me a special mix of skills that fit well with Technical Machine’s mission.

    I’ve been attracted to mentoring students–historically in physics, nano-engineering and software engineering, though that’s just the beginning. I take great pleasure in teaching and learning from others so I hope to see you all in the future at conferences, hack-a-thons and meetups. Stoked to be part of this amazing team and look forward to working with all of you via twitter and the forums. Feel free to reach out to me on twitter @HarleyKwyn or via e-mail at kwyn [at] technical.io

    Happy Hacking

    #kwyn meagher #tessel #technical machine #hack reactor #harleykwyn

  • Bringing Hardware to Life with JS and Node

    Tuesday, October 28, 2014

    10/28/2014– Kelsey Breseman

    Last week, I spoke at Fullstack Conference in London.

    You can see a copy of my slides here: Bringing Hardware to Life with JS and Node.

    I left lots of time to live-fix my three demos if necessary, but they all worked so well that I ended earlier than expected. That left lots of time to take questions! Fortunately, I had a very engaged audience, and they asked lots of good questions. I recommend you watch the video of the talk, which includes the demos and the questions:

    Kelsey Breseman: Bringing Hardware to Life with JS and Node [video]

    #kelsey breseman #fullstack #tessel #demo #technical machine #conferences #skillsmatter

  • What Comes Next: Fractal

    Monday, October 27, 2014

    10/27/2014– Kevin Mehall

    Jon’s last post hinted at what we’re working on next, a project we’re calling Fractal. I wanted to explain in a little more detail what we’re planning for the Fractal software stack.

    Our users love Tessel for the ease of getting started. This is especially apparent at hackathons and other meetups we’ve held for people to try Tessel. A first-time user can go from zero to something quite impressive in only a few hours. Many customers have been asking about their next steps once they build a prototype – Tessel can’t just be a device for winning hackathons. A good platform needs to scale as your project turns into a product and help you win in the marketplace too.

    Fractal is a system design tool for microcontroller firmware and hardware. For Tessel prototypes, Fractal will improve IO performance and provide better debug tools. Once your prototype works, and you want smaller, cheaper, and lower-power boards in quantity, Fractal will help you optimize your system design. It’ll help you choose the right parts and put together reference schematics and circuit board layouts as a starting point for your own hardware.

    Beyond JavaScript

    We’ve already had to include some dedicated C code in our firmware for specific applications with timing requirements that JavaScript can’t meet. The Audio module requires code in the firmware to feed the audio chip data exactly when it needs it, without waiting for the JS event loop. We’ve recently added code for driving Neopixel LEDs with the (really powerful, but nontrivial-to-configure) timer hardware built into the NXP micrcocontroller on Tessel. While this works for the handful of applications so far, it doesn’t scale; these things should be libraries, not built into the main Tessel firmware. With Fractal, we’re working on a way to ship compiled code modules that integrate tightly into the firmware, while remaining easy to use.

    Fractal adds Components, bundles of code for a discrete piece of your firmware, like an I2C controller, accelerometer driver, or JS VM containing your domain logic. Components have statically-defined, asynchronous, language-agnostic interfaces, and the Fractal compiler will be able to automatically generate cross-language bindings, so you don’t have to write them manually. This makes it easier to use the right language for each piece and phase of your project, be it prototyping or realtime control.

    The right language isn’t always JS or C. I’m enjoying Rust, and think it makes an ideal language for programming microcontrollers. Rust is a new language from Mozilla that combines high-level expressiveness and safety with low-level performance, size, and closeness to hardware. It’s a new entry into the systems programming space that has been dominated by C for decades.

    I’m also working on Signalspec, a domain-specific language for modeling IO protocols using regex-like definitions. Signalspec is a dedicated description language to abstractly define and then implement the state machines used to communicate with sensors and other chips. It saves you from writing asynchronous state machines by hand, a messy, error-prone process in existing imperative languages.

    Because of the cross-language Component interfaces that abstract the underlying hardware, porting between languages and between hardware platforms isn’t a full-system rewrite. Start by prototyping your domain logic in JS on Tessel, then port it to Rust and fit it on a $2 Cortex M0 part. Fractal will make such a port not only feasible, but easy and elegant.

    Tessel brings a few aspects of Node / JS to embedded development that will become a broader part of Fractal and improve the platform for all languages:

    Packages

    Components involve a change in how code gets deployed to your Tessel. Right now, you normally download the firmware from us pre-compiled, and then tessel run or tessel push deploys a bundle of your JavaScript, which the firmware runs from a virtual filesystem. Under Fractal, your project specifies which Components get compiled in, and it will build a custom firmware image containing everything from the low-level drivers to the Colony JS runtime and your JS code, with each deploy. This means many errors are detected at compile time instead of runtime.

    The ease of installing Tessel module drivers is important piece of the Tessel user experience, and will guide the design of the Component distribution story. npm will obviously remain the way to install pure-JS packages from the Node ecosystem within a JS component.

    Events

    There’s one convention in JS that is actually more like how hardware works than most other languages: events. Hardware interrupts wake up the CPU and run an interrupt handler function on hardware events like button presses, SPI completions, and UART received bytes. Sounds kind of like a JS async callback, right?

    An OS kernel can be thought of as an interrupts-to-threads adapter. To achieve asynchronous events within this threaded model, Node uses libuv, which can be thought of as a threads-to-events adaptor. On Tessel, rather than going from interrupts to threads and back again, hardware interrupts enqueue events directly onto the JS event queue.

    Fractal components add more structure to this asynchronous call / callback model, and use it throughout every layer of the system. Explicitly defining the beginning and end of IO actions as events saves power by spending more time in sleep mode, and saves RAM by avoiding the use of multiple stacks for threads.


    We’re just getting started developing Fractal. For more details, check out our preliminary documentation and let us know what you think. Sound like something you want to work on? We’ll be developing Fractal in the open on GitHub, and we’re hiring.

    #kevin mehall #fractal #Tessel #technical machine

  • Talk slides: "APIs to Electrons"

    Friday, October 17, 2014

    10/17/2014– Eric Kolker

    Hey Tesselators, Eric here.

    FIT

    Conference season has (unofficially) begun!

    Jon and I just got back from speaking at an event in Guatemala called Foro de Innovación Tecnológica (Forum on Technological Innovation), or “FIT” for short. We ran a four-hour hack event for the attendees, each gave a talk, and generally had a blast, which is pretty much par for the course.

    From API to Electrons

    My talk was called “From API to Electrons” and walks through what happens when you set a sound trigger on the Ambient module. As you might expect, it looks at what happens at every level of the system, from JS all the way down to simulating the analog electronics on the Ambient module…and back.

    I had a lot of fun writing the talk and hope to give it again (in English this time) in the not too distant future. If you’re in the San Francisco Bay Area, give our meetup a look and keep your eyes peeled. If not, or if you just can’t wait, I put the slides online here and all the resources for the presentation (code, LT SPICE simulation, SVGs, etc.) here.

    #eric kolker #apis to electrons #guatemala #talks #tech talk #conferences

  • Tessel + Keen.io

    Thursday, October 16, 2014

    10/16/2014 – Jia Huang

    Keen.io is a cloud analytics platform that’s extremely easy to use. It gives an endpoint to hit and logs all data sent to that endpoint as part of an event stream.

    We’re excited to finally get it working with Tessel. In the early Tessel firmware/runtime releases we had bugs on our runtime (specifically about zlib decoding/encoding) that prevented their library from working properly.

    Those bugs have since been fixed and working with Keen has been a breeze!

    In order to use Tessel with Keen first create an account.

    Then go on to the projects page and find the project ID & API keys

    Keen has an NPM library that takes in these keys. In order to configure Keen:

    var Keen = require('keen.io');
    var keen = Keen.configure({
        projectId: "####", // swap these out with your own keys
        writeKey: "####",
        readKey: "####"
    });
    

    As a test script I’ve sent over some data from the Accelerometer up to Keen. This script sets up the Accelerometer on port A of Tessel and sends data up to Keen every second:

    var Keen = require('keen.io');
    var tessel = require('tessel');
    // attach the accelerometer to port A
    var accel = require('accel-mma84').use(tessel.port['A']);
    var count = 0;
    
    console.log("setting up keen...");
    var keen = Keen.configure({
        projectId: "####", // swap these out with your own keys
        writeKey: "####",
        readKey: "####"
    });
    
    var dataArray = [];
    accel.on('ready', function () {
      console.log("Accelerometer is ready!");
      // as we get data push it into an array
      accel.on('data', function (xyz) {
        dataArray.push(xyz);
      });
    });
    
    // every second send up all the accelerometer data
    setTimeout(function sendData(){
      keen.addEvent("accel", {data: dataArray}, function(err){
        if (err) throw err;
    
        console.log("Added event #"+count, "data: ", dataArray);
        count++;
        dataArray = [];
        setTimeout(sendData, 1000);
      });
    }, 1000);
    
    

    Before running this make sure Tessel is connected to the internet:

    tessel wifi -n <your_network_ssid> -p <your_network_pw> -s <wpa2|wep>

    The security (-s) flag defaults to wpa2.

    If the network is unsecure, the password and security flags can be omitted:

    tessel wifi -n <your_network_ssid>

    Tessel should go through the wifi connection process and the yellow LED should be lit after it successfully connects to the internet.

    After connecting Tessel to wifi, just do a tessel run index.js to run the test script

    And we can see the data as it gets pushed to Keen along with a timestamp.

    The full code is here: https://github.com/jiahuang/tessel-keen

    Let us know what you do with Tessel + Keen!

    See Keen’s blog on our integration here

    #jia huang #tessel #keen #keenio #technical machine #integration #cloud #analytics

August 2018

January 2018

July 2017

February 2017

November 2016

October 2016

September 2016

August 2016

July 2016

June 2016

April 2016

March 2016

February 2016

November 2015

September 2015

August 2015

July 2015

June 2015

May 2015

March 2015

February 2015

January 2015

December 2014

November 2014

October 2014

September 2014

August 2014

July 2014

June 2014

May 2014

April 2014

March 2014

February 2014

January 2014

December 2013

November 2013

October 2013

September 2013

August 2013

July 2013