Padrão de projeto para um banco de teste mecânico automatizado

5

Plano de fundo

Eu tenho um dispositivo de teste com um número de dispositivos de comunicação / aquisição de dados que é usado como um teste de fim de linha para um produto.

Por causa de todos os vários sensores usados na bancada e da necessidade de executar o procedimento de teste quase em tempo real, estou tendo dificuldades em estruturar o programa para ser mais amigável para modificar mais tarde. Por exemplo, um dispositivo de aquisição de dados USB da National Instruments é usado para controlar uma saída analógica (carga) e monitorar uma entrada analógica (atual), uma balança digital com uma interface de dados serial mede a posição, um medidor de pressão de ar com uma interface de dados serial diferente e o produto é interligado por meio de uma DLL proprietária que manipula sua própria comunicação serial.

A parte difícil

O aspecto "tempo real" do programa é o meu maior ponto de tropeço. Por exemplo, preciso determinar quanto tempo o produto precisa passar da posição 0 para a posição 10.000 e a décima de segundo. Enquanto estiver viajando, eu preciso aumentar a saída do NI DAQ quando ele atingir a posição 6.000 e diminuí-lo quando atingir a posição 8.000. Esse tipo de controle parece fácil de navegar pelos documentos do LabVIEW da NI, mas eu estou com o C # por enquanto. Toda a comunicação externa é feita por polling, o que faz muitos loops irritantes.

Agrupei um modelo do Producer Consumer solto em que o encadeamento do Produtor faz a leitura dos sensores e define as saídas. O encadeamento Consumidor executa funções contendo loops cronometrados que pesquisam o Produtor em busca de dados atuais e executam comandos de movimento conforme necessário. O thread da interface do usuário pesquisa os dois threads para atualizar alguns indicadores que indicam o progresso atual do teste.

Não sabe por onde começar

Existe um padrão mais apropriado para esse tipo de aplicativo?

Há algum bom recurso para escrever loops de controle em software (não-LabVIEW) que interajam com sensores externos e outras coisas?

    
por JJS 12.06.2012 / 20:28
fonte

2 respostas

1

Esta é uma boa pergunta que depende muito do contexto. Minha abordagem será descrever os padrões disponíveis para sua análise. A seguir, uma visão geral de alto nível.

Estou procurando no livro de alto nível Padrões de design - Elementos do software orientado a objeto reutilizável , por Gamma, Helm, Johnson e Vlissides. Ele é escrito para C ++, mas seria amplamente aplicável em C #.

  1. Anti-padrão. Um lado negativo para projetar padrões é o potencial para aplicá-los apenas por uma questão de fazê-lo. É importante perceber que esses padrões resolvem problemas específicos e não devem ser implementados a menos que esse problema exista. Fazer isso seria um antipadrão.

  2. Fachada. 'Fornecer uma interface unificada para um conjunto de interfaces em um subsistema.' Isso parece potencialmente útil para você agrupar todos os seus objetos diferentes em uma única interface. Isso simplificará sua capacidade de acessá-los se todos eles forem agrupados em um 'Singleton' chamado, algo como Sensores ou Consumidores.

  3. Singleton. Garantir uma única instância de um objeto. Isso pode ser útil em colaboração com outros padrões. Isso pode ser comumente usado como objeto Manager ou Proxy, por exemplo.

  4. Proxy. 'Forneça um espaço reservado substituto para controlar o acesso.' Isso pode ser útil para revisar para abstrair seus pontos de conexão.

  5. Cadeia de Responsabilidade, Observador, Assinante do Editor. Estas são as noções de dependências da interface de desacoplamento. Uma delas pode ser útil para você entre o Consumidor do produtor, para que o produtor não seja desconectado esperando a execução de um consumidor ou para responder. Em vez disso, o que pode acontecer é que os eventos permitem uma separação entre os dois.

  6. Estratégia. "Uma família de algoritmos, encapsula cada um deles e os torna intercambiáveis." Isso pode ser útil se você tiver diferentes comportamentos que precisam mudar dinamicamente para estados diferentes.

  7. Iterador. Isso pode fornecer alguma otimização para o seu acúmulo de loops.

Mais uma vez, esta é uma visão geral de alto nível. Tenho certeza de que alguns deles não serão adequados para sua implementação, mas analisá-los pode dar uma boa ideia de quais otimizações estão disponíveis.

Por fim, lembre-se de que esses padrões são mais bem aplicados no tempo de design. Se você tiver uma implementação legada bastante robusta, um alto nível de refatoração complexa seria uma expectativa razoável.

Também dê uma olhada nos padrões específicos de C #. Muitas vezes os padrões originais apresentados acima se transformam à medida que transcendem as línguas. Eles podem ser essencialmente o mesmo padrão, mas com diferentes requisitos específicos de implementação, eles podem alterar nomes. Como PubSub / Observer.

Espero que ajude. Muito bem sucedida! Nash

    
por 13.06.2012 / 17:52
fonte
1

Você tem o hardware que você tem. No entanto ... O sistema operacional Windows não foi projetado para precisão, como você provavelmente sabe. Os controladores periféricos (nos dispositivos de aquisição de dados) geralmente podem fazer um tempo muito melhor que o Windows.

Idealmente, o controlador de periféricos teria uma funcionalidade na qual ele poderia receber uma lista de comandos, que seriam cronologicamente e executados. Essencialmente, você teria um thread em tempo real em um controlador dedicado.

Controle distribuído.

    
por 02.08.2014 / 07:39
fonte