Introdução aos RTSs e SCSs para projetos de ventiladores improvisados ​​COVID-19


O mundo como o conhecemos foi tomado pela tempestade. Essa tempestade foi uma doença com o surto da pandemia de COVID-19. Por sua vez, isso criou uma escassez de ventiladores em todo o mundo. Isso levou muitas pessoas a invadir o mundo do design de ventiladores.

Há apenas um problema, muitas pessoas estão baseando seus projetos na plataforma Arduino. Embora isso possa ser bom para uma prova de conceito; você não deseja usá-lo para suporte de vida real, a menos que seja absolutamente necessário.

Isso ocorre porque plataformas como o Arduino foram projetadas como uma plataforma para serem usadas em um ambiente de aprendizado e não foram projetadas para o tempo real, um projeto crítico de segurança que é necessário para construir ventiladores.

No entanto, existem algumas soluções alternativas que você pode empregar para adaptar a plataforma para uso em um ventilador de emergência improvisado, se for impraticável obter um.

Junte-se a mim neste post enquanto discutimos sistemas em tempo real, sistemas críticos de segurança e espero que você possa usar alguns desses princípios em seus próprios projetos de sistemas de controle de ventilador para melhorar sua segurança e confiabilidade.

Como o público-alvo é principalmente de desenvolvedores da Web que tentam trabalhar com design incorporado, tentarei tornar esse post o mais independente possível. Junte-se a mim enquanto mergulhamos do navegador no domínio do design de sistemas embarcados e nos aproximamos do hardware para projetar nossos ventiladores.

Sistemas Embarcados

Por toda a sua utilidade, um ventilador é simplesmente um sistema incorporado. Um sistema incorporado é um sistema projetado para executar uma função e executá-la bem, com alta confiabilidade e intervenção mínima do usuário.

Para fazer isso, um sistema incorporado consiste em dois componentes. Eles são um sistema de hardware e um componente de software para executar a configuração de hardware.

Um sistema embarcado clássico geralmente é alimentado por um dispositivo de controle que geralmente integra RAM, ROM e um conjunto de periféricos embarcados a bordo para permitir que o sistema realize sua tarefa.

Às vezes, sistemas embarcados modernos podem se basear em um processador de aplicativos, que pode integrar uma GPU, vários núcleos de CPU, codecs de multimídia e outros dispositivos. Embora os processadores de aplicativos possam ser usados ​​em sistemas embarcados, eles são usados ​​principalmente em sistemas de computação de uso geral, como um smartphone.

O software executado em um sistema incorporado é chamado de firmware. É chamado de firmware porque, uma vez gravado na ROM, não é esperado que ele mude com frequência.

Componentes de um sistema incorporado

Pense em um ventilador. Seu principal objetivo é fornecer ventilação mecânica para manter os pacientes vivos. Ele desempenha uma função e a executa com um alto grau de confiabilidade, a tal ponto que pode ser usado como um sistema de suporte à vida. Muito raro você encontra alguém alterando o firmware em um dispositivo assim que foi implantado.

O componente de hardware

Como afirmado anteriormente, o sistema incorporado possui um componente de hardware que integra RAM, ROM e outros dispositivos em um pacote. Este dispositivo é chamado de microcontrolador.

Atualmente, existem vários microcontroladores populares, com o PIC e o AVR da Microchip Technology, bem como o STM32 da STMicroelectronics, sendo o mais popular. O Arduino clássico usa um microcontrolador AVR em seu núcleo.

Independentemente do fabricante, o microcontrolador consiste em um núcleo de processador, memória e um meio de fornecer entrada e saída também conhecida como E / S.

Os microcontroladores também consistem em memória que é dividida em duas categorias: memória de dados e memória de programa.

Memória de dados é a memória usada para armazenar dados que serão usados ​​pelo microcontrolador durante o tempo de execução e normalmente é de algumas dezenas a algumas centenas de kilobytes de SRAM. A memória de dados é volátil e é perdida quando a energia é removida do dispositivo.

Programar memória, por outro lado, na verdade armazena a memória que será usada pelo microcontrolador. Consiste em Flash (pense na memória da sua unidade flash USB) ou FRAM (RAM ferroelétrica) e não é volátil. O tamanho da memória do programa geralmente varia de alguns bytes a alguns megabytes em sistemas modernos.

Os pinos de entrada e saída (E / S) no microcontrolador são os que permitem que o dispositivo se comunique com dispositivos externos, como sensores e outros chips que executam várias funções, como expansão de memória e até adição de E / S adicional ao dispositivo.

