晾晒谷物收获机自动化代码开源留存（3）

最新推荐文章于 2024-09-14 22:09:32 发布

别和李俊儒抢辣条

最新推荐文章于 2024-09-14 22:09:32 发布

阅读量138

点赞数

文章标签：自动化

本文链接：https://blog.csdn.net/qq_35339319/article/details/126626025

版权

晾晒谷物收获机自动化代码开源留存（3）

该部分属于自建库代码

“HX711.cpp”

#include "hx711.h"

 long HX711_Buffer = 0;
 int Weight_chushi = 0,Weight_Shiwu = 0;

void Init_Hx711()
{
  pinMode(HX711_SCK, OUTPUT); 
  pinMode(HX711_DT, INPUT);
}

void Get_chushi()
{
  HX711_Buffer = HX711_Read();
  Weight_chushi = HX711_Buffer/100;    
} 

unsigned int Get_Weight()
{
  HX711_Buffer = HX711_Read();
  HX711_Buffer = HX711_Buffer/100;
//  Serial.print(HX711_Buffer);
//  Serial.print("\n");
  if(HX711_Buffer > Weight_chushi)     
  {
    Weight_Shiwu = HX711_Buffer;
    Weight_Shiwu = Weight_Shiwu - Weight_chushi;     
  
    Weight_Shiwu = (unsigned int)((float)Weight_Shiwu/4.05+0.05); 
  }

  if(Weight_Shiwu > 5000  || HX711_Buffer < Weight_chushi - 30)
  {
    //鍙嶄簡銆?
  } 
  Weight_Shiwu = Weight_Shiwu + 2;
  return Weight_Shiwu;
}
                                                                                 

unsigned long HX711_Read(void)  //澧炵泭128
{
  unsigned long count; 
  unsigned char i;
  bool Flag = 0;

  digitalWrite(HX711_DT, HIGH);
  delayMicroseconds(1);

  digitalWrite(HX711_SCK, LOW);
  delayMicroseconds(1);

    count=0; 
    while(digitalRead(HX711_DT)); 
    for(i=0;i<24;i++)
  { 
      digitalWrite(HX711_SCK, HIGH); 
    delayMicroseconds(1);
      count=count<<1; 
    digitalWrite(HX711_SCK, LOW); 
    delayMicroseconds(1);
      if(digitalRead(HX711_DT))
      count++; 
  } 
  digitalWrite(HX711_SCK, HIGH); 
  delayMicroseconds(1);
  digitalWrite(HX711_SCK, LOW); 
  delayMicroseconds(1);
  //count ^= 0x800000;
  return(count);
}

“HX711.h”

#ifndef __HX711__H__
#define __HX711__H__

#include <Arduino.h>

#define HX711_SCK 6
#define HX711_DT 5

extern void Init_Hx711();
extern unsigned long HX711_Read(void);
extern unsigned int Get_Weight();
extern void Get_chushi();

#endif

“Modbus_TCP.cpp”

#include "Modbus_TCP.h"
  HardwareSerial* ModbusPort;
/*
  初始化函数
*/
 void Modbus_Tcp::modbusTcp_INI(HardwareSerial *SerialPort)
{
   ModbusPort = SerialPort;
  (*ModbusPort).begin(baudrate);
  (*ModbusPort).flush();  
}

