介绍

优微视视觉传感器，可以使用javascript作为脚本语言，对传感器进行控制。除了javascript的基本函数外。还提供了针对传感器的控制函数。

本教程详细介绍了这些控制函数。方便使用优微视视觉传感器的用户进行高级编程。

基本模块

模块变量： _applet

main

传感器被触发的时候运行的主函数。

如果在脚本中没有定义main函数，而且也没有用_applet.main()来指定主函数，传感器会顺序运行计算任务。

如果有定义main函数，则优先执行定义的主函数。

_applet.main(func)

func：处理函数

返回值：运行成功返回0，失败返回-1

/* 显式定义主函数*/
main(){
    /* do some thing here. */
}

/* 隐式定义主函数*/
function dotask(){
    /* do some thing here. */
}
_applet.main(dotask);

once

单次运行的函数。和main不同的地方，被此函数调用的函数只运行一次。

_applet.once(func)

func：处理函数

返回值：运行成功返回0，失败返回-1

/* 隐式定义主函数*/
function dotask(){
    /* do some thing here. */
}
_applet.once(dotask);

create

创建计算任务函数

_applet.create(task_class_name,task_name)

task_class_name：计算任务类名，如locate_circle,locate_blobs,find_line,find_circle

task_name：计算任务名，如locate_circle_1,locate_blobs_1,find_line_1,find_circle_2

返回值：创建成功返回 0；创建失败返回：-1

var ret = _applet.create('locate_circle','locate_circle_1');
assert(ret == 0);

destory

删除计算任务函数

_applet.destory(task_name)

task_name：计算任务名，如locate_circle_1

返回值：创建成功返回 0；创建失败返回：-1

var ret = _applet.destory('locate_circle_1');
assert(ret == 0);

order

计算任务执行顺序调整函数

_applet.order(task_name,id)

task_name：计算任务名，如locate_circle_1

id：调整到的位置

返回值：创建成功返回 0；创建失败返回：-1

var ret = _applet.order('locate_circle_1',3);
assert(ret == 0);

sync

同步计算任务结果函数，将参数保存到运行环境

_applet.sync(task_name)

task_name：计算任务名，如locate_circle_1

返回值：创建成功返回 0；创建失败返回：-1

var ret = _applet.sync('locate_circle_1');
assert(ret == 0);

set

设置计算任务参数任务

_applet.set(name,value)

name： 参数名称

value：参数值

返回值：运行成功返回0；运行失败返回 -1；

ret = _applet.set('locate_circle_1.pass',1);
assert(ret == 1);

get

设置计算任务参数任务

_applet.get(name)

name： 参数名称

返回值：运行成功返回 对应值；运行失败返回 -1；

ret = _applet.get('locate_circle_1.pass');
assert(ret == 1);

任务模块

使用传感器的编程IDE添加运算任务后，(默认添加acquire_image),如增加圆定位计算任务，locate_circle_1,在javascript运行环境中会自动添加全局变量 var locate_circle_1。

locate_circle_1的属性中包含三个成员函数：parse() 用来对参数进行分析； restore() 用来对参数进行保存；run() 用来运行运算函数

parse

分析运算参数

parse(options)

options:运行任务的配置参数。 返回值：运行成功返回0；运行失败返回 -1；

var param = {pass:0,pass_count:1,fail:0,fail_count:1,Enable:1};

locate_circle_1.parse(param);

restore

保存计算参数

restore()

返回值：运行成功返回0；运行失败返回 -1；

locate_circle_1.restore();

run

运行计算任务

run()

返回值：运行成功返回0；运行失败返回 -1；

locate_circle_1.run();

sync

同步计算任务结果函数，将参数保存到运行环境

sync()

返回值：创建成功返回 0；创建失败返回：-1

var ret = locate_circle_1.sync();
assert(ret == 0);

网络模块

模块变量 _http

get

设置get接口

_http.get(url,func)