Um microcontrolador também integrará periféricos para executar a funcionalidade analógica para digital (A para D) e digital para analógica (D para A).

Isso ocorre porque nosso mundo é de natureza analógica e a Conversão analógica para digital (ADC) converterá os dados do mundo real em um formato que nosso microcontrolador possa processar. Se você tiver um gravador de voz, um sensor de microfone junto com um microcontrolador converterá sua voz em um formato digital e a armazenará.

O microcontrolador também pode ter meios para executar a conversão digital para analógica (DAC), na qual os dados digitais podem ser convertidos em um formato analógico que podemos utilizar no mundo real.

No nosso exemplo de gravador de voz, isso seria aplicável quando você precisar reproduzir sua voz gravada. A informação digital armazenada é convertida em som que podemos detectar em nosso mundo analógico.

Quando combinamos tudo isso, obtemos um diagrama de blocos do hardware típico do microcontrolador.

Diagrama de blocos de microcontrolador bruto

Agora que temos um entendimento básico do hardware, vejamos o componente de software.

O componente de software

Por melhor que seja o seu hardware, sem o software para controlá-lo, ele se torna útil como uma gramatura de papel. O software em sistemas embarcados geralmente se enquadra em três categorias básicas: você tem sistemas de execução cíclica, sistemas baseados em máquinas de estado finito e sistemas construídos usando um sistema operacional em tempo real.

A diferença entre esses três tipos de sistemas de software é baseada na maneira como eles lidam com tarefas. Quando falamos de tarefas, o que estamos falando é a menor unidade de execução dentro do seu firmware.

Sistemas de Execução Cíclica

Um sistema de execução cíclica funciona tendo todas as tarefas do programa contidas em um loop infinito. Esses sistemas têm um ponto de entrada principal do programa e, em seguida, o sistema percorre uma lista de tarefas. Esse é o tipo mais simples de design de firmware e é usado para sistemas básicos.

Sistema de Execução Cíclica

Este sistema terá um ponto de entrada no programa que normalmente configuraria o hardware e configuraria os relógios do sistema e as tarefas básicas de ativação. Depois que o programa entra no loop infinito, ele executa a Tarefa um, depois a Tarefa dois e, finalmente, a Tarefa três.

Máquina de estados finitos

Embora o sistema de execução cíclico seja simples e eficaz na maioria das tarefas, às vezes você precisa de um pouco mais de controle sobre o fluxo do programa. Quando isso ocorre, um designer pode usar o que é conhecido como sistema FSM (Finite State Machine). Sistemas de máquinas de estado finito.

Em um FSM, podemos pensar em cada tarefa como um estado em que a máquina pode estar. O FSM terá um estado inicial e, depois disso, cada estado será executado com base em alguma declaração condicional. O torniquete aceitador de moedas geralmente é usado (como o hello world das máquinas de estado) para explicar o conceito de uma máquina de estado.

“FSM de torniquete aceitador de moedas”. (Estruturas de dados sem código de origem e algoritmos de Armstrong Subero).

Temos um ponto preto que representa o estado inicial, juntamente com dois estados bloqueados e desbloqueados. A catraca em um estado bloqueado será desbloqueada quando você inserir uma moeda. Mesmo se você pressionar a máquina, ela não será desbloqueada até você inserir uma moeda. Depois de inserir uma moeda, a máquina entra no estado desbloqueado e permanecerá nesse estado uma vez que uma moeda seja presente.

Se você pressionar a catraca enquanto estiver no estado destravado, essa condição fará com que a máquina faça a transição para um estado bloqueado no qual permanecerá até que uma moeda seja inserida novamente.

Tão simples quanto parece, esse método de sistema de modelagem de tarefas de programa, como estados que fazem a transição com base em condições, é um método poderoso de design de firmware de sistema incorporado. É o método que eu uso com mais frequência ao projetar meus próprios sistemas.

Os ventiladores são sistemas em tempo real

Sistemas em tempo real ou RTS são sistemas que devem atender a requisitos rígidos em termos de tempo de resposta. Em um sistema de tempo real, não há espaço para compromisso. Esses sistemas devem garantir que executará uma ação dentro de um determinado período de tempo. A não execução de uma ação dentro de um certo período de tempo pode levar à perda de vidas ou danos sérios à propriedade.

Essa é a categoria de sistemas em que um ventilador se enquadra.

