mep-master (master)

# Config()

Access to current configuration

# getDriver(driver)

Proxy to method Mep.DriverManager.getDriver(driver)

Parameters

# Log()

Logging system

# Mep()

Proxy to custom require(), Log, Config, DriverManager & services.

# Mep._driverManager()

Provides an instance of the DriverManager.

# Mep._motion()

Reference to motion service

# Mep._position()

Provides an instance of the PositionService.

# Mep._scheduler()

Provides an instance of the SchedulerService

# Mep._share()

Reference to share service

# Mep._terrain()

Provides an instance of the Terrain

# require(library)

Global function to require library relative to src directory

Parameters

# Telemetry()

Telemetry logging system

# ync()

Initialize necessary modules. Should be called only once during an application bootstrapping

# genOn(tag, action)

Helper that generates query string for .on()

Parameters

Returns

string

- Generated query string for .on()

# send(tag, action, params)

Send log or command to mep-dash.

Parameters

# Telemetry()

Enables communication between mep-master and mep-dash.

# telemetry.emit()

Packet arrived

# DriverChecker()

A goal of the class is to check if drivers are correctly implemented.

# callMethodByGroup(type, method, params)

Get all drivers that can provide specific type of data (or execute specific command) and call method.

Eg. imagine you have laptop and monitor. If a monitor is not available then your laptop is it totally ok with it, image will be sent only to laptop's monitor. However, if there is a monitor connected to the laptop then laptop will be aware of monitor and it will send an image to monitor too. Your laptop don't really recognize difference between displays, and it communicates between them in very similar way. To sum up, the same is for this method, method will be called to all drivers that are the part of the group.

Parameters

# DriverChecker()

# DriverManager()

Class manipulate drivers

DriverManager provides mechanisms to:

• initialize and configure drivers based on config files,
• return instance of driver by driver unique identifier,
• filter drivers by groups,
• check if driver is available,
• resolve dependencies and
• put driver out of order or recover driver if it is possible.

Each driver can be part of one or more of following groups: control, terrain & position.

# getDriver(name)

Get driver instance by driver name

Parameters

# getDriversByGroup(type)

Get all drivers that can provide specific type of data.

Every driver that can provide a certain type of data has implemented universal mechanism for getting that data from the driver. That is extremely useful for services and in that case services implement only logic for data processing, not mechanisms for data collection from different drivers. Services are in this case also hardware independent.

Parameters

# init()

Initialize all drivers

# isDriverAvailable(name)

Returns true if driver is available

Parameters

# isDriverOutOfOrder(name)

Check if driver is out of order

Parameters

# putDriverOutOfOrder(name, message)

Put driver out of order

Parameters

# _startCAN(device, bitrate)

private method

Start CAN bus device

Parameters

# CanDriver()

Driver for CAN bus (Controller Area Network)

# canDriver.emit()

Data arrived for specific ID.

# canDriver.emit()

Data arrived.

# constructor(name, config, config.device, config.bitrate)

Parameters

# EventEmitter()

# send(id, buffer)

Send buffer to specific ID

Parameters

# CanDriverSimulator()

Driver that simulates CAN bus

# EventEmitter()

# ColorDriver()

Driver detects color based on RGB components

# EventEmitter()

# getColor()

Get last read color

# rgbToHsl(r, g, b)

Converts an RGB color value to HSL. Conversion formula adapted from http://en.wikipedia.org/wiki/HSL_color_space. Assumes r, g, and b are contained in the set [0, 255] and returns h, s, and l in the set [0, 1].

Parameters

Returns

Array The HSL representation

# rgbToHsv(r, g, b)

Converts an RGB color value to HSV. Conversion formula adapted from http://en.wikipedia.org/wiki/HSV_color_space. Assumes r, g, and b are contained in the set [0, 255] and returns h, s, and v in the set [0, 1].

Parameters

Returns

Array The HSV representation

# start(interval)

Start reading data from sensor

Parameters

# stop()

Stop receiving RGB components

# DynamixelDriver()

Communicates with dynamixel servos (AX12 & RX24). NOTE: This class doesn't send start bytes & checksum, please make custom communicator (@dependecies.communicator) if you want these features.

# go(position, config, config.pollingPeriod, config.tolerance, config.timeout, config.firmwareImplementation)

Set servo to required position and get promise when position is reached

Parameters

# TaskError()

# HBridgeDriver(config, config.cid, [email protected])

Parameters

# TAG()

