Nosso objetivo: Esta biblioteca foi projetada para ajudá-lo a construir seu próprio CLP (Controlador Lógico Programável). Ela visa criar um ecossistema de dispositivos programáveis com o Fulmatic SOFT , proporcionando o máximo controle sobre seu hardware . Você pode usar esta extensa biblioteca com qualquer chip e IDE de sua escolha. Você pode definir o diagrama de circuito e todas as outras especificações de hardware por conta própria.
Fulmatic SOFT: Adicione a biblioteca Fulmatic Core ao código do seu chip seguindo as instruções e você poderá programar seus sistemas embarcados com o Fulmatic SOFT usando a linguagem ladder ( IEC 61131-3 ). O Fulmatic SOFT oferece mais do que apenas um CLP, com todos os recursos dos CLPs modernos, além de comandos TCP, UDP, de movimento e de cartão SD. O Fulmatic SOFT fornece um amplo espaço de trabalho com 771 blocos (255 DB, 256 PB, 256 FB e 4 OB) e 16384 E/S.
Firmware gratuito para CLP: Você pode usar a biblioteca do CLP gratuitamente até 2048 bytes (1026 bytes usados pelo DB0). Se precisar de mais memória, você deve adquirir uma licença (10 USD) . Sem uma licença, o CLP funcionará por 60 minutos. Nosso modelo de licenciamento transparente não possui contratos nem processos complicados. Você precisa adicionar um chip TSHA204A-SSHDA ao seu circuito. Ao adquirir uma licença, você receberá uma chave. O aplicativo de licenciamento se conectará ao nosso servidor com essa chave e enviará o código da licença para o chip via porta serial ou Ethernet. Sua quantidade de licenças no servidor diminuirá simultaneamente.
Github: Você pode baixar nosso projeto de exemplo preparado com o VS Code para STM32F407VGTx do Github para testar a biblioteca PLC . https://github.com/FultekPLC/Plc-Firmware
Neste projeto, você encontrará o firmware completo do CLP, utilizando quase todos os recursos do chip, disponível como código aberto. Você pode modificar as especificações de hardware do chip com o software Cube MX e continuar trabalhando no mesmo projeto. Você também pode alterar as especificações de hardware e software com o VS Code. É possível adicionar funções personalizadas ao firmware do CLP e executá-las diretamente do código do CLP . Você pode usar qualquer marca e modelo de chip ARM, especificando o número e os tipos de E/S. Em resumo, você pode usar a biblioteca Fulmatic Core sem restrições, de acordo com os termos da licença.
Atualização de Firmware: Os clientes que utilizam seu produto podem realizar atualizações de firmware do CLP com o Fulmatic SOFT. O código de atualização de firmware do CLP é totalmente de código aberto, e você pode visualizar e modificar o código do bootloader no projeto de exemplo. Além do código que recomendamos, você pode escrever seu próprio código de bootloader.
Guia de código
Estamos trabalhando para tornar o projeto de exemplo de 256 KB fácil de usar. 256 KB de código para um chip é um projeto bastante grande. Entender, modificar e implementar um projeto desse tamanho não será fácil. Tentamos explicar as funções nesta página e no código. Também estamos trabalhando para explicá-las melhor. Tentaremos responder às suas perguntas o máximo possível na seção de discussões do nosso repositório no GitHub. Infelizmente, não oferecemos suporte gratuito para o Fulmatic Core. Você pode solicitar um orçamento para que cuidemos de todos os processos em seu nome, incluindo o projeto da placa de circuito impresso.
Você pode baixar o projeto de exemplo em nosso link do Github: https://github.com/FultekPLC/Plc-Firmware. No projeto de exemplo, você pode visualizar e modificar todos os recursos do CLP usando código aberto. Você pode remover funções desnecessárias e adicionar novas funções.
Você pode encontrar todas as informações sobre IDEs e ferramentas de compilação em nosso repositório do GitHub. Nesta página, explicaremos as funções usadas para a integração da biblioteca com o código do seu microcontrolador.
FulmaticConfig.h
As definições da versão do firmware e do tamanho da string são feitas neste arquivo.
FulmaticCore.h
Este arquivo contém os cabeçalhos das funções da biblioteca que você chamará a partir do seu código de microcontrolador. Você encontrará descrições de todas as funções neste arquivo. A biblioteca trabalha com diversas variáveis e strings. Você deve criar essas strings e variáveis no seu código de microcontrolador. A estrutura `variables_TypeDef` é usada para passar as variáveis que você cria para a biblioteca. Você não pode modificar essa estrutura.
FulmaticInit : Este comando precisa ser executado apenas uma vez, quando o chip é ligado pela primeira vez. O retorno de 1 indica que o chip de licença foi lido corretamente e está operando sob licença.
FulmaticExecute é uma função chamada dentro do arquivo main.c para executar o código ladder do CLP . Ela é chamada durante o bloco Startup (quando o CLP inicia), o bloco Main (a cada ciclo), o bloco Shutdown (quando o CLP para), quando ocorre uma interrupção de entrada digital dentro do arquivo Interput.c e quando ocorre uma interrupção baseada em tempo (Timer) dentro do arquivo Fulmatic.c.
Fulmatic.c
Todas as funções necessárias para a biblioteca ser usada em seu código estão reunidas no arquivo Fulmatic.c. Este arquivo se ramifica em outros arquivos. Agrupamos as funções em quatro categorias. As descrições das funções estão escritas no arquivo onde o corpo da função está localizado.
- Funções necessárias para o projeto de exemplo que não são utilizadas pela biblioteca.
- Funções utilizadas pela biblioteca que devem ser incluídas no seu código.
- Funções que a biblioteca utiliza para fins de licenciamento. Funções não necessárias para uso sem licença.
- As funções da biblioteca dependem dos comandos do CLP utilizados. Por exemplo, se operações como TCP, UDP, SPI, porta serial e cartão SD não forem utilizadas no seu CLP, a biblioteca funcionará sem essas funções.
_DefaultEprom: As configurações de hardware selecionáveis com o Fulmatic SOFT são armazenadas nos arrays de código PlcSetupEprom[STPMEMORYSIZE] e PlcEprom [PRGMEMORYSIZE]. A função _DefaultEprom neste arquivo contém as configurações padrão do CLP. Você pode personalizar a configuração até certo ponto usando esses arrays em seu código.
`_EachMilliSecond`: Esta função, que é executada a cada milissegundo, é executada a partir do arquivo principal e da biblioteca. No projeto de exemplo, os parâmetros são definidos usando `TIM7_IRQHandler` em `Interrupt.c`, e não executados diretamente. Além disso, o valor de `TIM7->ARR` é calibrado com o RTC. Examine a função `_RtcCalibration` em `Fulmatic.c`. Uma calibração incorreta fará com que todas as operações baseadas em tempo no CLP sejam executadas com pequenos erros.
_DelayUs: Pode ser necessário modificar o código para garantir que esteja configurado com precisão de acordo com a frequência do chip. Recomenda-se testá-lo e calibrá-lo por um período prolongado. Ele está calibrado para 168 MHz.
_SetOutputs: Normalmente, as entradas são lidas e as saídas são escritas dentro do arquivo main.c. No entanto, quando ocorrem interrupções de entrada digitais ou baseadas em tempo, o bloco de interrupção OB2 é acionado. Este bloco é então chamado dentro da biblioteca para configurar as saídas sem demora.
_GetMsTimerCount : Utilizado para medir a duração em diversas operações. Deve estar presente no seu código. Você precisa habilitar a leitura do valor do temporizador em milissegundos.
_CrcCalculate: Usado para calcular checksums usando hardware. Você deve garantir que ele funcione corretamente, dependendo do chip que estiver usando.
Comunicação.c
Este arquivo contém o código necessário para usar Ethernet, porta serial e SPI no CLP. Chamadas do Modbus e do Fulmatic SOFT são recebidas neste arquivo. A consistência dos dados é garantida iniciando a resposta com um atraso a partir do arquivo main.c. Além disso, o código para atualização de firmware e operação do cartão SD está explicitamente escrito neste arquivo. O Fulmatic SOFT realiza atualizações de firmware e operações com o cartão SD usando este código. Você pode modificar este código para realizar operações semelhantes com seu próprio software em vez do Fulmatic SOFT. Outras operações do Fulmatic SOFT e do Modbus são enviadas e respondidas pela biblioteca através deste código. Modificando o código, você também pode responder a chamadas do Modbus sem enviá-las para a biblioteca.
Flash.c
O código do CLP e as informações persistentes do temporizador/contador são salvos na memória flash quando o CLP é desligado. Quando o CLP é ligado novamente, o último código salvo é lido do arquivo flash.h. Lembre-se de configurar as informações do setor do chip que você está usando. Você pode usar o circuito a seguir para detectar quando o CLP foi desligado.
Este circuito definirá o pino de Detecção de Desligamento como baixo quando a tensão cair de 24 volts para aproximadamente 19 volts. O capacitor C1 permite que o chip continue operando por um curto período. Durante esse período prolongado, apagar e regravar a memória flash é arriscado. Portanto, as seguintes etapas devem ser seguidas.
- Quando o CLP é ligado pela primeira vez, copiamos o setor 10 para o setor 11. Se a energia for interrompida durante a inicialização, os dados intactos são armazenados no setor 11.
- Para salvar novos dados na memória Flash, primeiro é necessário apagá-los. Apagar leva muito mais tempo do que salvar. Portanto, apagamos o setor 10 na inicialização e aguardamos o desligamento.
- O circuito de detecção de desligamento nos dá um pouco mais de 1 segundo de tempo. Quando o desligamento é detectado, os dados são salvos no setor 10 em 100-200 ms. Como o bloco de desligamento OB 1 será executado antes do desligamento e pode haver um código ladder extenso no CLP, o capacitor C1 deve ter pelo menos 2200 µF. Um resistor limitador de corrente de 100 ohms é usado para evitar um choque no circuito devido à alta capacitância.
- Quando o CLP inicia, ele lê todos os dados do setor 10 e realiza uma verificação de checksum. Se houver uma interrupção de energia durante a inicialização do CLP, a verificação de checksum falhará. Não se preocupe, os dados confiáveis estão sempre disponíveis no setor 11. A inicialização é feita automaticamente a partir do setor 11.
Interrupção.c
As interrupções de entrada digital, ADC, temporizador e UART estão localizadas neste arquivo. Elas são habilitadas e desabilitadas de acordo com o modo de operação do CLP na função `_INTSetup` dentro de `Fulmatic.c`. Lembre-se de adaptar o código de `_INTSetup` ao seu hardware. As funções neste arquivo precisam ser executadas rapidamente. Em nosso código de exemplo, usamos o comando `switch` para melhorar a legibilidade do código. No entanto, existem maneiras de torná-lo mais rápido. Por exemplo, as operações dentro do comando `switch` podem ser escritas como funções separadas.
- void Handle_Encoder(void)
- void (*EXTI0_Handler_Ptr)(void);
- Dependendo da seleção feita com Fulmatic SOFT em INTSetup: EXTI0_Handler_Ptr = Handle_Encoder;
- Quando ocorrer uma interrupção: Execute EXTI0_Handler_Ptr(); dentro de EXTI0_IRQHandler.
Outro método de aceleração é a conversão de byte para 32 bits. Você pode usar este código para a série STM: *(int32_t *)&PlcIO[EncIAdr[0]] = __rev(ValueS32);
Não devemos usar a biblioteca HAL para limpar os flags de interrupção. Em vez disso, devemos preferir o método mais rápido de modificar diretamente o valor do registrador. TIM3->SR = 0; //__HAL_TIM_CLEAR_IT(htim, TIM_IT_UPDATE);
Interrupções de entrada digital: Utilizadas em contadores de alta velocidade, codificadores e aplicações similares.
ADC: Não usamos DMA; realizamos operações de leitura do ADC dentro da interrupção. Isso nos permite realizar operações de filtragem.
Temporizador: Usamos isso para um temporizador de um milissegundo e saídas de tomada de força (PTO). Não basta que o temporizador simplesmente interrompa a cada milissegundo; ele também deve contar de 0 a 999.
USART: As interrupções da porta serial são usadas para transmissão e recepção de dados. Além disso, Fulmatic.c -> _EachMilliSecond contém operações do pino de habilitação RS485.
SdCard.c
As operações com o cartão SD são realizadas neste arquivo. Você também pode implementá-las de forma diferente do nosso projeto de exemplo. Os códigos de comunicação para envio e recebimento de arquivos para o CLP estão disponíveis em código aberto no arquivo Communication.c. Você pode enviar e receber arquivos usando o Fulmatic SOFT. Caso seu projeto não utilize um cartão SD, você pode excluir todas as funções.
principal.c
Este arquivo será alterado sempre que você salvar o projeto com o Cube MX. Para garantir que seus comandos permaneçam inalterados, você deve escrever seu código nas áreas reservadas para o seu código no Cube MX. /* USER CODE BEGIN 2 */ Escreva o código aqui. /* USER CODE END 2 */
Você pode criar todas as variáveis necessárias para a biblioteca neste arquivo. Pode ser necessário criar arrays grandes em um endereço específico. `uint8_t PlcEprom[PRGMEMORYSIZE] __attribute__((section(“.ccmram”))));`
Examine cuidadosamente as operações dentro do laço while. Quaisquer alterações feitas não devem afetar a estrutura geral. O código escrito em outras partes do programa não deve tornar esse laço mais lento.