Quando um paciente precisa de um ventilador, é porque ele não consegue respirar adequadamente e precisa de assistência mecânica para respirar exigido por um ventilador. Um ventilador pode realizar ventilação contínua obrigatória (CMV), o que significa que o paciente precisará obter um número mínimo de respirações garantidas pela máquina.

A falha em fornecer o número mínimo de respirações necessárias resultará na morte do paciente. Isso significa que a eletrônica de controle deve ser capaz de funcionar sem falhas.

Para isso, os sistemas em tempo real utilizam o que é conhecido como sistema operacional em tempo real (RTOS) para garantir que as muitas tarefas a serem executadas pelo dispositivo possam ser executadas sem falhas.

RTOSs usam um agendador para gerenciar tarefas e limitar como cada tarefa utiliza recursos. O kernel gerenciaria como cada tarefa pode utilizar os recursos de hardware com base em sua prioridade.

Pense nos projetos atuais de ventiladores improvisados ​​que existem. Os mais promissores são construídos usando um ressuscitador de válvula de bolsa que usa motores para acionar braços mecânicos que pressionam o ressuscitador de valor de bolsa e executam as funções do ventilador.

No entanto, o que acontecerá se o motor falhar? Talvez possamos adicionar um sensor infravermelho ou ultrassônico que mede a distância do braço mecânico a partir de um determinado ponto e garante que ele atinja uma distância específica. Esses sensores também podem garantir que retornem ao ponto de partida.

No entanto, o microcontrolador principal que lê esses sensores precisa de tempo para processar as informações. E se um sensor falhar? O microcontrolador deve travar aguardando dados do sensor? Uma falha no sensor impedirá que o motor seja acionado a tempo?

Para garantir que cada tarefa ocorra em um determinado momento, o planejador alocará apenas o tempo de processamento para a tarefa, conforme designado pelo designer do sistema.

Dessa forma, se um sensor falhar, após o tempo alocado para a leitura desse sensor, o microcontrolador passará para a outra tarefa de acionar o motor que manterá o sistema funcionando.

O uso de um sistema operacional em tempo real em seu design garantirá que seu dispositivo possa executar suas funções dentro do tempo especificado.

Os ventiladores são sistemas críticos de segurança

Na seção anterior, discutimos sistemas operacionais em tempo real. Acho que deveríamos expandir um pouco a nossa discussão e falar sobre sistemas de tempo real e de tempo real.

Em sistemas rígidos de tempo real, o requisito de operação é que DEVE ocorrer dentro do tempo especificado a todo custo e o não cumprimento dos prazos não é aceitável. Os sistemas de controle de tráfego aéreo e sistemas de ventilação se enquadram nessa categoria.

Sistemas difíceis em tempo real não podem perder prazos.

Em sistemas flexíveis de tempo real, embora seja preferível que os prazos sejam cumpridos, se nem sempre os prazos forem cumpridos, isso significa que isso pode incomodar o usuário final, mas pode ser aceitável. Pense em uma plataforma de jogos online. Gostaríamos de ter uma resposta em tempo real dos nossos jogos, mas se você perder alguns quadros, isso não resultará em perda de vidas.

Sistemas em tempo real suave podem perder prazos.

Agora, muitas pessoas confundem um sistema em tempo real com um sistema crítico de segurança. Nem todos os sistemas em tempo real são críticos para a segurança. Pense no exemplo acima com jogos on-line ou videoconferência, esses sistemas requerem desempenho em tempo real, mas não são de natureza crítica à segurança.

O que torna um sistema crítico de segurança (SCS) diferente de um sistema regular em tempo real é que o não cumprimento de um prazo dentro de um sistema crítico de segurança resultará em morte ou perda séria de propriedades.

Em um sistema crítico de segurança, a parada do sistema NÃO é uma opção.

Por exemplo, um sistema em tempo real do sistema de alta disponibilidade pode ser especificado como tendo um tempo de atividade de cerca de 99% em um período de 24 horas.

Pense em um sistema de ventilação.

Em qual 1% do dia é aceitável deixar o ventilador inoperante. Como temos 1440 minutos em um dia, quais 14,4 minutos do dia o paciente não deve poder respirar?

A plataforma Arduino

Nesta fase de nossa discussão, acho melhor conversarmos sobre a plataforma Arduino para uso em sistemas críticos de segurança.

Em nossa discussão sobre sistemas embarcados, falamos sobre hardware e software. No entanto, você sabia que também há o componente de ferramentas de desenvolvimento do processo de design?