url：接口名称

func：响应函数

function motor_get(opt){
    /* opt get parameter.
     * http://ip/usr/motor?x=1.0&y=2.0&z=3.0
     * opt = {
     *      x:1.0,
     *      y:2.0,
     *      z:3.0
     *  }
     */
    /* do some thing here. */
}

ret = _http.get('/usr/motor',motor_get);
assert(ret == 1);

post

设置post接口

_http.post(url,func)

url：接口名称

func：响应函数

function motor_port(){
    /* opt: post message as json.
     * sendRequeset(JSON.stringify({x:1.0,y:2.0,z:3.0}));
     * opt = {
     *      x:1.0,
     *      y:2.0,
     *      z:3.0
     *  }
     */
    /* do some thing here. */
}

ret = _http.post('/usr/motor',motor_post);
assert(ret == 1);

put

设置put接口

_http.put(url,func)

url：接口名称

func：响应函数

function motor_put(opt){
    /* do some thing here. */
}

ret = _http.post('/usr/motor',motor_put);
assert(ret == 1);

del

设置del接口

_http.del(url,func)

url：接口名称

func：响应函数

ret = _http.post('/usr/motor',function(opt){
    /* do some thing here. */
});
assert(ret == 1);

response

请求返回函数

_http.response(message)

message：返回的消息

ret = _http.response('ok');
assert(ret == 1);

broadcast

广播函数

_http.broadcast(message)

message：广播的消息

ret = _http.broadcast('proccess ok');
assert(ret == 1);

图像模块

模块变量：_image

load

读取图像，支持图像类型JPEG(.jpg)，BMP(.bmp)，YUV(.yuv)，load函数通过 文件扩展名判断图像的类型，yuv图像，通过widthXheight_formt的形式判断图像的宽度高度和类型。

load(path)

path：图像路径和名称

返回值：成功返回0；失败返回 -1

_image.load('./test.jpg');

save

保存图像，将当前正在处理的图像保存，支持图像类型JPEG(.jpg)，BMP(.bmp)，YUV(.yuv)，load函数通过 文件扩展名判断图像的类型，yuv图像，通过widthXheight_formt的形式判断图像的宽度高度和类型。

save(path)

path：图像路径和名称

返回值：成功返回0；失败返回 -1

_image.load('./test.jpg');

capture

从传感器实时图像中抓取一帧图像，图像的宽度和高度，由传感器决定。

capture()

返回值：成功返回0；失败返回-1

_image.capture();

rotate

图像旋转

rotate(x,y,angle)

x：旋转中心x坐标

y：旋转中心y坐标

angle：旋转角度

返回值：成功返回0；失败返回-1

_image.rotate(100,100,30);

串口模块

模块变量 _serial

open

打开串口函数

_serial.open(options)

options：串口参数，buad rate,priaty,data bit,stop bit

var serial2 = _serial.open({speed:115200,priaty:0,data_bit:8,stop_bit:0});

read

读串口函数

read(count,timeout)

count：读取数量

timeout：读取超时时间，以毫秒为单位

返回值：读取的数据，类型为字符串或数组

var ret = serial2.read(10,1000);
print(ret);

write

读串口函数

write(buffer,count)

buffer：写内容

count：写取数量

返回值：写入的字节数

var ret = serial2.write('test',4);
assert(ret == 4);

close

关闭串口函数

close()

返回值：关闭成功返回0；失败返回-1

var ret = serial2.close();
assert(ret == 1);

Modbus模块

模块变量：_modbus

open

打开函数

open(mode,options);

mode：模式，‘rtu‘，’tcp‘

options：参数，如果式rtu模式则为串口参数{baud,praity,data_bit,stop_bit} 如果式tcp模式则是网口参数{ip,port}

返回值：成功返回modbus对象，失败返回-1

var md = _modbus.open('rtu',{buad:115200,praity:0,data_bit:8,stop_bit:0});

