API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 20th, 2015
218
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.61 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Modbus serial - RTU Slave Arduino Sketch
  3.  
  4. Marcos Daniel Wiechert wiechertdaniel@yahoo.com.br
  5.  
  6. Baseado na biblioteca de Juan Pablo Zometa : jpmzometa@gmail.com
  7. http://sites.google.com/site/jpmzometa/
  8. and Samuel Marco: sammarcoarmengol@gmail.com
  9. and Andras Tucsni.
  10.  
  11. As funções do protocolo MODBUS implementadas neste código:
  12. 3 - Read holding registers;
  13. 6 - Preset single register;
  14. 16 - Preset multiple registers.
  15.  
  16. This program is free software; you can redistribute it and/or modify
  17. it under the terms of the GNU General Public License as published by
  18. the Free Software Foundation; either version 2 of the License, or
  19. (at your option) any later version.
  20.  
  21. This program is distributed in the hope that it will be useful,
  22. but WITHOUT ANY WARRANTY; without even the implied warranty of
  23. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  24. GNU General Public License for more details.
  25.  
  26. You should have received a copy of the GNU General Public License
  27. along with this program; if not, write to the Free Software
  28. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29.  
  30. The functions included here have been derived from the
  31. Modicon Modbus Protocol Reference Guide
  32. which can be obtained from Schneider at www.schneiderautomation.com.
  33.  
  34. This code has its origins with
  35. paul@pmcrae.freeserve.co.uk (http://www.pmcrae.freeserve.co.uk)
  36. who wrote a small program to read 100 registers from a modbus slave.
  37.  
  38. */
  39.  
  40.  
  41. /*
  42. * configure_mb_slave(baud, parity, tx_en_pin)
  43. *
  44. * configuração dos parametros da porta serial.
  45. *
  46. * baud: taxa de transmissão em bps (valores típicos entre 9600, 19200... 115200)
  47. * parity: seta o modo de paridade:
  48. * 'n' sem paridade (8N1); 'e' paridede impar (8E1), 'o' paridade par (8O1).
  49. * tx_en_pin: pino do arduino que controla a transmissão/recepção em uma linha RS485.
  50. * 0 or 1 desliga esta função (para rede RS232)
  51. * >2 para uma rede multiponto.
  52. */
  53. void configure_mb_slave(long baud, char parity, char txenpin);
  54.  
  55. /*
  56. * update_mb_slave(slave_id, holding_regs_array, number_of_regs)
  57. *
  58. * verifica se há qualquer pedido válido do mestre modbus. Se houver,
  59. * executa a ação solicitada
  60. *
  61. * slave: endereço do escravo (arduino) (1 to 127)
  62. * regs: uma matriz com os holding registers. Eles começam no endereço 1 (mestre ponto de vista)
  63. * Regs_size: número total de holding registers.
  64. * Retorna: 0 se não houver pedido do mestre,
  65. * NO_REPLY (-1) se nenhuma resposta é enviada para o mestre
  66. * Caso um código de exceção (1 a 4) em algumas exceções de modbus
  67. * O número de bytes enviados como resposta (> 4) se OK.
  68. */
  69.  
  70. int update_mb_slave(unsigned char slave, int *regs,
  71. unsigned int regs_size);
  72.  
  73. /* Aqui começa o código do exemplo */
  74.  
  75. /* Parâmetros Modbus RTU de comunicação, o Mestre e os escravos devem usar os mesmos parâmetros */
  76. enum {
  77. COMM_BPS = 9600, /* baud rate */
  78. MB_SLAVE = 1, /* endereço do escravo modbus */
  79. /* cada escravo modbus deve ter um */
  80. /* endereço único na rede modbus */
  81. PARITY = 'n' /* paridade */
  82.  
  83. };
  84.  
  85. /* registros do escravo (holding registers)
  86. *
  87. * Aqui ficam ordenados todos os registros de leitura e escrita
  88. * da comunicação entre o mestre e o escravo (SCADA e arduino)
  89. *
  90. */
  91.  
  92. enum {
  93.  
  94. MB_REG0, /* Leitura da entrada analógica 0 (0 a 1023) */
  95. MB_REGS /* número total de registros do escravo */
  96. };
  97.  
  98. // Pino onde o Termistor esta conectado
  99. #define PINOTERMISTOR A0
  100. // Valor do termistor na temperatura nominal
  101. #define TERMISTORNOMINAL 10000
  102. // Temp. nominal descrita no Manual
  103. #define TEMPERATURENOMINAL 25
  104. // Número de amostragens para
  105. #define NUMAMOSTRAS 5
  106. // Beta do nosso Termistor
  107. #define BCOEFFICIENT 3950
  108. // valor do resistor em série
  109. #define SERIESRESISTOR 10000
  110. int amostra[NUMAMOSTRAS];
  111. int i;
  112. int valor;
  113. int regs[MB_REGS];
  114.  
  115.  
  116.  
  117. unsigned long wdog = 0; /* watchdog */
  118. unsigned long tprev = 0; /* tempo anterior do último comando*/
  119. unsigned long tanalogprev = 0; /* tempo anterior da leitura dos pinos analogicos*/
  120.  
  121. void setup()
  122. {
  123. /* configura cominicação modbus
  124. * 9600 bps, 8N1, RS485 network */
  125. configure_mb_slave(COMM_BPS, PARITY, 2);
  126. analogReference(EXTERNAL);
  127.  
  128. }
  129.  
  130. void loop()
  131. {
  132. /* verifica se há solicitações do mestre */
  133. if(update_mb_slave(MB_SLAVE, regs, MB_REGS))
  134.  
  135. regs[0] = valor;
  136. float temperatura;
  137. float media;
  138.  
  139. for (i=0; i< NUMAMOSTRAS; i++) {
  140. amostra[i] = analogRead(PINOTERMISTOR);
  141. //delay(10);
  142. }
  143.  
  144. media = 0;
  145. for (i=0; i< NUMAMOSTRAS; i++) {
  146. media += amostra[i];
  147. }
  148. media /= NUMAMOSTRAS;
  149.  
  150. // Converte o valor da tensão em resistência
  151. media = 1023 / media - 1;
  152. media = SERIESRESISTOR / media;
  153.  
  154. //Faz o cálculo pela fórmula do Fator Beta
  155.  
  156. temperatura = media / TERMISTORNOMINAL; // (R/Ro)
  157. temperatura = log(temperatura); // ln(R/Ro)
  158. temperatura /= BCOEFFICIENT; // 1/B * ln(R/Ro)
  159. temperatura += 1.0 / (TEMPERATURENOMINAL + 273.15); // + (1/To)
  160. temperatura = 1.0 / temperatura; // Inverte o valor
  161. temperatura -= 273.15;
  162. valor = temperatura;
  163. // Converte para Celsius
  164.  
  165. /*Serial.print("Temperatura no Sensor eh: ");
  166. Serial.print(temperatura);
  167. Serial.println(" *C");
  168.  
  169. delay(1000);*/
  170. }
  171.  
  172. /****************************************************************************
  173. * INICIO DAS FUNÇÕES ESCRAVO Modbus RTU
  174. ****************************************************************************/
  175.  
  176. /* variaveis globais */
  177. unsigned int Txenpin = 2; /*Definir o pino usado para colocar o driver
  178. RS485 em modo de transmissão, utilizado
  179. somente em redes RS485 quando colocar em 0
  180. ou 1 para redes RS232 */
  181.  
  182.  
  183. /* Lista de códigos de função modbus suportados. Se você implementar um novo, colocar o seu código de função aqui! */
  184. enum {
  185. FC_READ_REGS = 0x03, //Read contiguous block of holding register (Ler um bloco contíguo de registos)
  186. FC_WRITE_REG = 0x06, //Write single holding register (Escrever em um único registro)
  187. FC_WRITE_REGS = 0x10 //Write block of contiguous registers (Escrever em um bloco contíguo de registos)
  188. };
  189.  
  190. /* Funções suportadas. Se você implementar um novo, colocar seu código em função nessa matriz! */
  191. const unsigned char fsupported[] = { FC_READ_REGS, FC_WRITE_REG, FC_WRITE_REGS };
  192.  
  193. /* constantes */
  194. enum {
  195. MAX_READ_REGS = 0x7D,
  196. MAX_WRITE_REGS = 0x7B,
  197. MAX_MESSAGE_LENGTH = 256
  198. };
  199.  
  200.  
  201. enum {
  202. RESPONSE_SIZE = 6,
  203. EXCEPTION_SIZE = 3,
  204. CHECKSUM_SIZE = 2
  205. };
  206.  
  207. /* código de exceções */
  208. enum {
  209. NO_REPLY = -1,
  210. EXC_FUNC_CODE = 1,
  211. EXC_ADDR_RANGE = 2,
  212. EXC_REGS_QUANT = 3,
  213. EXC_EXECUTE = 4
  214. };
  215.  
  216. /* posições dentro da matriz de consulta / resposta */
  217. enum {
  218. SLAVE = 0,
  219. FUNC,
  220. START_H,
  221. START_L,
  222. REGS_H,
  223. REGS_L,
  224. BYTE_CNT
  225. };
  226.  
  227.  
  228. /*
  229. CRC
  230.  
  231. INPUTS:
  232. buf -> Matriz contendo a mensagem a ser enviada para o controlador mestre.
  233. start -> Início do loop no crc do contador, normalmente 0.
  234. cnt -> Quantidade de bytes na mensagem a ser enviada para o controlador mestre
  235. OUTPUTS:
  236. temp -> Retorna byte crc para a mensagem.
  237. COMMENTÁRIOS:
  238. Esta rotina calcula o byte crc alto e baixo de uma mensagem.
  239. Note que este CRC é usado somente para Modbus, não em Modbus PLUS ou TCP.
  240. ****************************************************************************/
  241.  
  242. unsigned int crc(unsigned char *buf, unsigned char start,
  243. unsigned char cnt)
  244. {
  245. unsigned char i, j;
  246. unsigned temp, temp2, flag;
  247.  
  248. temp = 0xFFFF;
  249.  
  250. for (i = start; i < cnt; i++) {
  251. temp = temp ^ buf[i];
  252.  
  253. for (j = 1; j <= 8; j++) {
  254. flag = temp & 0x0001;
  255. temp = temp >> 1;
  256. if (flag)
  257. temp = temp ^ 0xA001;
  258. }
  259. }
  260.  
  261. /* Inverter a ordem dos bytes. */
  262. temp2 = temp >> 8;
  263. temp = (temp << 8) | temp2;
  264. temp &= 0xFFFF;
  265.  
  266. return (temp);
  267. }
  268.  
  269.  
  270.  
  271.  
  272. /***********************************************************************
  273. *
  274. * As seguintes funções constroem o frame de
  275. * um pacote de consulta modbus.
  276. *
  277. ***********************************************************************/
  278.  
  279. /*
  280. * Início do pacote de uma resposta read_holding_register
  281. */
  282. void build_read_packet(unsigned char slave, unsigned char function,
  283. unsigned char count, unsigned char *packet)
  284. {
  285. packet[SLAVE] = slave;
  286. packet[FUNC] = function;
  287. packet[2] = count * 2;
  288. }
  289.  
  290. /*
  291. * Início do pacote de uma resposta preset_multiple_register
  292. */
  293. void build_write_packet(unsigned char slave, unsigned char function,
  294. unsigned int start_addr,
  295. unsigned char count,
  296. unsigned char *packet)
  297. {
  298. packet[SLAVE] = slave;
  299. packet[FUNC] = function;
  300. packet[START_H] = start_addr >> 8;
  301. packet[START_L] = start_addr & 0x00ff;
  302. packet[REGS_H] = 0x00;
  303. packet[REGS_L] = count;
  304. }
  305.  
  306. /*
  307. * Início do pacote de uma resposta write_single_register
  308. */
  309. void build_write_single_packet(unsigned char slave, unsigned char function,
  310. unsigned int write_addr, unsigned int reg_val, unsigned char* packet)
  311. {
  312. packet[SLAVE] = slave;
  313. packet[FUNC] = function;
  314. packet[START_H] = write_addr >> 8;
  315. packet[START_L] = write_addr & 0x00ff;
  316. packet[REGS_H] = reg_val >> 8;
  317. packet[REGS_L] = reg_val & 0x00ff;
  318. }
  319.  
  320.  
  321. /*
  322. * Início do pacote de uma resposta excepção
  323. */
  324. void build_error_packet(unsigned char slave, unsigned char function,
  325. unsigned char exception, unsigned char *packet)
  326. {
  327. packet[SLAVE] = slave;
  328. packet[FUNC] = function + 0x80;
  329. packet[2] = exception;
  330. }
  331.  
  332.  
  333. /*************************************************************************
  334. *
  335. * modbus_query( packet, length)
  336. *
  337. * Função para adicionar uma soma de verificação para o fim de um pacote.
  338. * Por favor, note que a matriz pacote deve ser de pelo menos 2 campos mais do que
  339. * String_length.
  340. **************************************************************************/
  341.  
  342. void modbus_reply(unsigned char *packet, unsigned char string_length)
  343. {
  344. int temp_crc;
  345.  
  346. temp_crc = crc(packet, 0, string_length);
  347. packet[string_length] = temp_crc >> 8;
  348. string_length++;
  349. packet[string_length] = temp_crc & 0x00FF;
  350. }
  351.  
  352.  
  353.  
  354. /***********************************************************************
  355. *
  356. * send_reply( query_string, query_length )
  357. *
  358. * Função para enviar uma resposta a um mestre Modbus.
  359. * Retorna: o número total de caracteres enviados
  360. ************************************************************************/
  361.  
  362. int send_reply(unsigned char *query, unsigned char string_length)
  363. {
  364. unsigned char i;
  365.  
  366. if (Txenpin > 1) { // coloca o MAX485 no modo de transmissão
  367. UCSR0A=UCSR0A |(1 << TXC0);
  368. digitalWrite( Txenpin, HIGH);
  369. delayMicroseconds(3640); // aguarda silencio de 3.5 caracteres em 9600bps
  370. }
  371.  
  372. modbus_reply(query, string_length);
  373. string_length += 2;
  374.  
  375. for (i = 0; i < string_length; i++) {
  376. Serial.print(query[i], BYTE);
  377. }
  378.  
  379. if (Txenpin > 1) {// coloca o MAX485 no modo de recepção
  380. while (!(UCSR0A & (1 << TXC0)));
  381. digitalWrite( Txenpin, LOW);
  382. }
  383.  
  384. return i; /* isso não significa que a gravação foi bem sucedida */
  385. }
  386.  
  387. /***********************************************************************
  388. *
  389. * receive_request( array_for_data )
  390. *
  391. * Função para monitorar um pedido do mestre modbus.
  392. *
  393. * Retorna: Número total de caracteres recebidos se OK
  394. * 0 se não houver nenhum pedido
  395. * Um código de erro negativo em caso de falha
  396. ***********************************************************************/
  397.  
  398. int receive_request(unsigned char *received_string)
  399. {
  400. int bytes_received = 0;
  401.  
  402. /* FIXME: não Serial.available esperar 1.5T ou 3.5T antes de sair do loop? */
  403. while (Serial.available()) {
  404. received_string[bytes_received] = Serial.read();
  405. bytes_received++;
  406. if (bytes_received >= MAX_MESSAGE_LENGTH)
  407. return NO_REPLY; /* erro de porta */
  408. }
  409.  
  410. return (bytes_received);
  411. }
  412.  
  413.  
  414. /*********************************************************************
  415. *
  416. * modbus_request(slave_id, request_data_array)
  417. *
  418. * Função que é retornada quando o pedido está correto
  419. * e a soma de verificação está correto.
  420. * Retorna: string_length se OK
  421. * 0 se não
  422. * Menos de 0 para erros de exceção
  423. *
  424. * Nota: Todas as funções usadas para enviar ou receber dados via
  425. * Modbus devolver esses valores de retorno.
  426. *
  427. **********************************************************************/
  428.  
  429. int modbus_request(unsigned char slave, unsigned char *data)
  430. {
  431. int response_length;
  432. unsigned int crc_calc = 0;
  433. unsigned int crc_received = 0;
  434. unsigned char recv_crc_hi;
  435. unsigned char recv_crc_lo;
  436.  
  437. response_length = receive_request(data);
  438.  
  439. if (response_length > 0) {
  440. crc_calc = crc(data, 0, response_length - 2);
  441. recv_crc_hi = (unsigned) data[response_length - 2];
  442. recv_crc_lo = (unsigned) data[response_length - 1];
  443. crc_received = data[response_length - 2];
  444. crc_received = (unsigned) crc_received << 8;
  445. crc_received =
  446. crc_received | (unsigned) data[response_length - 1];
  447.  
  448. /*********** verificar CRC da resposta ************/
  449. if (crc_calc != crc_received) {
  450. return NO_REPLY;
  451. }
  452.  
  453. /* verificar a ID do escravo */
  454. if (slave != data[SLAVE]) {
  455. return NO_REPLY;
  456. }
  457. }
  458. return (response_length);
  459. }
  460.  
  461. /*********************************************************************
  462. *
  463. * validate_request(request_data_array, request_length, available_regs)
  464. *
  465. * Função para verificar se o pedido pode ser processado pelo escravo.
  466. *
  467. * Retorna: 0 se OK
  468. * Um código de exceção negativa em caso de erro
  469. *
  470. **********************************************************************/
  471.  
  472. int validate_request(unsigned char *data, unsigned char length,
  473. unsigned int regs_size)
  474. {
  475. int i, fcnt = 0;
  476. unsigned int regs_num = 0;
  477. unsigned int start_addr = 0;
  478. unsigned char max_regs_num;
  479.  
  480. /* verificar o código de função */
  481. for (i = 0; i < sizeof(fsupported); i++) {
  482. if (fsupported[i] == data[FUNC]) {
  483. fcnt = 1;
  484. break;
  485. }
  486. }
  487. if (0 == fcnt)
  488. return EXC_FUNC_CODE;
  489.  
  490. if (FC_WRITE_REG == data[FUNC]) {
  491. /* Para a função de escrever um reg único, este é o registro alvo.*/
  492. regs_num = ((int) data[START_H] << 8) + (int) data[START_L];
  493. if (regs_num >= regs_size)
  494. return EXC_ADDR_RANGE;
  495. return 0;
  496. }
  497.  
  498. /* Para as funções de leitura / escrita de registros, este é o intervalo. */
  499. regs_num = ((int) data[REGS_H] << 8) + (int) data[REGS_L];
  500.  
  501. /* verifica a quantidade de registros */
  502. if (FC_READ_REGS == data[FUNC])
  503. max_regs_num = MAX_READ_REGS;
  504. else if (FC_WRITE_REGS == data[FUNC])
  505. max_regs_num = MAX_WRITE_REGS;
  506.  
  507. if ((regs_num < 1) || (regs_num > max_regs_num))
  508. return EXC_REGS_QUANT;
  509.  
  510. /* verificará a quantidade de registros, endereço inicial é 0 */
  511. start_addr = ((int) data[START_H] << 8) + (int) data[START_L];
  512. if ((start_addr + regs_num) > regs_size)
  513. return EXC_ADDR_RANGE;
  514.  
  515. return 0; /* OK, sem exceção */
  516. }
  517.  
  518.  
  519.  
  520. /************************************************************************
  521. *
  522. * write_regs(first_register, data_array, registers_array)
  523. *
  524. * escreve nos registradores do escravo os dados em consulta,
  525. * A partir de start_addr.
  526. *
  527. * Retorna: o número de registros escritos
  528. ************************************************************************/
  529.  
  530. int write_regs(unsigned int start_addr, unsigned char *query, int *regs)
  531. {
  532. int temp;
  533. unsigned int i;
  534.  
  535. for (i = 0; i < query[REGS_L]; i++) {
  536. /* mudar reg hi_byte para temp */
  537. temp = (int) query[(BYTE_CNT + 1) + i * 2] << 8;
  538. /* OR com lo_byte */
  539. temp = temp | (int) query[(BYTE_CNT + 2) + i * 2];
  540.  
  541. regs[start_addr + i] = temp;
  542. }
  543. return i;
  544. }
  545.  
  546. /************************************************************************
  547. *
  548. * preset_multiple_registers(slave_id, first_register, number_of_registers,
  549. * data_array, registers_array)
  550. *
  551. * Escreva os dados na matriz dos registos do escravo.
  552. *
  553. *************************************************************************/
  554.  
  555. int preset_multiple_registers(unsigned char slave,
  556. unsigned int start_addr,
  557. unsigned char count,
  558. unsigned char *query,
  559. int *regs)
  560. {
  561. unsigned char function = FC_WRITE_REGS; /* Escrever em múltiplos registros */
  562. int status = 0;
  563. unsigned char packet[RESPONSE_SIZE + CHECKSUM_SIZE];
  564.  
  565. build_write_packet(slave, function, start_addr, count, packet);
  566.  
  567. if (write_regs(start_addr, query, regs)) {
  568. status = send_reply(packet, RESPONSE_SIZE);
  569. }
  570.  
  571. return (status);
  572. }
  573.  
  574.  
  575. /************************************************************************
  576. *
  577. * write_single_register(slave_id, write_addr, data_array, registers_array)
  578. *
  579. * Escrever um único valor inteiro em um único registo do escravo.
  580. *
  581. *************************************************************************/
  582.  
  583. int write_single_register(unsigned char slave,
  584. unsigned int write_addr, unsigned char *query, int *regs)
  585. {
  586. unsigned char function = FC_WRITE_REG; /* Função: Write Single Register */
  587. int status = 0;
  588. unsigned int reg_val;
  589. unsigned char packet[RESPONSE_SIZE + CHECKSUM_SIZE];
  590.  
  591. reg_val = query[REGS_H] << 8 | query[REGS_L];
  592. build_write_single_packet(slave, function, write_addr, reg_val, packet);
  593. regs[write_addr] = (int) reg_val;
  594. /*
  595. written.start_addr=write_addr;
  596. written.num_regs=1;
  597. */
  598. status = send_reply(packet, RESPONSE_SIZE);
  599.  
  600. return (status);
  601. }
  602.  
  603.  
  604. /************************************************************************
  605. *
  606. * read_holding_registers(slave_id, first_register, number_of_registers,
  607. * registers_array)
  608. *
  609. * lê os registros do escravo e envia para o mestre Modbus
  610. *
  611. *************************************************************************/
  612.  
  613. int read_holding_registers(unsigned char slave, unsigned int start_addr,
  614.  
  615. unsigned char reg_count, int *regs)
  616. {
  617. unsigned char function = 0x03; /* Função 03: Read Holding Registers */
  618. int packet_size = 3;
  619. int status;
  620. unsigned int i;
  621. unsigned char packet[MAX_MESSAGE_LENGTH];
  622.  
  623. build_read_packet(slave, function, reg_count, packet);
  624.  
  625. for (i = start_addr; i < (start_addr + (unsigned int) reg_count);
  626. i++) {
  627. packet[packet_size] = regs[i] >> 8;
  628. packet_size++;
  629. packet[packet_size] = regs[i] & 0x00FF;
  630. packet_size++;
  631. }
  632.  
  633. status = send_reply(packet, packet_size);
  634.  
  635. return (status);
  636. }
  637.  
  638.  
  639. void configure_mb_slave(long baud, char parity, char txenpin)
  640. {
  641. Serial.begin(baud);
  642.  
  643. switch (parity) {
  644. case 'e': // 8E1
  645. UCSR0C |= ((1<<UPM01) | (1<<UCSZ01) | (1<<UCSZ00));
  646. // UCSR0C &= ~((1<<UPM00) | (1<<UCSZ02) | (1<<USBS0));
  647. break;
  648. case 'o': // 8O1
  649. UCSR0C |= ((1<<UPM01) | (1<<UPM00) | (1<<UCSZ01) | (1<<UCSZ00));
  650. // UCSR0C &= ~((1<<UCSZ02) | (1<<USBS0));
  651. break;
  652. case 'n': // 8N1
  653. UCSR0C |= ((1<<UCSZ01) | (1<<UCSZ00));
  654. // UCSR0C &= ~((1<<UPM01) | (1<<UPM00) | (1<<UCSZ02) | (1<<USBS0));
  655. break;
  656. default:
  657. break;
  658. }
  659.  
  660. if (txenpin > 1) { // pino 0 & pino 1 são reservados para RX/TX
  661. Txenpin = txenpin; /* definir variável global */
  662. pinMode(Txenpin, OUTPUT);
  663. digitalWrite(Txenpin, LOW);
  664. }
  665.  
  666. return;
  667. }
  668.  
  669. /*
  670. * update_mb_slave(slave_id, holding_regs_array, number_of_regs)
  671. *
  672. * verifica se há qualquer pedido válido do mestre modbus. Se houver,
  673. * executa a ação solicitada
  674. */
  675.  
  676. unsigned long Nowdt = 0;
  677. unsigned int lastBytesReceived;
  678. const unsigned long T35 = 5;
  679.  
  680. int update_mb_slave(unsigned char slave, int *regs,
  681. unsigned int regs_size)
  682. {
  683. unsigned char query[MAX_MESSAGE_LENGTH];
  684. unsigned char errpacket[EXCEPTION_SIZE + CHECKSUM_SIZE];
  685. unsigned int start_addr;
  686. int exception;
  687. int length = Serial.available();
  688. unsigned long now = millis();
  689.  
  690. if (length == 0) {
  691. lastBytesReceived = 0;
  692. return 0;
  693. }
  694.  
  695. if (lastBytesReceived != length) {
  696. lastBytesReceived = length;
  697. Nowdt = now + T35;
  698. return 0;
  699. }
  700. if (now < Nowdt)
  701. return 0;
  702.  
  703. lastBytesReceived = 0;
  704.  
  705. length = modbus_request(slave, query);
  706. if (length < 1)
  707. return length;
  708.  
  709.  
  710. exception = validate_request(query, length, regs_size);
  711. if (exception) {
  712. build_error_packet(slave, query[FUNC], exception,
  713. errpacket);
  714. send_reply(errpacket, EXCEPTION_SIZE);
  715. return (exception);
  716. }
  717.  
  718.  
  719. start_addr = ((int) query[START_H] << 8) +
  720. (int) query[START_L];
  721. switch (query[FUNC]) {
  722. case FC_READ_REGS:
  723. return read_holding_registers(slave,
  724. start_addr,
  725. query[REGS_L],
  726. regs);
  727. break;
  728. case FC_WRITE_REGS:
  729. return preset_multiple_registers(slave,
  730. start_addr,
  731. query[REGS_L],
  732. query,
  733. regs);
  734. break;
  735. case FC_WRITE_REG:
  736. write_single_register(slave,
  737. start_addr,
  738. query,
  739. regs);
  740. break;
  741. }
  742. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!