Pessoal tenho uma duvida.
Os pinos 0 e 1 do arduino Uno são para porta serial. Esta porta posso ligar direto um conversor RS232 - 485, ou um conversor USB serial RS232? Tem algum problema?
Eu li em alguns lugares que esta porta é TTL. Esta correto isso? Em caso afirmativo como eu pòsso entao usar a serial do Uno para ligar no pc, pois eu quero monitorar algumas coisas nele via Modbus.
Valeu a todos
O Uno tem um conversor usb/serial ligado as portas 0 e 1. Mas se quiser pode ligar os pinos direto na serial usando um conversor ttl como o MAX232 ou um usb/serial como ftdi.
defende:
(...)
Esta porta posso ligar direto um conversor RS232 - 485
(...)
Não os níeis desta porta sériesão TTL (entre 0 e 5V) e não RS232 (entre -12 e 12V), por isso não pode ligar esse conversor.
defende:
(...)
a um conversor USB serial RS232
(...)
Também não poque nesta porta nem há níveis RS232 nem USB.
Par a ligação por Modbus, pode começar por aqui:
http://playground.arduino.cc/Code/ModbusMaster
Valeu pela resposta de todos.
Com respeito ao protocolo Modbus eu entendo e sei como funciona, sem problema algum.
A minha duvida é com o hardware mesmo. Tenho um conversor que eu comprei que é USB - RS232 de 1 metro. Eu uso ele para conectar o notebook com alguns CLPS. Este não serve?
Tenho tambem um outro, o que eu mais uso, que é ligado direto na porta Express Card do Notebook (http://www.online-wholesale.net/img/p/m/rs232-serial-port-34mm-express-card-adapter-for-laptop-66465-1.jpg) sera que tambem não serve?
Agora voltando a falar para usar a RS485. Qual seria a melhor forma para fazer um PC se conectar com varios Arduinos Uno? Usar o MAX485 ou de que forma?
Vou explicar rapidamente o que eu quero fazer: tenho de montar varios monitoramentos de sensores digitais e analogicos dentro de uma empresa. Para isso vou usar os Arduinos e alguns acessorios. Ate ai tudo bem. A duvida é na parte do hardware para ligar tudo isso no PC que vai monitorar (Modbus Master).
Novamente valeu pela ajuda dos amigos.
Rodrigo
Rodrigo, os cabos não servem. Serviam se do lado do Arduino tivesse um conversor TTL-RS232. No caso nem é necessário porque tem um conversor TTL-USB. Sendo assim, para ligar um Arduino a um PC apenas é necessário um cabo USB: USB-B (para o lado do Arduino) -> USB-A (para o lado do PC).
Não conheço o software, mas se o que ele precisa é de uma porta série a ligação pode ser feita usando apenas um cabo USB e depois escolhendo a porta série correspondente.
A ligação entre os Arduinos (ligados através de RS-485, se percebi bem) pode ser feita utilizando um conversor TTL para RS-485.
Não disse explicitamente, por isso vou fazer a referência aqui. Os cabos não servem, porque o Arduino está melhor preparado que os PLC's. Os PLC's apenas permitiam a ligação através de porta série (protocolo RS-232) ao PC, no entanto, as placas do Arduino como são mais "modernas" que a maioria dos PLC's já estão preparadas para usarem o protocolo USB (que é o que equipa os PC's modernos) e não o antigo RS-232 que já não equipa nenhum PC actual. Portanto, tanto o seu cabo RS-232 como o conversor RS-232/PCMCIA, que mostra no link, são muito bons (e eu também tenho um) para ligar aos PLC's (ou a alguma placa microcontroladora mais antiga), mas já não são necessários para ligar ao Arduino.
Em relação à questão da ligação RS-485 ao PC, não consigo responder concretamente, porque nunca precisei de fazer uma ligação desse género. No entanto, pode usar um Arduino "Master" que está ligado à rede e comunica directamente com o PC, ou então usar um conversor RS-485 para USB e ligar a rede directamente ao PC (como lhe disse não sei se esta última opção é possível, por não ter conhecimentos suficientes sobre o protocolo RS-485).
Valeu pela resposta - esclareceu muito.
Eu tambem vi num site (http://www.andresarmento.com/2011/11/rede-de-automacao-rs-485modbus-com-arduino/) que ele usa um conversor USB - RS485 do lado do PC e dai um outro conversor para ligar no Arduino que faz o controle de fluxo (eu acho).
No meu caso vc acha que daria certo?
Tambem estou pensando em usar uma Ethernet no arduino para fazer a mesma comunicacao Modbus, porque realmente no meu caso os Arduinos vao ficar pelo menos uns 30 metros do PC e dai USB nao daria.
O meu problema realmente esta sendo na parte de comunicacao Arduino PC por causa da distancia.
Tens uma outra sugestao??
Valeu.
Se a comunicação é feita através de ethernet, não é necessário nada disto, penso eu. Este caso era para uma comunicação RS-485.
Eu penso que mesmo para essa distância, a comunicação pode ser feita através de RS-485, mas como lhe disse não tenho muita experiência nesse protocolo, portanto, não sou a melhor pessoa para o aconselhar.
No vídeo, do lado do PC, se não me engano, ele usa um conversor RS-485 para TTL e posteriormente um conversor TTL para USB. Se não percebi mal, ele usa este integrado para a conversão USB-TTL e posteriormente tem um transceiver de RS-485 (que ele não diz qual é).
É isso mesmo que ele faz.
Só não entendi do lado do pc como ele referencia a USB no Scada. Deve usar algum tipo de Virtual Com ou coisa assim.
Resumindo, para eu poder usar a serial do Arduino a entrada tem de ser TTL? Justamente por isso que ele usa dois conversores?
Estou pesquisando tambem para migrar tudo para Ethernet.
Valeu
defende:
(...)
Só não entendi do lado do pc como ele referencia a USB no Scada. Deve usar algum tipo de Virtual Com ou coisa assim.
(...)
Isso é feito pelo driver. O driver é que diz ao SO que aque dispositivo USB é uma porta série. A partir daí para o SO quando aquilo se liga ele trata-o como uma porta série (aliás é isto que é feito também pelo driver do seu cabo conversor de RS-232 para USB, e mesmo o chip que o seu cabo conversor tem no seu interior, é bastante semelhante ao que ele usa na plaquinho do vídeo)
defende:
(...)
Resumindo, para eu poder usar a serial do Arduino a entrada tem de ser TTL? Justamente por isso que ele usa dois conversores?
(...)
Sim, precisa sempre de dois conversores. Esses conversores vão transformar os sinais dos níveis do Arduino para os níveis RS-485 e é necessária essa conversão dos dois lados.
Para ethernet não é necessário nada disto. Apenas tem que ter dois Arduinos e dois shields ethernet. Depois pode liga-los um ao outro (penso que com cabos cruzados) ou então a um switch.
Muito obrigado a todos que me ajudaram aqui.
Valeu mesmo pelas info.
Vou continuar a fazer os testes inclusive com ethernet e vamos ver no que vai dar.
Valeu a todos.
Ola amigo.
Podes muito bem usar o RS485.Usares o ethernet pode te encarecer um pouco a solução.Quanto á distancia depende um pouco do baud-rate que utilizes no barramento RS485, mas no ultimo projecto onde o usei não tive problemas em cerca de 300 metros de cabo usando um baud-rate a 9600 bps.
Eu usei os MAX485 e so tive de desenvolver um simples protocolo de comunicação.O RS485 funciona na camada física do modelo OSI por isso so tens de garantir que trocas os bytes no bus comutando o max485 nos tempos certos enquanto os outros nós escutam.Basicamente tenho um nó master que interroga os slaves e eles quando detectam que a mensagem tem i ID que lhe pertence responde no bus.
Nas mensagens trocadas faço controlo de CRC para verificar a veracidade dos dados.
Pra te dar uma idea do que fiz ficam umas fotos das placas que fiz
A plaquinha tem muito bom aspecto. Eu também tinha a sensação que no caso do RS-485 também se conseguiam obter distâncias dessa ordem de grandeza, mas como nunca fiz nenhum projecto "a sério" usando esse protocolo, não tinha a certeza.
"+1 karma" para si HugoPT!
HugoPt muito boa essa placa, gostei mesmo. Parabens.
A proposito voce usou que protocolo no seu sistema?
Outra coisa, como vc comuta o Max485? Eu nunca usei um destes por isso eu estou perguntando.
Valeu
A proposito você usou que protocolo no seu sistema?
Concebi o meu proprio protocolo
Outra coisa, como vc comuta o Max485? Eu nunca usei um destes por isso eu estou perguntando.
O max485 tem 2 pinos (RE DE) que normalmente numa comunicação half-duplex os unes e os controlas com um pino no microcontrolador.Estes dois pinos basicamente server para colocar o max em escuta ou a enviar dados mediante o nivel logico.
Podes unir os dois pinos devido a um ter logica invertida(nota que ele tem o simbolo de negado).
Tal como te disse é importante acertar nos tempos e algo onde eu perdi algum tempo a depurar o meu código foi neste aspecto.
Em traços gerais sempre que queiras "ouvir" o barramento tens de ter pino que esta ligado aos (RE DE) em nível 0 e sempre que queiras enviar dados tens de o ter a nível 1.
Receber dados é relativamente simples, já o enviar tem um pormenor, é necessário assegurar que só voltas ao modo escuta quando efetivamente todos os bytes tiverem sido enviados, isto é, terem saído do serial buffer.
Em traços gerais usei isto assim:
txMode();
Serial.write(data,8);
while (! TXC0); //Aguarda até esvaziar o buffer TX
rxMode();
Muito grato mesmo pelas informações.
So mais uma ajuda. Como nao sou muito bom em C++ eu tenho o codigo abaixo que é de um protocolo Modbus.
#include <ModbusSlave.h>
/*
* ModBus Slave Library *Example*
* By André Sarmento Barbosa
* andre@infolink.com.br
* Check whole project at:
* http://www.diybrasil.com.br/projetos/rede-de-automaacaao-rs-485modbus-com-arduino
*
* History:
* I had modified original library Arduino Modbus Slave:
* http://sites.google.com/site/jpmzometa/arduino-mbrt/arduino-modbus-slave
* adding:
* - Function 0x01 - Read Coils
* - Function 0x02 - Read Input Status
* - Function 0x04 - Read Input Registers
* - Function 0x05 - Write Single Coil
* - New methods for setup arrays of holding registers, input registers, coils and discrete inputs.
* - Arduino 0.22 and 1.0 support
*
* I did this example to test the new library and show integration with ScadaBR software:
* http://www.sacadabr.com.br
*
*/
/* First step MBS: create an instance */
ModbusSlave mbs;
/* slave holding registers - int (read/write) */
enum {
MB_CTRL, /* Led control on, off or blink */
MB_TIME, /* blink time in milliseconds */
MB_CNT, /* count the number of blinks */
MB_REGS /* total number of holding registers on slave */
};
/* slave input registers - int (read only) */
enum {
MB_TEMP, /* Temperature sensor */
MB_INPUTREGS /* total number of input registers on slave */
};
/* slave coils - on/off (read/write) */
enum {
MB_FAN, /* Fan */
MB_LAMP, /* Lamp */
MB_COILS
};
/* slave inputs - on/off (read only) */
enum {
MB_DOOR, /* Reed-switch (door sensor) */
MB_INPUTS
};
int regs[MB_REGS];
int inputregs[MB_INPUTREGS];
bool coils[MB_COILS];
bool inputs[MB_INPUTS];
int doorPin = 11;
int fanPin = 12;
int ledPin = 13;
unsigned long wdog = 0; /* watchdog */
unsigned long tprev = 0; /* previous time*/
void setup()
{
/* the Modbus slave configuration parameters */
const unsigned char SLAVE = 10; /* slaveId */
const long BAUD = 115200; /* baud rate */
const char PARITY = 'n'; /* n=none; e=even; o=odd */
const char TXENPIN = 2; /* output driver enable pin */
/* Second step MBS: configure */
mbs.configure(SLAVE, BAUD, PARITY, TXENPIN);
mbs.setup_regs(regs, MB_REGS);
mbs.setup_coils(coils, MB_COILS);
mbs.setup_inputregs(inputregs, MB_INPUTREGS);
mbs.setup_inputs(inputs, MB_INPUTS);
pinMode(doorPin, INPUT);
digitalWrite(doorPin, HIGH);
pinMode(fanPin, OUTPUT);
pinMode(ledPin, OUTPUT);
}
void loop()
{
/* Third and las step MBS: update in loop*/
if(mbs.update())
wdog = millis();
if ((millis() - wdog) > 3000)
inputregs[MB_TEMP] = analogRead(A0); /* read input A0 */
/* the values in regs are set by the modbus master */
switch(regs[MB_CTRL]) {
case 0:
digitalWrite(ledPin, LOW);
break;
case 1:
digitalWrite(ledPin, HIGH);
break;
default: // blink
if (millis() - tprev > regs[MB_TIME]) {
if (LOW == digitalRead(ledPin)) {
digitalWrite(ledPin, HIGH);
regs[MB_CNT]++;
} else {
digitalWrite(ledPin, LOW);
}
tprev = millis();
}
}
//Fan (coils array)
if (coils[MB_FAN] == true) digitalWrite(fanPin, HIGH); else digitalWrite(fanPin, LOW);
//Door sensor (inputs array)
if (digitalRead(doorPin) == HIGH) inputs[MB_DOOR] = true; else inputs[MB_DOOR] = false;
}
Eu nao entendi muito bem a parte dos ENUM. Como eu determino qual o endereço na memoria do Arduino que eu vou usar para escrever, ler, bobinas, etc.
Nao entendi como ele faz isso. Poderiam me dar mais esta ajuda..
Valeu
Eu nao entendi muito bem a parte dos ENUM
Bom o ENUM é uma forma de teres conjuntos de valores como se fossem constantes da linguagem
Um caso disso é o #define, mas o ENUM permite enumerar de uma só vez mais "constantes"
enum {
MB_CTRL, /* Led control on, off or blink /
MB_TIME, / blink time in milliseconds /
MB_CNT, / count the number of blinks /
MB_REGS / total number of holding registers on slave */
};
Isto equivale a estares a definir MB_CTRL = 0 MB_TIME = 1 MB_CNT = 2 MB_REGS = 3
Nao entendo é porque é que o autor não deu nomes á enumeraçao ...
int regs[MB_REGS];
int inputregs[MB_INPUTREGS];
bool coils[MB_COILS];
bool inputs[MB_INPUTS];
Isto equivale a isto:
int regs[3];
int inputregs[1];
bool coils[2];
bool inputs[1];
Valeu mesmo.
Agora eu posso modificar o codigo pra ficar mais amigavel e mais flexivel para o que eu quero usar.
Valeu.