Você vê que, para colocar o software que você escreveu no dispositivo de microcontrolador que executa o hardware, é necessário usar ferramentas de desenvolvimento, como um IDE e uma cadeia de ferramentas para programar o dispositivo.

Configurar e usar uma cadeia de ferramentas foi um processo doloroso, dependendo do dispositivo que você estava usando. Muitos fornecedores de microcontroladores costumavam fornecer IDEs desajeitados que você precisava ser um designer incorporado experiente (embora isso tenha mudado nos últimos anos).

Além disso, você também precisava do conhecimento do hardware subjacente e a configuração de registros e relógios pode ser assustadora, mesmo para designers experientes.

Mesmo que você tenha superado esses obstáculos no lado do software, era necessário ter uma placa de circuito impresso (PCB) ou ter experiência em usar uma placa de ensaio para colocar seu microcontrolador em funcionamento.

Você não sabia como conectar corretamente o seu hardware, mesmo que seu programa esteja correto, o dispositivo não funcionará e a solução de problemas do hardware também exigia alguma experiência.

Para resolver o problema, a plataforma Arduino foi introduzida como uma maneira de fornecer sinergia entre hardware, software e ferramentas de desenvolvimento para fazer com que os alunos controlem o hardware com facilidade.

Os componentes da plataforma Arduino

O Arduino fornece uma placa física com o chip que está em uma configuração conhecida por funcionar junto com um IDE simples com toneladas de bibliotecas. Essa integração perfeita cria uma incursão menos intimidante para iniciantes que desejam entrar no campo do design de hardware.

O problema com o uso do Arduino em sistemas críticos de segurança

Há um problema, já que o Arduino é tão fácil de usar, isso levou muitas pessoas a usar o Arduino muito além do objetivo original da plataforma, incluindo o uso em sistemas de tempo real.

Não é recomendável usar o Arduino para sistemas em tempo real. Por quê? Algumas pessoas podem argumentar que você pode usar um sistema operacional como o Amazon FreeRTOS no Arduino e torná-lo em tempo real. Isso é verdade, enquanto a plataforma se tornar em tempo real e oferecer alta confiabilidade, ela não será um fator crítico de segurança.

O que torna o Arduino não adequado para uso em sistemas críticos de segurança? A resposta está na abstração e sua relação com a capacidade de teste e depuração da plataforma.

O Arduino é uma boa plataforma para aprendizado, pois adiciona muita abstração de software para facilitar as coisas.

A abstração em si não é necessariamente uma coisa ruim. A abstração permite a reutilização do código e pode ajudar a eliminar erros se usada corretamente. O código devidamente testado que abstrai muito do hardware pode ser uma ferramenta poderosa nas mãos certas.

No entanto, a abstração NÃO elimina erros e existe o problema. Mesmo se o código for abstrato, se ele tiver uma lógica defeituosa, a abstração não o salvará.

Se você encontrar um bug, normalmente você confiaria em um depurador e testes de software para ajudá-lo a descobrir a fonte e melhorar a confiabilidade do sistema.

Ai que fica o problema. A plataforma Arduino não possui capacidade de depuração.

Não ter depuração dificulta o rastreamento de erros. Ter um software livre de bugs é crucial em um projeto crítico de segurança. Além disso, a execução de testes no seu código não é fácil, pois o IDE é muito simples para a poderosa depuração e teste necessários para o design do sistema de segurança crítica.

Se você não tiver escolha, poderá usar o Arduino para projetar um sistema de ventilação, no entanto, a falta de depuração dificulta e aumenta a probabilidade de erros no firmware e aumenta o risco de falha no sistema.

Como posso projetar um bom sistema improvisado?

Se você deve projetar um sistema de ventilação, há algumas coisas específicas que você pode fazer para melhorar seu design com base no Arduino, executando duas coisas específicas.

Você pode melhorar o design do software e o design do hardware.

Melhorando o design no lado do software