# constructor(name, config.infraredMaxDistance, config.sensorAngle, config.sensorX, config.sensorY, config.cid, config.objectSize, config['@dependencies'])

Make instance of InfraredDriver.

 Check image bellow to understand sensorAngle, sensorX & sensorY s1   s2   s3 \   |   / |---------| |  Robot  | |_________| Sensor s1 params: sensorAngle~=110, sensorY~10, sensorX~=10 Sensor s2 params: sensorAngle~=90, sensorY~=0, sensorX~=10 Sensor s3 params: sensorAngle~=60, sensorY~=-10, sensorX~=10 

Parameters

# disable()

Disable sensor

# enable()

Enable sensor

# EventEmitter()

# InfraredDriver()

Uses data from infrared sensors to determine where is an enemy robot and other obstacles.

# processDetection(buffer)

private method

Process detected obstacle

Parameters

# this.emit()

Obstacle detected event.

# _addPointToPolyGenerator(angle, distance)

private method

Process a measurement and try to make an obstacle approximation. It uses bounding box algorithm to make an approximation of the obstacle

Parameters

# _onDataReceived(data)

private method

Process data from lidar

Parameters

# disable()

Disable lidar driver

# enable()

Enable lidar driver

# EventEmitter()

# LidarDriver()

Provides an abstraction layer on top of lidar's firmware and algorithms to determine robot's position and obstacles

# this.emit()

Position changed event.

# LunarCollectorDriver(config.leftTrack, config.rightTrack, config.leftHand, config.rightHand)

Parameters

# TAG()

# constructor(name, config)

Creates instance of ModbusDriver

Parameters

# ModbusDriver()

Driver for Modbus communication protocol.

# ModbusDriverBinder()

# super.emit()

Coil value changed event.

# super.emit()

Coil value changed event on single address.

# EventEmitter()

# ModbusDriverSimulator()

Simulation for Modbus communication protocol

# _onDataReceived(buffer, type)

private method

Callback will be called when new packet is arrived and it will dispatch event to new callback depending on packet type

Parameters

# _onPReceived(buffer)

private method

Packet type P is received

Parameters

# constructor(name, config, config.startPosition, config.startOrientation, config.startSpeed, config.refreshDataPeriod, config.connectionTimeout, config.ackTimeout)

Parameters

# finishCommand()

Finish moveToCurvilinear command and prepare robot for another one

# getPosition()

Get position of the robot

Returns

misc.Point

Position of the robot

# goForward(millimeters)

Move robot forward or backward depending on sign

Parameters

# init()

Check driver by checking checking communication with motion driver board

# MotionDriver()

Driver enables communication with Memristor's motion driver.

# moveToCurvilinear(position, direction, radius, tolerance)

Move robot to absolute position but robot make curves to speed up motion. This command requires finishCommand() before next motion command.

Parameters

# moveToPosition(position, direction)

Move robot to absolute position

Parameters

# Point()

# requestRefreshData()

Request state, position and orientation from motion driver

# reset()

Reset all settings in motion driver

# rotateFor(angle)

Rotate for given angle

Parameters

# rotateTo(angle)

Rotate robot to given angle

Parameters

# setPositionAndOrientation(x, y, orientation)

Reset position and orientation

Parameters

# setSpeed(speed)

Set default speed of the robot

Parameters

# softStop()

Stop robot by turning off motors.

# stop()

Stop the robot.

# this.emit()

Position changed event.

# this.emit()

State change event.

# this.emit()

Orientation change event.

# MotionDriverController()

Remote controller for motion driver

# TAG()

# constructor(name, config)

Parameters

# getPosition()

Get position of the robot

Returns

Point

- Position of the robot

# motionDriver.emit()

Position changed event.

# motionDriver.emit()

State change event.

# motionDriver.emit()

Orientation change event.

# MotionDriverBinder()

# MotionDriverNative()

Natively (C++) implemented driver that enables communication with Memristor's motion driver.

# MotionDriverSimulator()

MotionDriverSimulator simulation module. Has same methods as MotionDriver but this module send all commands to simulator.

# Point()

# EventEmitter()

# PinDriver()

Communicates with pins on microcontrollers.

# read()

Read value of given pin

# tValue()

Get last value

# write(value)

Write value to given pin

Parameters

# EventEmitter()

# getTime()

Get time in seconds since match is started

Returns

number

- Seconds since match is started

# getTimeMills()

Get time in milliseconds since match is started

Returns

Number

Milliseconds since match is started

# StarterDriver()

Detects when rope is pulled out of the robot and starts counting game time.