//=====================================================================================
//  函数功能: 接收处理
//  返回值：  无                        
//=====================================================================================
void Modbus_Tcp:: modbusTcp_slave(short *frame)
{
  unsigned char address=0;
  unsigned int i;

  while((*ModbusPort).available() > 0)
  {   //如果缓冲区有数据
       if(address<bufferSize) //接收的数据量应小于一帧数据的最大字节数量
       {   
          pBuf[address]=(*ModbusPort).read();
          delay(4);
          address++;
          if(searchOneFrame(pBuf, address))
          {
                m_dwFrCount = pBuf[0]<< 8 | pBuf[1]; //处理通信状态
                if(pBuf[7] == 0x03) //功能码03
                {
                  //Serial.println("03 is OK!");
                 Rxd_Func03(pBuf+6, frame);
                }
                if(pBuf[7] == 0x05) //功能码05
                {
                  Rxd_Func05(pBuf+6);
                }
          } 
       }else{
        (*ModbusPort).flush();   //条件不满足时直接清空缓冲区
       }
  }
}
/*
*函数名称：boolean searchOneFrame(unsigned char pBuf,unsigned int fLength)
*返回值：无
*参数： pBuf,fLength
*功能描述：寻找一帧完整的modbus-tcp报文
*/
boolean Modbus_Tcp:: searchOneFrame(unsigned char *pBuf, unsigned char fLength)
{ 
    //Serial.println(pBuf[7]);
   unsigned char FrmLength = 12;

    if(fLength < FrmLength)
    {
      // (*ModbusPort).print("FM_Len_ERR");
      return false;
    }
   if(pBuf[6] != AddrID)
    {
       // (*ModbusPort).print("FM_Addr_ERR");
        return false;
      }

      switch(pBuf[7])
    {
    case 1:
    case 3:
    case 4:
    case 5:
    default:
      return true;
    }
      return true;
}


/*
*函数名称：void Rxd_Func03();
*返回值：无
*参数：无
*功能描述：当主机发来报文 判定为03功能码时，使用此函数来应答主机并返回相应的数据
*/
void Modbus_Tcp:: Rxd_Func03(byte *pBuf, short *frame)
{
  //Serial.println("Func03 is OK");
   Txd_ResFrame(ProcessFunc03(pBuf, frame));
}

// 遥控操作
void Modbus_Tcp:: Rxd_Func05(byte *pBuf)
{
  ProcessFunc05(pBuf);
}

/*
*函数名称：ProcessFunc03;
*返回值：无
*参数：无
*功能描述：发送应答帧
*/
int Modbus_Tcp:: ProcessFunc03(byte *pBuf, short *frame)
{
  unsigned int m_wDataLen = 0;
  int i;
  word  wAddr,wNum;    //起始地址
  byte  ErrCode;       //需要读取的寄存器个数
  
  wAddr = pBuf[2]<<8 | pBuf[3];   
  wNum =  pBuf[4]<<8 | pBuf[5];
  memset(m_TcpTxdBuf,0,wNum*2+6); //为m_TcpTxdBuf分配内存空间
  m_TcpTxdBuf[6] = pBuf[0];
  m_TcpTxdBuf[7] = pBuf[1];
  m_TcpTxdBuf[8] = wNum*2;
  
  for (i=0; i < wNum*2; i++)
  {
    m_TcpTxdBuf[i*2+9] = highByte(frame[i]);
    m_TcpTxdBuf[i*2+10] = lowByte(frame[i]);
    }
    m_wDataLen = wNum*2+3;
    return m_wDataLen;
}