var md = _modbus.open('tcp',{ip:'192.168.0.38':8080});

check

检查函数,检查modbus是否已经打开，如果没有打开则打开，如果已经打开，检查参数是否相同，如果不相同，则关闭原来的句柄，并用新参数打开

check(mode,options)

mode：模式，‘rtu‘，’tcp‘

options：参数，如果式rtu模式则为串口参数{baud,praity,data_bit,stop_bit} 如果式tcp模式则是网口参数{ip,port}

返回值：成功返回0，失败返回-1

var md = _modbus.check('rtu',{buad:115200,praity:0,data_bit:8,stop_bit:0});

var md = _modbus.check('tcp',{ip:'192.168.0.38':8080});

slave

设置slave的id

slave(id)

id：slave的id

返回值：成功返回0；错误返回-1

var ret = md.slave(1);
assert(ret == 1);

read_bits

读取触点函数

read_bits(address,count)

address：触点地址

count：触点个数

返回值：触点值BOOL型，错误返回-1

var val = md.read_bits(10,1);

read_inputbits

读取输入寄存器函数

read_inputbits(address,count)

address：触点地址

count：触点个数

返回值：触点值BOOL型，错误返回-1

var val = md.read_inputbits(10,1);

read_registers

读取寄存器函数

read_registers(address,count)

address：地址

count：数量

返回值：寄存器值，错误返回-1

var val = md.read_registers(10,1);

read_inputregisters

读取输入寄存器函数

read_inputregisters(address,count)

address：地址

count：数量

返回值：寄存器值，错误返回-1

var ret = md.read_inputregisters(10,1);
assert(ret == 1);

write_bit

写触点

write_bit(address,value)

address：触点地址

value：触点值

返回值：写成功返回0，错误返回-1

var ret = md.write_bit(10,1);
assert(ret == 1);

write_bits

写多个触点

write_bits(address,value)

address：触点地址

value：触点值，类型为数组

返回值：写成功返回0，错误返回-1

var ret = md.write_bits(10,[1,0]);
assert(ret == 1);

write_register

写寄存器

write_register(address,value)

address：地址

value：寄存器值

返回值：写成功返回0，错误返回-1

var ret = md.write_register(10,10]);
assert(ret == 1);

write_registers

写多个寄存器

write_registers(address,value)

address：地址

value：寄存器值，类型数组

返回值：写成功返回0，错误返回-1

var ret = md.write_registers(10,[10,20]);
assert(ret == 1);

send_string

发送文本信息函数

send_string(message)

message：待发送信息

返回值：发送成功返回0，错误返回-1

var ret = md.send_string('test');
assert(ret == 1);

close

关闭函数

close()

返回值：成功返回0，错误返回-1

var ret = md.close();
assert(ret == 1);

Plc模块

模块变量：_plc

PLC相关函数支持的PLC类型有 西门子，松下，欧姆龙和霍尼韦尔

相关的PLC的地址命名如下

西门子PLC的寄存器地址

  • DBBxx、DBWxx、DBDxx（DIBxx+、DIWxx、DIDxxx 字节，字，双字

  • DBX+．+（或DIXx．x） 二进制地址

  • DB 数据块

  • M 内部标志存储区

  • I 输入输出映像寄存器

  • Q 输出继电器

松下PLC寄存器地址

  • X Y 外部输入输出继电器

  • WX WY 外部输入输出继电器字

  • R 内部继电器

  • DT 数据寄存器

欧姆龙PLC地址

  • 输入输出寄存器

  • IR 内部辅助继电器

  • SR 特殊继电器

  • HR 保持继电器

  • TR 暂存继电器

open

打开plc函数

open(name,options)

name：PLC名,目前支持siemens, panasonic,omron,ab

options：打开参数，如果是串口类型的，如panasonic，则是串口参数 {baud,praity,data_bit,stop_bit} 如果是tcp或udp类型的则是网络参数 {ip,port}