# this.emit()

Tick event

# waitStartSignal()

Wait a start match signal (pulled rope, pressed key or delay)

Returns

Promise

# _onPacketReceived(packet, type)

private method

Method will be called only if protocol is not null and protocol generated packet.

Parameters

# constructor(name, config.device, config.baudRate, config.protocol)

Parameters

# fs()

# send(buffer, callback, type)

Send data to Uart

Parameters

# Uart()

Driver enables uart communication with electronic boards

# Usage()

# UsageDriver()

Logs memory and cpu usage

# add(callback)

Subscribe on event. Add callback function to queue.

Parameters

# CallbackQueue()

Queue of callback functions. It used when you want to allow other modules to subscribe to your events.

# notifyAll(params)

Call all callback functions from queue with same parameters.

Parameters

# TAG()

# CircularBuffer()

Implementation of circular buffer using Node.js's Buffer

# delay(milliseconds)

Synced setTimeout()

Parameters

# constructor(startPoint, endPoint)

Parameters

# getEndPoint()

Get end point

Returns

misc.Point

# getStartPoint()

Get start point

Returns

misc.Point

# isIntersectWithLine(line)

Check if it intersect with another line

Parameters

Returns

Boolean

True if two lines intersect

# isIntersectWithPolygon(polygon)

Check if it intersect with polygon

Parameters

# Line()

Line in 2D space

# Point()

# clone()

Clone the point

Returns

misc.Point

Cloned point

# constructor(x, y)

Make new point.

Parameters

# equals(point)

Check if points are equal

Parameters

# getDistance(point)

Calculate Euclidean distance between two Points

Parameters

# getX()

Return x coordinate

# getY()

Returns y coordinate

# Point()

Point in 2D space

# rotate(originPoint, angleDegrees)

Rotate point around origin point

Parameters

# rotateAroundZero(angleDegrees)

Optimized algorithm for point rotation around coordinate beginning

Parameters

# setX(x)

Set X coordinate

Parameters

# setY(y)

Set Y coordinate

Parameters

# translate(translatePoint)

Translate point

Parameters

# clone()

Clone a polygon

# constructor(tag, duration, points)

Parameters

# getDuration()

# getPoints()

# getTag()

# Point()

# Polygon()

Describes an polygon

# rotate(originPoint, angleDegrees)

Rotate all points of polygon around an origin point

Parameters

# rotateAroundZero(angleDegrees)

Optimized algorithm for polygon rotation around coordinate beginning

Parameters

# translate(translatePoint)

Translate all points of polygon

Parameters

# constructor(config.bufferSize, config.onDataCallback)

Parameters

# generate(buffer, type)

Generate packet

Parameters

# PLLSP()

Packetized Low-Level Secured Protocol

 0                   1                   2                   3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +--------------+-------+-------+---------------+----------------+ |  Start Byte  | Header|Payload|  Packet type  | Payload length | |    (0x3C)    |    Checksum   |               |                | +-------------------------------- - - - - - - - - - - - - - - - + :                     Payload Data continued ...                : + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + |                     Payload Data continued ...                | +---------------------------------------------------------------+ 

# push(chunkBuffer)

Push received data to receive buffer

Parameters

# _goSingleTarget(point, params, params.backward, params.tolerance, params.speed)

private method

Go to single point without advanced features

Parameters

Returns

Promise

# go(tunedPoint, parameters, parameters.pf, parameters.backward, parameters.rerouting, parameters.relative, parameters.tolerance, parameters.speed, parameters.obstacle, parameters.friend)

Move the robot, set new position of the robot

Parameters

# MotionService()

Provides a very abstract way to control and estimate robot position

# rotate(tunedAngle, options)

Rotate robot for an angle

Parameters

# stop(softStop)

Stop the robot

Parameters

# straight(millimeters, params, params.speed)

Move robot forward or backward depending on param millimeters

Parameters

# TaskError()

# MotionTarget()

Target (point & params) that robot has to reach

# TAG()

# addPointBack(point, params)

Add single point at the end of the queue

Parameters

# addPointFront(point, params)

Add single point at the beginning of the queue

Parameters

# addPointsBack(points, params)

Add points at the end of the queue

Parameters

# addPointsFront(points, params)

Add points at the beginning of the queue

Parameters

# empty()

Delete all items from queue

# getPfLine()

Make line between current position and target if path finding is enabled

# getPfTarget()

Get final target of path finding algorithm if path finding is enabled

# getTargetBack()

Get target at the end of the queue

