定制的测控软件能实现哪些功能?

适用范围

各种测控应用场景。

跨平台部署：win7及以上，linux系列、android3.0及以上（后续支持）。

开发语言：C++，C#（后续支持）

图形化展示

目前支持各种文本标签、数字标签；

支持趋势图、波动图、缺陷图及统计图表。

目前支持圆形、高度、宽度、厚度、螺纹钢等截面图动态显示，且支持扩展。

界面布局

向导式配置，带你从零开始构建自己的解决方案。

支持拖拽式交互设计。

支持自定义界面布局。

支持自定义样式。

流畅刷新

内置网络、串口采样模块，支持高速数据采集。

应用无锁队列、内存数据库等核心技术，实现采样数据无卡顿、无丢失快速刷新。

接口丰富

内嵌网络（TCP、UDP）、串口（RS422、RS232，RS485）通信模块。

支持Modbus通信协议。

目前支持各种报警灯、步进电机、伺服电机、CCD传感器、微视相机等设备接入。

二次开发

提供SDK开发包，支持二次开发。

无锁队列、内存数据库，多线程、及各种设计模式，对SDK屏蔽复杂性，上手速度快。

对外提供开发接入服务，快速为您的设备提供理想的上位机软件。

实现了一个lock free queue，自测通过。有需要的拿去。

```

#ifndef __LFQUEUE_H__

#define __LFQUEUE_H__

#include <thread>

#include <iostream>

#include <atomic>

#include "dtype.h"

#include "os/Win.h"

#include "logger.h"

#define CAS2(obj, expected, desired) std::atomic::atomic_compare_exchange_weak(obj, expected, desired)

#ifdef WIN32

#define CAS(ptr, oldvalue, newvalue) InterlockedCompareExchange(ptr, newvalue, oldvalue)

#else

#define CAS(ptr, oldvalue, newvalue) __sync_val_compare_and_swap(ptr , oldvalue , newvalue)

#endif

typedef struct queue_elem

{

void* data

bool origin // 0: from GRPC, 1: from Self

queue_elem(void* e, uint32 o) { data = eorigin = o}

} QueueElem

class LockFreeQueue

{

public:

LockFreeQueue(int32 capicity)

: capicity_(capicity), header_(0), tailer_(0), guard_(0)

{

if (capicity_ <4) { capicity_ = 4}

lf_queue_ = new QueueElem*[capicity_]

for (int i = 0i <capicity_i++)

lf_queue_[i] = NULL

}

~LockFreeQueue() { if (lf_queue_) { delete [] lf_queue_} }

public:

enum QStatus {

Empty,

Full,

Normal,

Unknown

}

//bool isempty() { return header_ == tailer_}

// guard_ is the maximum dequeue item

bool isempty() { return header_ == guard_}

bool isfull() { return (internal_index(tailer_ + 1)) == header_}

int32 internal_index(int32 v) { return (v % capicity_)}

bool enqueue(QueueElem* item)

{

int32 temp,guard

assert(item)

do

{

// fetch tailer_ first and then judge isfull, else encounter concurrent problem

temp = tailer_

guard = guard_

if (isfull())

{

return false

}

// cross operate

if (CAS(&tailer_, temp, internal_index(temp + 1)) == temp)

{

lf_queue_[temp] = item

// update the guard_ for the max dequeue item

CAS(&guard_, guard, internal_index(guard + 1))

break

}

else

{

//std::cout <<"enqueue Cas failure one times" <<std::endl

}

} while (true)

return true

}

bool dequeue(QueueElem** item)

{

int32 temp

do

{

// fetch header first and then judge isempty, else encounter concurrent problem

temp = header_

*item = NULL

if (isempty())

{

return false

}

// cross operate CAS failure

*item = lf_queue_[temp]

if (CAS(&header_, temp, internal_index(temp + 1)) == temp)

{

// some producer lock one slot, but doesn't push back

// while (!lf_queue_[temp])

// {

// std::this_thread::yield()

// }

//*item = lf_queue_[temp]

lf_queue_[temp] = NULL

break

}

else

{

//std::cout <<"dequeue Cas failure one times" <<std::endl

}

} while (true)

return true

}

private:

QueueElem** lf_queue_

int32 capicity_

#ifdef WIN32

LONG header_

LONG tailer_

LONG guard_ // header <= guard <= tailer

#else

int32 header_

int32 tailer_

int32 guard_ // header <= guard <= tailer

#endif

}

#endif

```

---