var plc0 = _plc.open('panasonic',{buad:115200,priaty:0,data_bit:8,stop_bit:0});

read_bit

读取触点函数

read_bit(address)

adress：地址

返回值：触点值，类型微BOOL，失败返回-1

var ret = plc0.read_bit('X10');

read_byte

按字节读取寄存器函数

read_byte(address)

address：地址

返回值：成功则返回寄存器值；失败返回-1

var val = plc0.read_byte('DT10');

read_bytes

按字节读取寄存器函数

read_bytes(address,count)

address：起始地址

count：数量

返回值：成功返回寄存器值，类型为数组；失败返回-1

var val = plc0.read_bytes('DT10',2);

read_u16

按16bit无符号数读取寄存器

read_u16(address)

address：地址

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.read_u16('DT10');

read_s16

按16bit有符号数读取寄存器

read_s16(address)

address：地址

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.read_s16('DT10');

read_u32

按32bit无符号数读取寄存器

read_u32(address)

address：地址

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.read_u32('DT10');

read_s32

按32bit有符号数读取寄存器函数

read_s32(address)

address：地址

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.read_u32('DT10');

read_float

按浮点数读取寄存器

read_float(address)

address：地址

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.read_float('DT10');

read_string

读取字符串函数

read_string(address,length)

address：地址

length：读取字符串长度

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.read_string('DT10');

write_bit

写触点函数

write_bit(address,value)

address：地址

value：写入值

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_bit('X10',1);

write_byte

按字节写寄存器函数

write_byte(address,value)

address：地址

value：写入值

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_byte('DT10',1);

write_bytes

按字节写寄存器函数

write_bytes(address,value,length)

address：地址

value：写入值,类型为数组

length：数据长度,此参数可选

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_byte('DT10',[1,2],2);

write_u16

按16bit无符号数写寄存器

write_u16(address,value)

address：地址

value：写入值

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_u16('DT10',1);

write_s16

按16bit有符号数写寄存器

write_s16(address,value)

address：地址

value：写入值

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_s16('DT10',1);

write_u32

按32bit无符号数写寄存器

write_u32(address,value)

address：地址

value：写入值

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_u32('DT10',1);

write_s32

按32bit有符号数写寄存器

write_s32(address,value)

address：地址

value：写入值

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_s32('DT10',1);

wriet_float

按浮点数写寄存器

write_float(address,value)

address：地址

value：写入值

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_float('DT10',1);

write_string

写字符串函数

write_string(address,value,length)

address：地址

value：写入值

lenght：字符串长度，此参数可选

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.write_string('DT10','test');

close

关闭函数

close()

返回值：成功则返回寄存器值，失败返回-1

var val = plc0.close();

光源控制模块

模块变量：_light

on

开关控制函数

_light.on(val)

val：光源开关标志 打开1；关闭0

返回值：成功返回0，失败返回-1

var ret = _light.on(0); /* 关闭光源 */

var ret = _light.on(1); /* 打开光源 */

flash

频闪控制函数

_light.flash(val)

val：光源开关标志 打开1；关闭0

返回值：成功返回0，失败返回-1

var ret = _light.flash(0); /* 关闭光源 */

var ret = _light.flash(1); /* 打开光源 */

bright

亮度控制函数

_light.bright(val)

val：光源亮度值，最小0，最大1.0

返回值：成功返回0，失败返回-1

var ret = _light.bright(0.2); /* 光源亮度20% */

mode

模式控制函数

_light.mode(val)

val：模式值，常开0，频闪1

返回值：成功返回0，失败返回-1

var ret = _light.mode(0); /* 常开模式 */

IO控制模块

模块变量：_gpio

open

打开IO函数

_gpio.open(id)

id：IO参数

var gpio2 = _gpio.open(0);

read

读IO函数

read()

返回值：读取的数据，类型为bool类型