# getTargetFront()

Get target at the front of queue

# getTargets()

Get all targets

# isEmpty()

Check if queue is empty

# MotionTarget()

# MotionTargetQueue()

Queue of targets (points) that robot has to reach.

# removeBack()

Remove target from back of queue

# removeFront()

Remove target from front of queue

# getOrientation()

Get current robot's orientation

# getPosition()

Get current robot's position

# Point()

# PositionService()

Implements algorithms to collect data from sensors and determine current robot's location

# k(tasks)

Algorithm to choose the best task

Parameters

# SchedulerService()

Implements algorithms to schedule task execution

# Task()

# EventEmitter()

# ShareService()

Automatically shares position, obstacles and task statuses between robots and provides simple API to share custom messages.

# this.emit()

Packet arrived

# EventEmitter()

# this.emit()

Packet arrived

# Udp()

Provides sharing based on UDP protocol. Same prototype should be used for other protocols.

# Point()

# TerrainService()

Class represent obstacles on the terrain and mechanism to search terrain between objects.

# constructor(maxX, minX, maxY, minY)

Creates terrain finding algorithm for an area

Parameters

# PathFindingBinder()

# super.addObstacle(points)

Parameters

Returns

Number

- ID of the obstacle

# super.removeObstacle(id)

Parameters

# super.search(start, goal)

Parameters

Returns

Array<misc.Point>

- Array of pairs (x, y)

# kError(reason)

Run default action if there is the exception in task is not caught with try {} catch(e) {}.

Parameters

# ks()

Get all registered task

# Scheduler()

Default scheduler class describes general task scheduling and robot behaviour

# TAG()

# Shortcut()

Populates global space with short functions and variables in order to provide easier and faster way to write strategies. NOTE: Polluting a global space generally is not a good way to go, however after a year of experience in this case it is a good solution.

# TunedPoint()

# ACTIVE()

Task is executing

# constructor(scheduler, parameters, parameters.weight, parameters.time, parameters.location)

Default constructor for task

Parameters

# finish()

Finish this task and run next one

# FINISHED()

Task is finished and it is not be consider in the future

# getState()

Get current state

# getTime()

Get predicted time of current task

# getWeight()

Get weight of current task

# isAvailable()

Condition which will be checked by SchedulerService to decide to run task or not. Eg. Release lunar modules only if there is lunar modules inside robot

# onRun()

This method will be executed as soon as mep run this task

# plusPriority()

Change priority during runtime

# Point()

# READY()

Task is ready to be executed

# run()

Run current task and change a state

# setState(state)

Set current state

Parameters

# setWeight(weight)

Change default weight of the task

Parameters

# suspend()

Suspend this task and run next one

# SUSPENDED()

Task is suspended and waiting a chance to become ready

# Task()

Default task class describes general task robot behaviour during task execution

# constructor(source, action, message, params)

Default constructor for class

Parameters

# TaskError()

Describes an error during strategy execution (eg. robot stuck)

# constructor(defaultAngle)

Add multiple angles, add angle for each table. It must has at least one angle which will be used as default. Other angles must have tag!

Parameters

# getAngle()

Get angle depending on the chosen table in configuration.

# TAG()

# TunedAngle()

Tunable angle. Angle is chosen depends on table name in configuration.

# constructor(defaultX, defaultY)

Add multiple Points, add Points for each table. It must has at least one Point which will be used as default. Other Points must have tag!

Parameters

# getPoint()

Get point depending on the chosen table in configuration.

# Point()

# TunedPoint()

Tunable Point. Point coordinates are choose depends on table name in configuration.

# Console()

Simplified functions for mep command prompt. All methods are accessible by using t. prefix.

# driver(id)

List driver properties for driver with id

Parameters

# drivers()

List all available drivers for current current configuration

# forward(millimeters)

Go forward

Parameters

# go(x, y, config)

Go to (x, y) position.

Parameters

# home()

Return robot to home

# rotate(angle, config)

Rotate to angle

Parameters

# test()

Motion driver test, drive robot in rectangle.

# onRun()

# Console()

Simplified functions for mep command prompt. All methods are accessible by using t. prefix.

# driver(id)

List driver properties for driver with id

Parameters

# drivers()

List all available drivers for current current configuration

# forward(millimeters)

Go forward

Parameters

# go(x, y, config)

Go to (x, y) position.

Parameters

# home()

Return robot to home

# rotate(angle, config)

Rotate to angle

Parameters

# test()

Motion driver test, drive robot in rectangle.