Transportador
A proposta deste artigo é a criação de um seletor de receitas que pode ser tomado como exemplo para diversas aplicações usando funções de Sistema do Step7. Iremos abordar o uso especifico em uma aplicação típica de um transportador de esteira onde as velocidades e parâmetros dos trechos podem ser modificados conforme um setup do equipamento.
Uma esteira trabalha a uma velocidade de 90m/s quando transportando garrafas de iorgut de 1500 ml, porém depois de um setup ela esta apta a rodar garrafas de 250 ml e o transportador deverá ter suas velocidades ajustadas para o novo formato desta vez mais veloz devido a maior velocidade de enchimento, visto que a vazão do enchedor não se altera. Nosso exemplo terá cinco trechos motorizados ajustados. A escolha do ajuste deverá ser realizada através de uma IHM Siemens, estando integrada ao projeto do CLP o qual pode ser baixado em nossa biblioteca.
Para controle de velocidade dos motores será utilizado o Inversor de freqüência Siemens MicroMaster420 em uma Process Field Bus (Profibus). Ajustes de velocidade desta rede deverão seguir o procedimento da descrição técnica que também pode ser baixado em nossa biblioteca.
O SFC 20 (Sytem Fuction) é conhecido como Move Block, ou seja, sua tarefa é transportar valores de um local para outro com a fonte de dados e o destino que podem ser definidos em sua interface. Sendo fácil para operar, porém por vez se deverá recorrer à ajuda de ponteiros que no Siemens são utilizados toda vez que não consigamos descrever um valor de uma área devido ao tamanho da estrutura para a qual estamos nos referindo em uma operação.
Aqui representado como é em linguagem SCL. Temos uma pequena lógica de acionamento que o antecede dizendo quando executar ou não a Função. De forma que a Memória M320.0 quando é igual a zero executa um salto não condicional (JNB) em direção ao rótulo M001. Desta fazendo cumprir o parâmetro de não execução de sistema NOP 0. O qual esvazia os acumuladores do processador liberando o para a próxima tarefa.
Caso o contrario, se M320.0 for igual a um, o comando de salto é ignorado e é executado o próximo comando que serve para abrir no registrador um bloco de dados (OPN). Note que a informação de qual DB será aberta por este comando estará armazenado na palavra de memória MW 312. Sendo assim, haverá mais uma instrução lógica apontando um valor para dentro desta memória. O que veremos mais adiante.
Após executada a abertura do DB tem a chamada de execução da Função de Sistema do SFC 20, conhecido como “BLKMOV”, que nos fornece uma interface parametrizável.
O parâmetro SRCBLK esta parametrizado com o ponteiro em P#DBX 0.0 BYTE 31, que significa que a fonte dos dados que será movida é o DBX, em outras palavras aquele que acabamos de abrir, e este será lido a partir do bit 0.0 uma largura de 31 BYTE.
O parâmetro RETVAL, retornará um valor quando este valor de leitura de SRCBLK ou DSTBLK não for encontrado ou for de tamanho incompatível. Isto pode acontecer quando a DB não existir no CLP ou tiver sido criado com um tamanho insuficiente para destino ou uma fonte muito grande de dados, que é o mesmo. O valor de RETVAL deve ser parametrizado com um WORD e aqui o foi com a MW 315.
O parâmetro DSTBLK esta parametrizado com o ponteiro em P#DB300.DBX0.0 BYTE 31, que significa que a função de sistema escreverá os dados lidos da fonte SRCBLK no bloco da DB300 que iremos chamar de Receita de trabalho e será descarregado nela a partir do bit 0.0 em 31 bytes de comprimento. Se ocorrer de encontrar algum problema de destino ou de largura de fonte de dados o parâmetro RETVAL retornará um código de erro que pode ser tratado como mostraremos mais adiante. De outra forma se tudo der certo será dado um comando NOP 0, finalizando a execução do SFC 20 nesta chamada.
//**************************************************************************************************************
NETWORK
TITLE = Transfer Program Select
A M 320.0;
JNB M001;
OPN DB [MW 312];
CALL "BLKMOV" (
SRCBLK := P#DBX 0.0 BYTE 31,
RET_VAL := MW 315,
DSTBLK := P#DB300.DBX0.0 BYTE 31);
NOP 0;
M001: NOP 0;
END_FUNCTION
//**************************************************************************************************************
//**************************************************************************************************************
TITLE =Pulso incrementa
A M 305.1;
FP M 305.3;
= M 305.5;
TITLE =Pulso decrementa
A M 305.0;
FP M 305.2;
= M 305.4;
TITLE =Incrementa programa selecionado
A M 305.5;
JNB _001;
L MW 310;
L 1;
+I ;
T MW 310;
_001: NOP 0;
TITLE =Decrementa programa selecionado
A M 305.4;
JNB _002;
L MW 310;
L 1;
-I ;
T MW 310;
_002: NOP 0;
TITLE =Limita programa selecionado não mais que dez
A( ;
L MW 310;
L 11;
>=I ;
) ;
JNB _003;
L 1;
T MW 310;
_003: NOP 0;
TITLE =Limites programa selecionado não menor que zero
A( ;
L MW 310;
L 1;
<I ;
) ;
JNB _004;
L 10;
T MW 310;
_004: NOP 0;
NETWORK
TITLE =Calcula numero da DB a abrir
L MW 310;
L 300;
+I ;
T MW 312;
NOP 0;
//**************************************************************************************************************
Como vimos até aqui, o SFC 20 faz com que os valores escolhidos entrem na DB 300 (Trabalho) que é o bloco de dados em uso, em outras palavras, é onde o clp consulta os parâmetros a serem utilizados a cada scan. A DBX é a receita escolhida e ela possui a mesma estrutura para permitir a entrada de dados sem erros no DB de trabalho. Deixaremos aqui o exemplo com 5 variantes de receitas que poderá ser escolhida. Com tudo a maneiras de se criar uma DB com funções de sistemas que não comentarei agora.
Em nossa estrutura temos a DB 300 (trabalho), DB301 (receita_1), DB302 (receita_2), DB303 (receita_3), DB304 (receita_4), DB305 (receita_5). Por conveniência sugerimos que não se utilize os blocos de dados desta centena para outras funções já que podem vir a ser necessários para produzirem outras variantes de receitas.
Antes de explicar como criar os blocos de dados deveremos saber como selecioná-los. Visto que depois de termos criado um DB os outros serão criados com Ctrl+C e Ctrl+V.
Temos abaixo o trecho do código que aponta para o valor que será escrito dentro da memória MW312.
Em nossa tela do seletor na IHM existe dois botões de pulso um com a descrição Próximo que se trata da memória M305.1 que é convenientemente posta em linha com um detector de Flanco de Positivo que tem como recipiente a memória M305.3 e o resultado da operação será igual a M305.5. E outro escrito Anterior que se trata da memória M 305.0, que também esta justa posto em linha lógica com um detector de flanco positivo com recipiente na memória M305.2, e o seu resultado modifica a memória M305.4. Estes na IHM modificarão a descrição da receita a ser escolhida para ser posta em trabalho pelo botão Transferir que é a memória M 320.0, que já vimos anteriormente.
A próxima instrução auxilia o seletor no incremento do valor selecionado transferindo o resultado de uma adição a cada pulso do botão Próximo e outra decrementando o valor a ser transferido para a memória MW310 a cada pulso do botão Anterior.
Um problema que deve ser cuidado é que não devemos incrementar ou decrementar a memória além do número de receitas disponíveis. Então temos uma instrução que delimita o valor da MW 310 ao número de programas disponíveis que podem ser selecionados.
Na ultima instrução especificamos o número dos blocos de dados a partir do qual teremos as receitas.
Até aqui descrevemos como funciona o seletor de receitas em sua parte mais especifica, como identificar a receita e descarregar no bloco de trabalho. Em nosso próximo artigo descreveremos como proceder para criação dos blocos de dados estruturados com uma UDT e organizar as informações de forma indexada para organizá-los em um IHM.
Você também pode baixar o projeto Step7-300 aqui
você pode baixar o pdf deste artigo aqui