var ret = gpio2.read();
print(ret);

write

读IO函数

write(id,value)

id：IO的id

value：值

返回值：写入成功返回0，失败返回-1

var ret = gpio2.write(0,1);
assert(ret == 0);

关闭IO函数

close()

返回值：关闭成功返回0；失败返回-1

var ret = gpio2.close();
assert(ret == 1);

TCP模块

模块变量：_tcp

open

打开TCP函数

_tcp.open(ip,port)

ip：IP参数

port：端口

返回值：tcp对象

var tcp1 = _tcp.open('192.168.0.38',8080);

read

读TCP函数

read(count,timeout)

count：读取数量

timeout：读取超时时间，以毫秒为单位

返回值：读取的数据，类型为字符串或数组

var ret = tcp1.read(10,1000);
print(ret);

write

读TCP函数

write(buffer,count)

buffer：写内容

count：写取数量

返回值：写入的字节数

var ret = tcp1.write('test',4);
assert(ret == 4);

close

关闭TCP函数

close()

返回值：关闭成功返回0；失败返回-1

var ret = tcp1.close();
assert(ret == 1);

UDP模块

模块变量：_udp

open

打开UDP函数

_gpio.open(id)

ip：IP参数

port：端口

返回值：udp对象

var udp1 = _udp.open('192.168.0.38',8080);

read

读UDP函数

read(count,timeout)

count：读取数量

timeout：读取超时时间，以毫秒为单位

返回值：读取的数据，类型为字符串或数组

var ret = udp1.read(10,1000);
print(ret);

write

读UDP函数

write(buffer,count)

buffer：写内容

count：写取数量

返回值：写入的字节数

var ret = udp1.write('data',4);
assert(ret == 4);

close

关闭UDP函数

close()

返回值：关闭成功返回0；失败返回-1

var ret = udp1.close();
assert(ret == 1);

标定模块

模块变量：_calib

nine

九点标定

nine(from,to)

from：mark点

to：参考点

返回值：标定成功返回标定参数coeffs，标定失败返回-1

var from = [
            {x:0, y:0},
            {x:1, y:1},
            {x:2, y:2},
            {x:3, y:3},
            {x:4, y:4},
            {x:5, y:5},
            {x:6, y:6},
            {x:7, y:7},
            {x:8, y:8}
         ];
var to = [
            {x:0, y:10},
            {x:1, y:11},
            {x:2, y:12},
            {x:3, y:13},
            {x:4, y:14},
            {x:5, y:15},
            {x:6, y:16},
            {x:7, y:17},
            {x:8, y:18}
         ];
var coeffs = _calib.nine(from,to);

two

两点标定

two(from,to)

from：mark点

to：参考点

返回值：标定成功返回标定参数coeffs，标定失败返回-1

var from = [ {x:0, y:0},
             {x:1, y:1} ];
var to = [ {x:0, y:10},
           {x:1, y:11} ];
var coeffs = _calib.two(from,to);

coeffs

标定参数设置

coeffs(coeffs)

coeffs：标定参数,大于9个数值的数组

返回值：标定成功返回0，标定失败返回-1

var coeffs = [1.0, 0.0, 0.0,
              0.0, 1.0, 0.0,
              0.0, 0.0, 1.0];
var ret = _calib.coeffs(coeffs);

correct

校正函数

correct(points,coeffs)

points：需要矫正的点

coeffs：矫正参数

返回值：矫正成功返回矫正后的点信息，失败返回-1

var to = [  {x:0, y:10},
            {x:1, y:11},
            {x:2, y:12},
            {x:3, y:13},
            {x:4, y:14},
            {x:5, y:15},
            {x:6, y:16},
            {x:7, y:17},
            {x:8, y:18} ];
var coeffs = [1.0, 0.0, 0.0,
              0.0, 1.0, 0.0,
              0.0, 0.0, 1.0];
var results = _calib.correct(points,coeffs);