/*
*函数名称：ProcessFunc05;
*返回值：Addr
*参数：pBuf
*功能描述：遥控命令执行
*/
void Modbus_Tcp:: ProcessFunc05(byte *pBuf)
{
  word  Addr,Cmd;    //起始地址
  
  Addr = pBuf[2]<<8 | pBuf[3];
  Cmd = pBuf[4]<<8 | pBuf[5];
  //(*ModbusPort).write(Addr);
  //(*ModbusPort).write(Cmd);   
  switch(Addr)
    {
          case 0x08:
          {
            //(*ModbusPort).write(Addr);
            //(*ModbusPort).write(Cmd);
            if(!Cmd)         //Cmd写0关，写1开
            {digitalWrite(LIGHT, LOW);}
            break;
            }
          case 0x09:
          {
            if(Cmd)
            {digitalWrite(LIGHT, HIGH);}
            break;
            }
            case 0x0A:
          {
            //(*ModbusPort).write(Addr);
            //(*ModbusPort).write(Cmd);
            if(!Cmd)         //Cmd写0关，写1开
            {digitalWrite(WATER, LOW);}
            break;
            }
          case 0x0B:
          {
            if(Cmd)
            {digitalWrite(WATER, HIGH);}
            break;
            }
          /*case 0x0C:
          {
            //(*ModbusPort).write(Addr);
            //(*ModbusPort).write(Cmd);
            if(!Cmd)         //Cmd写0关
            {digitalWrite(WATER, LOW);}
            break;
            }
          case 0x0D:
          {
            if(Cmd)
            {digitalWrite(LIGHT, HIGH);}
            break;
            }
            case 0x0E:
          {
            //(*ModbusPort).write(Addr);
            //(*ModbusPort).write(Cmd);
            if(!Cmd)         //Cmd写0关，写1开
           // {digitalWrite(LIGHT, LOW);}
            break;
            }
          case 0x0F:
          {
            if(Cmd)
           // {digitalWrite(LIGHT, HIGH);}
            break;
          }*/
          default: break;   
      }
       (*ModbusPort).flush();
}
/*
*函数名称：Txd_ResFrame();
*返回值：无
*参数：无
*功能描述：发送应答帧
*/
void Modbus_Tcp:: Txd_ResFrame(int m_wDataLen)
{
  m_TcpTxdBuf[0] = highByte(m_dwFrCount); //事务处理标示符Hi
  m_TcpTxdBuf[1] = lowByte(m_dwFrCount); //事务处理标示符Lo
  m_TcpTxdBuf[2] = 0; //协议标示符
  m_TcpTxdBuf[3] = 0; //协议标示符
  m_TcpTxdBuf[4] = highByte(m_wDataLen); //长度
  m_TcpTxdBuf[5] = lowByte(m_wDataLen); //长度

  (*ModbusPort).write(m_TcpTxdBuf,m_wDataLen+6);
  (*ModbusPort).flush();
}

“Modbus_TCP.h”

#include "Arduino.h"

#include <SPI.h>
#include <Ethernet.h>

#ifndef Modbus_TCP_h
#define Modbus_TCP_h

#define baudrate 9600  //定义通讯波特率
#define AddrID 0x21  //定义modbus Tcp从站站号
#define modbusDataSize 100  //定义modbus数据库空间大小,可根据实际情况自行修改大小


class Modbus_Tcp
{
  public: 
    HardwareSerial* ModbusPort;
    //系统参数
    #define bufferSize 255 
    short frame[bufferSize];  //用于保存接收或发送的数据
    unsigned char pBuf[bufferSize];
    
    byte*  m_TxdBuf;
    void modbusTcp_slave(short *frame);  //声明modbus Tcp从站函数
    void modbusTcp_INI(HardwareSerial *SerialPort);  //声明modbus Tcp端口初始化函数
    boolean searchOneFrame(unsigned char *pBuf, unsigned char fLength); //寻找一帧完整的modbus-tcp报文
    
  private:
    
     void Txd_ResFrame(int); //发送返回帧
     void Rxd_Func03(byte *pBuf, short *frame); //遥测、定值、事件个数
     void Rxd_Func05(byte *pBuf); //遥控
    
   //收发处理
    int  ProcessFunc03(byte *pBuf, short *frame);  //遥测、定值、事件个数
    void  ProcessFunc05(byte *pBuf);  //遥控

    int WIND  = 40;
    int WATER = 6;
    int LIGHT = 11;
    uint16_t       m_dwFrCount=0;
    byte  m_TcpTxdBuf[bufferSize];  //rtu是响应缓冲区,tcp是去除了保文头的响应缓冲区 2013.6.19syy注释

  
    uint8_t m_wDataLen; //m_wDataLen为从"模块地址"开始的响应报文长度 2013.6.19syy注释  
};
#endif