Skip to content
Snippets Groups Projects
Select Git revision
  • master default protected
  • at_palomagr
2 results

rndmc

  • Clone with SSH
  • Clone with HTTPS
  • Jake's avatar
    Jake Read authored
    b08b0c28
    History

    RNDMC

    Reconfigurable Numeric Dataflow Machine Controller

    aka project 'consistent-sandbox'

    img software img hardware

    This is a piece of software that is designed to help you assemble high level controllers from dataflow software elements. It serves a graphical programming interface, and is meant to live with dataflow hardware elements from this project 'automatakit'.

    It's in the early stages, so bear with us. Everything is going to be great.

    Usage

    Installing Node.js, WebSocket and SerialPort, and MathJS

    To Run DMC, you'll need to install node.js, and then the packages serialport and ws (websocket).

    Install Node.js

    Node.js is a runtime environment for javascript, so you can write and run js locally. Download and install it here.

    To check that node is installed, you can use

    node -v

    In Windows check that in Environment Variables, System Variables, Path there is a path for C:\Users\yourusername\npm folder. If the folder does not exist, create it and set the path.

    Packages

    I've added a package.json file to the repo, which is another cool node.js trick - this means that to install everything, you should be able to (after downloading the repo and cd-ing into it) run:

    npm install

    This should install everything else. If this fails, you can install things one-by-one as listed below.

    Install Serialport

    Node comes with a package controller called 'npm' - node package manager. You can use this to install dependencies for node programs.

    Serialport is a package for node that allows it to interact with a hardware serial port.

    Navigate to the directory where you'll be running from (atkapi). Do

    npm install serialport

    Install WS (WebSocket)

    WebSockets are very simple web connections. We use them to chat between the 'server' / heap (node) and the 'view' (your browser).

    To install ws, do

    npm install ws

    Install MathJS

    MathJS is just a node package that does maths. To install, you guessed it, do

    npm install mathjs

    Installing Serial Port Drivers

    The ATKRouter uses a CP2102N USB-to-UART bridge to transmit and receive serial characters.

    Drivers are available for all platforms at SiLabs' Website

    Download and install drivers, and check in your system's device manager that a 'CP210x USB to UART Bridge' appears.

    Running DMC

    To run the program, we launch the main.js file with node, from the command line. One of the things this does is run a tiny HTTP server that we can use to access the UI.

    cd to the rndmc folder and run:

    node rundmc

    It's handy to keep a terminal window open beside a browser when running the software - it's not perfect yet - I do this:

    term

    This way I can watch for errors, and restart it when it crashes. Hopefully not a lot of this will happen.

    Open a Browser

    The program is now running a tiny HTTP server, where it will deliver an interface. It's set to show up at your local address on port 8080.

    In a browser open localhost:8080 you will see the mods and this msg in the terminal SEND PROGRAMS TO UI

    Using the Browser Interface

    img moving

    Words of Warning

    This is very new software, so bear with me. It's worth having whomever on the team is in charge of controls read the section (below) on what-all is going on with the software, and understanding how to write new modules, and assemble programs.

    Getting Around

    To navigate, you can scroll in-and-out (try this once there is actually a program loaded) and drag to pan around.

    Loading a Program

    To load a program, hit 'l' on your keyboard. This will open a menu of all of the .json program representations in the /programs directory.

    There is an example program there, that will do acceleration-controlled motion with gcode as input.

    Loading a Module

    To load a module, right-click anywhere on the screen.

    Deleting a Module

    To delete or copy a module, right-click on its title.

    Connecting Outputs to Inputs

    Once loaded, modules can be connected by first clicking on the output of one and the input of another. This will cause events on that output to call events associated with the input.

    Disconnecting Outputs from Inputs

    To disconnect, click the output to disconnect, and then the input to disconnect it from.

    Troubleshooting

    • ?

    RuNDMC Architecture

    arch

    Above is a somewhat-complete representation of what-all is going on in software.

    Essentially, we load tiny programs (modules/sub/modulename.js) using node.js's require function. These programs each have inputs and outputs, and some state. Each also has a description (an example of a complete module is below).

    The UI serves a representation of this through a websocket.

    Pardon my at-the-moment brief explanation.

    Writing New Modules

    Whenever a menu is requested, the system searches modules/ * for anything. When you write a new module, just include your newmodule.js there, and the program should find it.

    These modules are written with objects inherited from lib/jsunit.js

    Here's an example. This is modules/ui/number.js.

    Besides Inputs, Outputs, a Description and State object, anything else goes. I.E. local functions, other Node.JS packages, etc.

    // boilerplate rndmc header
    const JSUnit = require('../../src/jsunit.js')
    let Input = JSUnit.Input
    let Output = JSUnit.Output
    let State = JSUnit.State
    let Button = JSUnit.Button
    
    // a constructor, a fn, a javascript mess
    function uiNum() {
    
        // this is the tiny program-as-and-object that we'll load into rundmc 
        // description / name is required to load successfully 
        var uinum = {
            description: {
                name: 'number-output',
                alt: 'for clicking'
            }
        }
    
        // the State() object is what the system scrapes for ui variables / updates from the UI
        // this includes things like Button('title', callback), which are unique state variables
        // they can also be found in jsunit.js 
        uinum.state = State()
        // alias !
        var state = uinum.state 
    
        state.number = 10
        state.onUiChange('number', onNumberDesire)
    
        state.button = Button('WHAM', onNumberDesire)
    
        // inputs are required, and must be Input('type', callback) 
        uinum.inputs = {
            thru: Input('any', onThruInput), // makes anything into num event 
            evt: Input('any', onNumberDesire)
        }
    
        // outputs: Output('type')
        uinum.outputs = {
            out: Output('number')
        }
    
        // here's our input callback, specified in the input constructor 
        function onThruInput(input){
            if(typeof input == 'number'){
                state.number = input
            } else {
                state.number = parseFloat(input)
            }
            onNumberDesire()
        }
    
        function onNumberDesire(){
            // here's how we fire an output. 
            uinum.outputs.out.emit(state.number)
        }
    
        // gotta give the program this thing we made 
        return uinum
    }
    
    // this for node.js's require() function 
    module.exports = uiNum

    Writing Hardware Modules

    Hardware Modules are identical to other modules, but they inherit a class that can be found and examined at lib/atkunit.js which subsequently calls hardware-interfacing classes from lib/atkroute.js and often use tools from lib/packets.js (packets.js is mostly about packing 64-bit information into byte-size units).

    Programatically Connecting and Loading Modules

    We can also write and manipulate modules as software objects. This is sometimes very nice.

    I.E. here is 'main.js' as configured to run the small program described.

    
    // business 
    const Reps = require('./reps.js')
    const Programs = require('./programs.js')
    
    // the program object: real simple, just has a description, and a 'modules' 
    var program = Programs.new('new program')
    
    /* example program-like-an-api */
    // load some modules
    var multiline = Programs.loadModuleFromSource(program, './modules/ui/multiline.js')
    var gcode = Programs.loadModuleFromSource(program, './modules/parsing/gcode.js')
    
    // attaching: always like outputs to inputs
    multiline.outputs.lineOut.attach(gcode.inputs.lineIn)
    
    // we can move things around here as well
    multiline.description.position = {
        left: 50,
        top: 50
    }
    
    gcode.description.position = {
        left: 500,
        top: 100
    }
    
    // if I have a public function in a module, I can also use that
    multiline.load('./files/dogbone.gcode')
    
    // UI 
    const View = require('./views.js')
    View.startHttp() 
    View.startWs() 
    
    Programs.assignSocket(View.uiSocket)
    View.assignProgram(program)

    Development Notes

    Immediately

    • nice work on generic ui classes / ui.thing.call('function', arg)

    • finish robot flow: offsets, ok, 100ms updates, ok

    • forward transform object -> three.js canvas

    • do key-binding ui for robot jogging, write video

    • three robot canvas

    • set module display width

    • saved program doesn't save state booleans

    • ui objects ... refresh ... use state model ?

    • ui objects client drop below inputs / outputs

    • ui / button

    • svg doesn't display on chrome

    • would like to send board with new buck out to fab

    • just do stepper23, bc if that's it, that's it ?

    • tuning:

    • mrobot having PI, PID terms

    • probably good to do a remote-get ...

    • having position-set input (also gets output?)

    • having position-actual output

    • graphing these things

    • use UI slider (external) to set PID terms?

    • should be able to use the same slider element directly inline

    • cleaning up reps

    • looking for heirarchy demonstration

    • imagining microcontrollers

    • working on robot to inform desires: i.e. ui charts and graphs

    For Madison Park

    • want that better-planner, better-stepper, better-inputs and graphic ui w/ 3js

    • want network to not blow

    • tokens w/ crc bit-level ?

    • app does keepalive / green-when-on etc ?

    • example of setup-for-consistent-feedback of variable, on a timer? tuning loops ... search ...

    • do axis pullout separately from stepper motor ? accel command ? deep jog desire ... architecture still messy though

    • bug hunting

    • multiline change input paste doesn't work ... big state problem

    • is load / save really consistent ? what is the state answer ?

    • expected behavior: pressing the button on the raw move module should result in a move for every button press

    • observed behavior: to send another raw move (via the button on the raw move module), we must reset the motor drivers.

    • add router for reset, test

    Forever

    • open the door, no cuffs
    • option for 'native' multithreading by opening workers on each event ?

    Questionable Moves

    • module deletion seems unclean
    • input / output objects should be able to unhook themselves:
    • keep references of what-is-attached ?
    • would like to be able to default prevent state variables from being changed by users, i.e. in 'collector' the 'count' variable

    WRT Representations

    Module have Inputs Outputs State (initial states are settings)

    Hardware Modules have routes connected to links

    Also Names, IDs Paths-to-source

    To assemble a representation of these, we want to have a kind of 'netlist' that, for convenience, we'll treat like a JSON object. We want heirarchy, so consider the representation having 'top-level' outputs / inputs / state as well ?

    Programming Notes

    15 Minute Tasks

    • @ views.js, uiRequestModuleMenu and uiRequestProgramMenu don't properly build trees from folder structure. similarly, reciprical fn's in client.js do the same
    • @ these load / save functions could also reach into the modules' source to retrieve their proper names, as spec'd in description ...
    • 's' for save program uses hack-asf DOM alert to ask for path

    Desires

    • reload / edit individual modules ?
    • modules spawn new inputs / outputs ?
    • big UI ?
    • arrows catch for jogging
    • editing ?
    • heirarchy zoom
    • architectural clarity betwixt UI and Heap
    • some auto load / save currently.json file so that we can restart program w/o pain ... maybe just save on new user inputs ?
    • state.setDefault('var', num) or etc / types
    • perhaps all state objects like this ... still somehow state.var = // is a good operator ? don't really want state.var.set(num) and state.var.get()
    • states / uis / etc - one off / one-at-a-time for updates
    • i.e. all f'n update calls are to single module-global state update
    • !
    • states / getters / setters not applicable to sub-elements in an object within state
    • i.e. array access
    • consistent dereferencing, type checking implementation?

    UI Desires

    • scroll / grab events for touchpads etc ... find a mac user and workshop this for one afternoon ?
    • modules have visual ways to throw errors - i.e. flashing red, popping up...
    • off-screen divs get pointers-to so that we don't get lost
      • 'h' or something to zoom-to-extents
    • better module menu
    • hover for alt descriptions

    Planner Bugs

    • trapezoid linking doesn't account for speed changes properly, i.e. doesn't ramp down into next move if next move's cruise speed is less than our exit speed
    • should have some stronger ideas about flow control, allowable segment size (based on time)

    Want

    • log() for logs-from-module tagged

    Demo Desires

    • want to show immediacy of hardware: software representation
    • want to show physical reconfigurability and software reconfigurability
    • i.e. mill, add rotary tool, pull normal vector from planner moves and route to r motor
    • want to have UI elements
    • button, terminal,
    • live motor torque display, vector from accelerometer

    Network Desires

    • c improvements / dma etc, would be very cool
    • flow control probably desired ... what can we model with uart and implement with fpga?
    • proper speed tests
    • DMA not possible / not enough channels for router implementation / not portable enough ...
    • lights displaying activity

    Bugs

    • cannot connect input to output w/o backwards bezier
    • when source has changed, opening programs that have references to that source should be carefully done ...

    The RPI

    One of the desires here is to run programs headlessly on small embedded computers like the Raspberry Pi. The router has pogo-pins for this, so that when it's mounted beneath a Raspberry Pi the USB and Power lines are automatically hooked up - the 2A Buck Converter on the Router can also be used to power the RPI, so it can all run on one DC power bus. Nice!

    ATKRouter

    Setup the Raspberry Pi

    Install Node on the Raspberry Pi

    • to install node, download the distro you want from nodejs.org
    • extract the files, and hit these commands

    navigate to the distribution cd <distro> copy that to local space on the pi sudo cp -R * /usr/local/

    to check that node is installed, check the version using node -v which should return the version number of the distro you installed.

    However:

    need to figure out how to get the RPI serialport to talk