Toda a esperança não está perdida. Para garantir que seu sistema possua um software confiável, considere o seguinte:

  1. Considere usar outro IDE – o Atmel Studio é um ótimo IDE que oferece a opção de depuração se você usar um depurador externo, como o Atmel ICE ou ICD 4. Além disso, o MPLAB X pode ser usado. Esses IDE ajudarão na depuração.
  2. Aderir a um padrão de codificação C / C ++ – O uso de um padrão de código pode melhorar a confiabilidade do sistema e tornar o design do sistema mais eficiente. Considere reescrever as bibliotecas que você está usando para aderir ao MISRA, JSF ++ ou mesmo ao padrão de codificação C incorporado do Barr Group
  3. Use um RTOS – Muitos dos projetos de ventiladores baseados no Arduino utilizam a plataforma como está com um sistema de execução cíclico. Considere usar o Amazon FreeRTOS para tornar seu sistema em tempo real. Isso evitaria o bloqueio do sistema e tornaria seu sistema mais confiável.
  4. Considere usar uma plataforma com bibliotecas que atendem aos requisitos de segurança – embora não seja ideal para designers inexperientes; o uso de um dispositivo que possui bibliotecas que já possuem requisitos de segurança existentes ajudará a tornar seu design mais robusto. Por exemplo, mesmo que nosso dispositivo seja um dispositivo médico improvisado, o uso dos requisitos IEC 60730 para segurança de Classe B pode ajudar a tornar seu projeto mais robusto. A Microchip Technology (empresa que fabrica o chip que alimenta o Arduino) possui outros dispositivos que possuem bibliotecas que atendem aos requisitos de segurança da Classe B e ajudariam a melhorar a segurança do dispositivo.
  5. Implementar redundância analítica de dados do sensor – Ao projetar seu dispositivo, considere usar sensores para garantir que ele ainda esteja operacional e, quando o fizer, considere usar métodos de redundância analítica para ajudar com dados mais precisos do sensor.
  6. Considere usar o SAFERTOS – Embora possa exigir a alteração de sistemas, o SAFERTOS é pré-certificado para uso em sistemas médicos e fornecerá um nível de segurança mais alto que o software da plataforma Arduino.

Melhorando o design no lado do hardware

Você também pode melhorar seu design no lado do hardware:

  1. Considere usar um cronômetro de monitoramento – se você não tiver tempo para usar um RTOS, uma maneira simples de garantir que seu dispositivo continue operando é usar um cronômetro de monitoramento em seu projeto. O cronômetro do watchdog garante que o dispositivo seja redefinido se ocorrer um problema na execução do seu código.
  2. Use um dispositivo de hardware com certificações e bibliotecas de segurança pré-existentes – Alguns dispositivos são mais adequados para a tarefa de design de um ventilador. Em vez de confiar um projeto crítico de segurança a um Arduino, considere usar um dispositivo de controle que possa usar software já certificado para uso em dispositivos médicos ou forneça bibliotecas de segurança. As plataformas suportadas pelo SAFERTOS são um bom ponto de partida. A página da Web Microchip Technology no software de segurança Classe B também é um bom ponto de partida.
  3. Adicionar sistemas de feedback – Não basta ter o seu dispositivo em funcionamento. Você também precisa de sistemas de feedback para garantir que os dispositivos estejam operando como deveriam. Integre sensores para fornecer feedback sobre peças mecânicas sujeitas a falha.
  4. Considere o controle de hardware distribuído – embora muitas pessoas baseiem seus projetos em um único chip, considere usar vários microcontroladores em seu projeto. Considere ter um dispositivo para controle e outro para notificar o usuário final se um componente estiver falhando.
  5. Implementar redundância do sistema – Ter um sistema de desligamento adequado com um sistema de transferência adequado é crucial para esses projetos. Implemente um procedimento de desligamento adequado, caso o sistema falhe, além de ter um mecanismo de comutação adequado para garantir que você tenha um tempo de funcionamento de 100% no sistema.

Empacotando

Neste post, vimos sistemas embarcados, falamos brevemente sobre seus componentes de hardware e software e abordamos paradigmas de design de firmware. Também falamos sobre sistemas em tempo real e sistemas críticos de segurança no que se refere ao design do ventilador.

Por fim, falamos sobre como melhorar a segurança e a confiabilidade dos projetos de seus ventiladores baseados em Arduino, melhorando o design de hardware e software.

No final deste post, você deverá ter alguma compreensão de como aprimorar seu sistema de ventilação Arduino improvisado.

Se você deseja aprender mais sobre microcontroladores, pegue meu livro “Programação de microcontroladores PIC com XC8”, onde você aprenderá sobre o microcontrolador PIC e como programá-lo. Este microcontrolador também pode ser usado para projetar seus ventiladores e oferecerá um maior grau de capacidade de controle e depuração do que a plataforma Arduino.

Leia o livro aqui:

https://www.apress.com/gp/book/9781484232729



Fonte

Leave a Reply

Your email address will not be published. Required fields are marked *