Browse Source

update

master
zhaohe 1 year ago
parent
commit
41e6040902
  1. 2
      app_protocols/transmit_disfection_protocol
  2. 19
      usrc/board/liquid_ctrl_board.cpp
  3. 9
      usrc/board/liquid_ctrl_board.hpp
  4. 192
      usrc/protocol_processer_impl/liquid_ctrl_board_cmd_processer.cpp
  5. 41
      usrc/protocol_processer_impl/liquid_ctrl_board_cmd_processer.hpp
  6. 4
      usrc/protocol_processer_impl/public_cmd_processer.cpp
  7. 14
      usrc/protocol_processer_mgr/i_protocol_processer.hpp
  8. 2
      zsdk

2
app_protocols/transmit_disfection_protocol

@ -1 +1 @@
Subproject commit 7ec8b89424ab02856d3c48a77dfb11e790db4693
Subproject commit 591e174e21072cc71d6288d6c5cfa00f34952e9b

19
usrc/board/liquid_ctrl_board.cpp

@ -160,26 +160,21 @@ void LiquidCtrlBoard::initialize() {
/***********************************************************************************************************************
* *
***********************************************************************************************************************/
m_motor_spi.init(&MOTOR_SPI);
m_tmc_power_pin.initAsOutput(TMC_POWER, kxs_gpio_nopull, true, false);
osDelay(100);
m_tmc_power_pin.write(true);
// PB2
m_motor[0].initialize(&m_motor_spi, MOTOR0_ENN, MOTOR0_CSN);
m_motor[0].setIHOLD_IRUN(1, 15, 0);
m_motor[0].initialize({&MOTOR_SPI, MOTOR0_CSN, MOTOR0_ENN});
m_motor[0].setIHOLD_IRUN(1, 28, 0);
m_motor[0].setMotorShaft(true);
m_motor[0].setAcceleration(300000);
m_motor[0].setDeceleration(300000);
m_motor[1].initialize(&m_motor_spi, MOTOR1_ENN, MOTOR1_CSN);
m_motor[1].setIHOLD_IRUN(1, 15, 0);
m_motor[1].initialize({&MOTOR_SPI, MOTOR1_CSN, MOTOR1_ENN});
m_motor[1].setIHOLD_IRUN(1, 28, 0);
m_motor[1].setMotorShaft(true);
m_motor[1].setAcceleration(300000);
m_motor[1].setDeceleration(300000);
int32_t chipv0 = m_motor[0].readChipVERSION(); // 5130:0x11
int32_t chipv1 = m_motor[1].readChipVERSION(); // 5130:0x11
int32_t chipv0 = m_motor[0].readICVersion(); // 5130:0x11
int32_t chipv1 = m_motor[1].readICVersion(); // 5130:0x11
// m_motor[0].rotate(500000);
// m_motor[1].rotate(500000);
ZLOGI(TAG, "chipv0: %x, chipv1: %x", chipv0, chipv1);
@ -214,7 +209,7 @@ void LiquidCtrlBoard::initialize() {
}
int32_t LiquidCtrlBoard::motorNum() { return ZARRAY_SIZE(m_motor); }
TMC5130* LiquidCtrlBoard::motor(int32_t index) {
TMC51X0* LiquidCtrlBoard::motor(int32_t index) {
if (index < ZARRAY_SIZE(m_motor)) {
return &m_motor[index];
}

9
usrc/board/liquid_ctrl_board.hpp

@ -1,3 +1,4 @@
#pragma once
#include <stddef.h>
#include <stdio.h>
@ -7,17 +8,17 @@
//
#include "zsdk/modbus/modbus_block_host.hpp"
#include "zsdk/pxx_pressure_sensor_driver/pxx_pressure_sensor_bus.hpp"
#include "zsdk/tmc/ztmc5130.hpp"
#include "zsdk/tmcdriver/tmc51x0/tmc51x0.hpp"
#include "zsdk/zsdk.hpp"
namespace iflytop {
class LiquidCtrlBoard {
public:
ZGPIO m_evaporation_bin_water_sensor; // 蒸发仓水浸
ZGPIO m_device_bottom_water_sensor; // 设备底部水浸
ZSPI m_motor_spi; // SPI
ZGPIO m_tmc_power_pin; //
TMC5130 m_motor[2]; // 蠕动泵控制
TMC51X0 m_motor[2]; // 蠕动泵控制
ZGPIO triLight_R;
ZGPIO triLight_G;
@ -35,7 +36,7 @@ class LiquidCtrlBoard {
void initialize();
int32_t motorNum();
TMC5130* motor(int32_t index);
TMC51X0* motor(int32_t index);
PXXPressureSensorBus* pressureSensorBus();

192
usrc/protocol_processer_impl/liquid_ctrl_board_cmd_processer.cpp

@ -0,0 +1,192 @@
#include "liquid_ctrl_board_cmd_processer.hpp"
#include "board/liquid_ctrl_board.hpp"
using namespace iflytop;
static osTimerId MotorMonitorTimerId; // 压力传感器数值上报
static bool motorErrorFlagCache[10]; // 电机异常状态上报标志位
static zmutex motorErrorFlagCacheLock;
static bool motorErrorFlag_get(int subindex) {
bool ret;
{
zlock_guard guard(motorErrorFlagCacheLock);
ret = motorErrorFlagCache[subindex];
}
return ret;
}
static void motorErrorFlag_set(int subindex, bool val) {
{
zlock_guard guard(motorErrorFlagCacheLock);
motorErrorFlagCache[subindex] = val;
}
}
#define DEVICE LiquidCtrlBoard::ins()
void LiquidCtrlBoardCmdProcesser::initialize() { motorErrorFlagCacheLock.init(); }
bool LiquidCtrlBoardCmdProcesser::isSupportThisCmd(ProcessContext* cxt) { return false; }
/***********************************************************************************************************************
* PUMP *
***********************************************************************************************************************/
void LiquidCtrlBoardCmdProcesser::pump_rotate(ProcessContext* cxt) {
CHECK_PARAM_LEN(PRAAM_LEN(), 2);
int32_t subindex = GET_PARAM(0);
int32_t velocity = GET_PARAM(1);
if (subindex >= DEVICE->motorNum()) {
zcanbus_send_errorack(cxt->packet, kerr_invalid_param);
return;
}
if (!DEVICE->motor(subindex)->ping()) {
zcanbus_send_errorack(cxt->packet, kerr_motor_subdevice_offline);
return;
}
DEVICE->motor(subindex)->enable(false);
DEVICE->motor(subindex)->enable(true);
DEVICE->motor(subindex)->moveToEnd(velocity > 0 ? 1 : -1, abs(velocity));
zcanbus_send_ack(cxt->packet, NULL, 0);
motorErrorFlag_set(subindex, false);
}
void LiquidCtrlBoardCmdProcesser::pump_stop(ProcessContext* cxt) {
CHECK_PARAM_LEN(PRAAM_LEN(), 1);
int32_t subindex = GET_PARAM(0);
if (subindex >= DEVICE->motorNum()) {
zcanbus_send_errorack(cxt->packet, kerr_invalid_param);
return;
}
if (!DEVICE->motor(subindex)->ping()) {
zcanbus_send_errorack(cxt->packet, kerr_motor_subdevice_offline);
return;
}
DEVICE->motor(subindex)->stop();
zcanbus_send_ack(cxt->packet, NULL, 0);
}
void LiquidCtrlBoardCmdProcesser::pump_set_ihold_irun_idelay(ProcessContext* cxt) {
CHECK_PARAM_LEN(PRAAM_LEN(), 4);
int32_t subindex = GET_PARAM(0);
int32_t ihold = GET_PARAM(1);
int32_t irun = GET_PARAM(2);
int32_t idelay = GET_PARAM(3);
if (subindex >= DEVICE->motorNum()) {
zcanbus_send_errorack(cxt->packet, kerr_invalid_param);
return;
}
if (!DEVICE->motor(subindex)->ping()) {
zcanbus_send_errorack(cxt->packet, kerr_motor_subdevice_offline);
return;
}
DEVICE->motor(subindex)->setIHOLD_IRUN(ihold, irun, idelay);
zcanbus_send_ack(cxt->packet, NULL, 0);
}
void LiquidCtrlBoardCmdProcesser::pump_set_acc(ProcessContext* cxt) {
CHECK_PARAM_LEN(PRAAM_LEN(), 2);
int32_t subindex = GET_PARAM(0);
int32_t acc = GET_PARAM(1);
if (subindex >= DEVICE->motorNum()) {
zcanbus_send_errorack(cxt->packet, kerr_invalid_param);
return;
}
if (!DEVICE->motor(subindex)->ping()) {
zcanbus_send_errorack(cxt->packet, kerr_motor_subdevice_offline);
return;
}
DEVICE->motor(subindex)->setAmax(acc);
DEVICE->motor(subindex)->setDmax(acc);
zcanbus_send_ack(cxt->packet, NULL, 0);
}
void LiquidCtrlBoardCmdProcesser::pump_set_subic_reg(ProcessContext* cxt) {
CHECK_PARAM_LEN(PRAAM_LEN(), 3);
int32_t subindex = GET_PARAM(0);
int32_t regadd = GET_PARAM(1);
int32_t regval = GET_PARAM(2);
if (subindex >= DEVICE->motorNum()) {
zcanbus_send_errorack(cxt->packet, kerr_invalid_param);
return;
}
if (!DEVICE->motor(subindex)->ping()) {
zcanbus_send_errorack(cxt->packet, kerr_motor_subdevice_offline);
return;
}
DEVICE->motor(subindex)->writeIntExt(regadd, regval);
}
void LiquidCtrlBoardCmdProcesser::pump_get_subic_reg(ProcessContext* cxt) {
CHECK_PARAM_LEN(PRAAM_LEN(), 2);
int32_t subindex = GET_PARAM(0);
int32_t regadd = GET_PARAM(1);
if (subindex >= DEVICE->motorNum()) {
zcanbus_send_errorack(cxt->packet, kerr_invalid_param);
return;
}
if (!DEVICE->motor(subindex)->ping()) {
zcanbus_send_errorack(cxt->packet, kerr_motor_subdevice_offline);
return;
}
int32_t val = DEVICE->motor(subindex)->readIntExt(regadd);
zcanbus_send_ack(cxt->packet, (uint8_t*)&val, sizeof(val));
}
void LiquidCtrlBoardCmdProcesser::pump_ping(ProcessContext* cxt) {
CHECK_PARAM_LEN(PRAAM_LEN(), 1);
int32_t subindex = GET_PARAM(0);
if (subindex >= DEVICE->motorNum()) {
zcanbus_send_errorack(cxt->packet, kerr_invalid_param);
return;
}
if (!DEVICE->motor(subindex)->ping()) {
zcanbus_send_errorack(cxt->packet, kerr_motor_subdevice_offline);
return;
}
zcanbus_send_ack(cxt->packet, NULL, 0);
}
/***********************************************************************************************************************
* WS *
***********************************************************************************************************************/
void LiquidCtrlBoardCmdProcesser::evaporation_bin_water_sensor_read_state(ProcessContext* cxt) {
int32_t val = DEVICE->m_evaporation_bin_water_sensor.read();
zcanbus_send_ack(cxt->packet, (uint8_t*)&val, sizeof(val));
}
void LiquidCtrlBoardCmdProcesser::device_bottom_water_sensor_read_state(ProcessContext* cxt) {
int32_t val = DEVICE->m_device_bottom_water_sensor.read();
zcanbus_send_ack(cxt->packet, (uint8_t*)&val, sizeof(val));
}
/***********************************************************************************************************************
* PRESSURE *
***********************************************************************************************************************/
void LiquidCtrlBoardCmdProcesser::pressure_sensor_bus_read_data(ProcessContext* cxt) {}
void LiquidCtrlBoardCmdProcesser::pressure_sensor_bus_set_report_period_ms(ProcessContext* cxt) {}
/***********************************************************************************************************************
* WARNING LIGHT *
***********************************************************************************************************************/
void LiquidCtrlBoardCmdProcesser::triple_warning_light_ctl(ProcessContext* cxt) {}

41
usrc/protocol_processer_impl/liquid_ctrl_board_cmd_processer.hpp

@ -0,0 +1,41 @@
#pragma once
#include "protocol_processer_mgr/i_protocol_processer.hpp"
namespace iflytop {
using namespace std;
using namespace zscanprotocol;
using namespace transmit_disfection_protocol;
class LiquidCtrlBoardCmdProcesser : public IProtocolProcesser {
list<CmdProcesser> cmdprocesser;
uint8_t boardResetFlag; // 0: 重启标志
public:
static LiquidCtrlBoardCmdProcesser* ins() {
static LiquidCtrlBoardCmdProcesser ins;
return &ins;
}
virtual void initialize() override;
virtual const char* getName() override { return "LiquidCtrlBoardCmdProcesser"; };
virtual bool isSupportThisCmd(ProcessContext* cxt) override;
virtual void process(ProcessContext* cxt) override;
private:
void evaporation_bin_water_sensor_read_state(ProcessContext* cxt);
void device_bottom_water_sensor_read_state(ProcessContext* cxt);
void pump_rotate(ProcessContext* cxt);
void pump_stop(ProcessContext* cxt);
void pump_set_ihold_irun_idelay(ProcessContext* cxt);
void pump_set_acc(ProcessContext* cxt);
void pump_set_subic_reg(ProcessContext* cxt);
void pump_get_subic_reg(ProcessContext* cxt);
void pump_ping(ProcessContext* cxt);
void triple_warning_light_ctl(ProcessContext* cxt);
void pressure_sensor_bus_read_data(ProcessContext* cxt);
void pressure_sensor_bus_set_report_period_ms(ProcessContext* cxt);
};
} // namespace iflytop

4
usrc/protocol_processer_impl/public_cmd_processer.cpp

@ -49,7 +49,7 @@ void PublicCmdProcesser::read_sysinfo(ProcessContext* cxt) {
}
void PublicCmdProcesser::read_taskinfo(ProcessContext* cxt) {
static ask_taskinfo_t ack;
int32_t taskoff = GET_PARAM(cxt->packet->params, 0);
int32_t taskoff = GET_PARAM(0);
osThreadId taskId = SysMgr::ins()->osGetId(taskoff);
SysMgr::ins()->osTaskName(taskId, (char*)ack.taskName, sizeof(ack.taskName));
SysMgr::ins()->osTaskStackRemainingSize(taskId, &ack.stackRemindSize);
@ -61,7 +61,7 @@ void PublicCmdProcesser::read_taskinfo(ProcessContext* cxt) {
void PublicCmdProcesser::heart_ping(ProcessContext* cxt) {
static report_heatpacket_data_t heatpacket;
heatpacket.boardType = PublicBoard::ins()->getBoardTypeId();
heatpacket.heartIndex = GET_PARAM(cxt->packet->params, 0);
heatpacket.heartIndex = GET_PARAM(0);
heatpacket.flag = gBoardFlag;
zcanbus_send_report(kreport_heatpacket_pong, (uint8_t*)&heatpacket, sizeof(heatpacket), 30);
}

14
usrc/protocol_processer_mgr/i_protocol_processer.hpp

@ -5,10 +5,10 @@
#include "zsdk/zsdk.hpp"
#include "zstm32/zstm32.hpp"
//
#include "transmit_disfection_protocol/transmit_disfection_protocol.hpp"
#include "base/device_info.hpp"
#include "board/board.hpp"
#include "gflag/gflag.h"
#include "transmit_disfection_protocol/transmit_disfection_protocol.hpp"
#include "zsdk/zcanreceiver/zcanreceiver.hpp"
namespace iflytop {
@ -16,9 +16,15 @@ using namespace std;
using namespace zscanprotocol;
using namespace transmit_disfection_protocol;
#define REG_FN(fn) cmdprocesser.push_back(CmdProcesser(kfn_##fn, bind(&PublicCmdProcesser::fn, this, placeholders::_1)))
#define GET_PARAM(buff, off) ((((int32_t*)(buff))[off]))
#define PRAAM_LEN() ((len - sizeof(zcanbus_packet_t)) / 4)
#define REG_FN(fn) cmdprocesser.push_back(CmdProcesser(kfn_##fn, bind(&PublicCmdProcesser::fn, this, placeholders::_1)))
#define GET_PARAM(off) ((((int32_t*)(cxt->packet->params))[off]))
#define PRAAM_LEN() ((cxt->packetlen - sizeof(zcanbus_packet_t)) / 4)
#define CHECK_PARAM_LEN(_paramNum, expectNum) \
if (_paramNum != expectNum) { \
zcanbus_send_errorack(cxt->packet, kerr_invalid_param_num); \
return; \
}
/***********************************************************************************************************************
* ClassDeclear *

2
zsdk

@ -1 +1 @@
Subproject commit c7d515f2180f0ce961f7b61794544d8ea01ec586
Subproject commit c2a0f4d846f416a48f7cd6d4a22e2e7a8649ab40
Loading…
Cancel
Save