11SMTF050922T03

11a
Semana de Tecnologia Metroferroviária – Fórum Técnico
Associação dos Engenheiros e Arquitetos de Metrô - AEAMESP
IMPORTÂNCIA DA QUALIDADE DE SOFTWARE EM SEGURANÇA CRÍTICA
Introdução
O objetivo deste trabalho, frente ao atual cenário do setor Metroferroviário, é de conscientização e
esclarecimento sobre o Controle da Qualidade de Software de Sistemas Sinalização e Controle,
demonstrando providências exigíveis a Empresas Fornecedoras e Projetistas destes Sistemas.
No meio acadêmico, são ainda muito discutidas as problemáticas da realização de funções de
segurança através de Software. Apesar do tímido número de evidências científicas de que
equipamentos baseados em Software se comportam de maneira segura, a prática em diversas áreas
demonstra um quadro irreversível de aplicação intensiva desses equipamentos nos mais diversos
sistemas, conforme vivenciamos no nosso dia a dia.
A obtenção de um Software Seguro envolve inúmeros fatores, entre eles a experiência e o preparo
de toda a equipe envolvida no Processo, o uso de técnicas e ferramentas apropriadas, uma criteriosa
Análise de Segurança Independente e, dentre os atributos da Qualidade de Software, em especial
sua Confiabilidade.
Confiabilidade de Software
A Confiabilidade de Software pode ser definida como a “probabilidade de operação livre de falhas
por um período de tempo especificado em um determinado ambiente” [ANSI 1991]. A
Confiabilidade é um dos atributos da Qualidade de Software, uma propriedade multidimensional
que inclui outros fatores de satisfação do cliente tais como funcionalidade, facilidade de uso,
desempenho, capacidade, documentação, facilidades de suporte, instalação e manutenção [Grad
1987, Grad 1992].
A Confiabilidade de Software é geralmente aceita como o fator principal da Qualidade de Software,
pois quantifica as falhas de Software – que podem tirar de operação um poderoso sistema ou até
mesmo trazer riscos às pessoas e patrimônio [Lyu 1996].

Os métodos mais respeitados e evoluídos para a avaliação da confiabilidade de software, tal como
descrito em “Software Reliability Engineering” [Musa 1999], são baseados na observação de falhas
do produto terminado, sustentada por análise estatística. Estes métodos são a única forma de medir
a confiabilidade do produto, pois são baseadas na observação direta de seu comportamento. As
importantes desvantagens destas abordagens são [Dale 1990]:
• estão preocupadas puramente com a medida da confiabilidade, enquanto outras informações
sobre, por exemplo, os métodos que foram utilizados no desenvolvimento do produto, são
ignoradas; e
• só podem ser utilizadas quando o produto final existe, portanto sua aplicação só pode ser
iniciada a partir da obtenção de dados durante a fase de testes do desenvolvimento.
Uma alternativa pesquisada para a obtenção de Software de alta confiabilidade é a especificação e
análise dos Processos de Desenvolvimento de Software adotados em um projeto, em conformidade
com as normas técnicas adequadas a aplicação, além de modelos de ampla aceitação.
Adotando-se uma abordagem deste tipo, a avaliação da confiabilidade deve ser realizada sobre os
produtos intermediários de cada fase do processo de desenvolvimento, antes de se obter o produto
final.
Segurança de Software (SW Safety)
A Segurança de um sistema S(t) é a probabilidade de um sistema efetuar suas operações de forma
correta, ou descontinuar seu funcionamento de forma a não comprometer a operação de outros
sistemas ou comprometer a Segurança [Johnson 1989]. As técnicas de “falha segura” (fail-safe) têm
sido empregadas desde em sistemas eletrônicos convencionais e até mesmo nas principais rotinas de
diagnóstico de funções de Software e componentes de Hardware, bem como nos conceitos de
programação defensiva.
Especificação de Requisitos Técnicos de Software
A Especificação Técnica de Software abordada a seguir foi elaborada, a princípio, tendo em vista
um horizonte de aplicação da tecnologia “Communications Based Train Control” (CBTC) na

implantação e modernização de Sistemas de Sinalização e Controle. O emprego desta nova
tecnologia traz desafios tais como:
• uso intensivo de Software para a realização de funções de Tempo Real e Segurança Crítica;
• fatores de aumento natural do risco e a conseqüente necessidade de sua mitigação através da
tecnologia, tais como a diminuição do intervalo entre trens (“headway”), operação automática
sem condutor (“driverless”), funções de diagnóstico e recuperação remotas;
• transmissão intensiva por meio aberto de sinais vitais, trazendo preocupações típicas da
Segurança da Informação (“security”), além do envelhecimento de informações de tempo real,
que devem ser tratadas pelo Software de comunicação;
• determinação da posição das composições e distâncias percorridas utilizando múltiplos
sensores, e tratamento por algoritmos que incluem informações sobre margens de segurança
para determinação e cumprimento de pontos de parada com segurança;
• emprego limitado de hardware intrinsecamente “fail-safe” e componentes com modos de falha
bem definidos; e
• os conceitos consagrados de Segurança de um Sistema de Sinalização e Controle devem ser
implementados de forma completa e claramente verificáveis [IEEE 2005].
No entanto, devido a incorporação da experiência obtida pelo METRÔ-SP no projeto e implantação
dos sistemas de Sinalização e Controle, somada a estudos realizados em conjunto com a Fundação
para o Desenvolvimento Tecnológico da Engenharia - FDTE, foi considerado adequado o emprego
desta metodologia para a aquisição de Software do Sistema de Sinalização e Controle de Trens –
Estações e Vias da Extensão da Linha 2 – Verde, trecho Ana Rosa – Ipiranga, mesmo tratando-se de
um Sistema Microprocessado Convencional, e dentre seus principais requisitos, serão enfatizados:
Conformidade com CMMi
A Capacidade do Processo [CMU/SEI 2002] estabelece o grau de refinamento e institucionalização
com que o processo é realizado em uma organização, em cinco níveis discretos, em sua
representação por estágios, conforme representado na Figura 1.

Nível 1 - Inicial
Fracamente Controlado,
Imprevisível
Nível 2 - Repetível
Repetição de Tarefas
executadas com sucesso
Nível 3 - Definido
Processo caracterizado e
claramente entendido
Nível 4 - Gerenciado
Processo medido e
controlado
Nível 5 - Otimização
Foco na melhoria
contínua do Processo
Figura 1 - Estágios do CMMi
Os atributos de processo pertinentes ao nível 2 do CMMi, pelo qual estamos iniciando a utilização
desta metodologia, ilustrados na Figura 2, podem ser assim resumidos:
• o Processo é Executado;
• o Processo atinge seus resultados definidos; e
• os produtos de trabalho do Processo são gerenciados.
SaídasEntradas
Figura 2 - CMMi nível 2 - Visibilidade
A Especificação Técnica de Software apresenta o seguinte requisito:
A Contratada deve adotar a metodologia estabelecida no “Capability Maturity Model Integration
for Systems Engineering and Software Engineering” (CMMI-SE/SW), versão 1.1 ou superior, do
“Software Engineering Institute / Carnegie Mellon University” (SEI/CMU) para todo o Software
fornecido, sendo que:

Deve ser adotado CMMI-SE/SW nível dois (2) ou superior, na representação em estágios “Staged
Representation”;
A Contratada deve comprovar pelo “Standard CMMI Appraisal Method for Process Improvement”
(SCAMPI) [CMU/SEI 2001], o emprego desta metodologia por toda equipe envolvida no projeto.
Nível de Integridade de Segurança (SIL)
A Especificação Técnica de Software apresenta o seguinte requisito com relação ao Nível de
Integridade de Segurança de Software, que juntamente com os parâmetros de Segurança do
Hardware irão determinar a Segurança do Sistema, traduzido em valores na Figura 3.
Os conceitos de “Fail Safe” devem ser utilizados no Software relacionado às funções de Segurança
Crítica ou Vitais. Deve atender ao “Software Safety Integrity Level” (SIL) quatro (4), conforme a
norma IEC 61508 “Functional Safety of Electrical/Electronic/Programmable Electronic Safety-
Related Systems”.
SIL Falhas inseguras / hora
4 10-9
< λu < 10-8
3 10-8
< λu < 10-7
2 10-7
< λu < 10-6
1 10-6
< λu < 10-5
Figura 3 – Nível de Integridade de Segurança [IEC 1999]
Conformidade com a Norma CENELEC 50128
Um importante requisito na Especificação Técnica de Software é a conformidade com a Norma
CENELEC 50128 [CENELEC 2001], específica para o Software aplicado a Sistemas de
Sinalização e Controle:
Devem ser atendidas as recomendações da norma CENELEC 50128 “Railway applications –
Communications, Signaling and Processing Systems – Software for Railway Control and Protection
Systems”.
Conforme podemos observar no diagrama seguinte, presente na Figura 4, as atividades específicas
para a obtenção do Software estão vinculadas às especificações do Sistema onde ele é empregado.

Integração de Sistema
Especificação de Requisitos de Sistema
Especificação de Requisitos de Segurança de Sistema
Descrição da Arquitetura de Sistema
Plano de Segurança de Sistema
Especificação dos
Requisitos de Software
Especificação de teste de
Especificação de Arquitetura de Software
Plano de Integração de
Software
Especificação de Projeto de
Software
Especificação de Teste de
Módulo de Software
Especificação de Projeto de
Módulo de Software
Código Fonte de Software,
e documentação de suporte
Relatório de Teste de Módulo de Software
Relatório de Teste de Integração de Software
Relatório de Teste de Integração de Software e
Hardware
Documentos de Integração e Teste de Sistema
Verificação do Sistema
Verificação dos Requisitos de
Software
Verificação da Arquitetura
de Software
Verificação do Projeto de
Software
Verificação dos módulos de
Software
Verificação de Código
Validação de Software
Validação de Sistema
Teste de Software
Implementação /
Codificação
Projeto de Software
Integração de Software e
Hardware
Documentos de Projeto Verificação Etapa
Documentos de Instalação do Sistema
Documentos de Manutenção do Sistema
Validação do Sistema
Desenvolvimento do
Sistema
Projeto de Módulo de
Software
Validação de Software
Transição para Suporte
Figura 4 - Ciclo de Vida e Artefatos [CENELEC 2001]

Planejamento de Software
Antes do início do desenvolvimento do Software, foi detectada a necessidade de solicitar à empresa
fornecedora e projetista a elaboração de Planos específicos aos processos de obtenção de Software
com o nível de Segurança adequado à aplicação no sistema de Sinalização e Controle:
• Plano de Gerenciamento de Software;
• Plano de Garantia da Qualidade de Software;
• Plano de Gerência de Configuração de Software;
• Plano de Verificação de Software de Aplicação Crítica e de Segurança; e
• Plano de Validação de Software.
Estes documentos deverão ser submetidos à aprovação, incluindo eventuais alterações ao longo do
fornecimento.
Ciclo de Vida
A Especificação Técnica de Software apresenta, ainda, uma descrição das fases de um Ciclo de
Vida do Software de referência, listadas a seguir:
• Especificação de Requisitos de Software;
• Arquitetura de Software;
• Projeto de Software;
• Implementação de Software;
• Integração e Testes de Software;
• Validação de Software;
• Aceitação de Software; e
• Operação e Manutenção.
Conclusões
Este trabalho tem por objetivo obter uma maior garantia do nível de Segurança do Software e,
ainda, a redução do re-trabalho e conseqüente otimização dos recursos empregados, possibilitando
também um maior controle sobre o processo e as tecnologias em implantação.
Não deixando de observar as limitações impostas pelo estágio de desenvolvimento atual da
indústria nacional, é importante vislumbrar esta oportunidade e necessidade de progresso,

aproveitando a experiência e capacidade de inovação, e incorporando a iniciativa dos maiores
consumidores de Software mundiais e a produção científico-acadêmica disponível nesta área.
Referência Bibliográfica
[CMU/SEI 2002] Carnegie Mellon University Software Engineering Institute: “CMMI-SE/SW – Capability Maturity
Model Integration (CMMI), Version 1.1: CMMI for Systems Engineering and Software Engineering, Staged
Representation”, CMU/SEI-2002-TR-002, 2002.
[CMU/SEI 2001] Carnegie Mellon University Software Engineering Institute: “SCAMPI – Standard CMMI Appraisal
Method for Process Improvement Version 1.1: Method Definition Document”, CMU/SEI-2001-HB-001, 2001.
[CENELEC 2001] European Committee for Electrotechnical Standardization: “Railway Applications –
Communications, Signaling and Processing Systems – Software for Railway Control and Protection Systems”, BS-EN
50128, 2001.
[Dale 1990] Dale, C.; Paul Rook (ed.) – “Software Reliability Handbook” – Elsevier Applied Science, 1990.
[Johson 1989] Barry W. Johnson –“Design and Analyses of fault-Tolerant Digital Systems” – Addison-Wesley, 1989.
[Lyu 1996] Michael R. Lyu (ed.) – “Handbook of Software Reliability Engineering”, McGraw-Hill, 1996.
[Musa 1999] Musa J.D. – “Software Reliability Engineering”, McGraw-Hill, 1999.
[ANSI 1991] ANSI/IEEE, "Standard Glossary of Software Engineering Terminology", STD-729-1991, ANSI/IEEE,
1991.
[GRAD 1987] Grady, Robert B.; Caswell, Deborah L.- “Software Metrics: Establishing a Company-Wide Program.”
Prentice Hall, 1987.
[GRAD 1992] Grady, Robert B. - “Practical Software Metrics for Project Management and Process Improvement”.
Prentice Hall, 1992.
[IEEE 2005] IEEE Standard for Communications-Based Train Control (CBTC) Performance and Functional
Requirements, Institute of Electrical and Electronics Engineers, IEEE 1474-1, 2005.
[IEC 1999] Functional safety of electrical/electronic/programmable electronic safety-related systems - General
requirements, IEC 61508-1, 1999.
Eng. Christian Becker Bueno de Abreu
e-mail: cbecker@metrosp.com.br – tel. 55-11-3371-7222
Engenheiro de Projeto da Companhia do Metropolitano de São Paulo – METRÔ
Departamento de Projeto de Sistemas de Controle e Comunicações – GEP/EPS
Prof. Dr. Paulo Sérgio Cugnasca
Escola Politécnica da Universidade de São Paulo (EPUSP)
Departamento de Engenharia de Computação e Sistemas Digitais (PCS)
Grupo de Análise de Segurança (GAS)

202 3 FtxBAC[UFtxBAC].m[i+1] = msg[i]; 203 3 i++;
204 3 }
205 2
206 2 FtxBAC[UFtxBAC].m[0] = n;
207 2
208 2
209 2 /* Atualiza indices da fila de transmissao. */
210 2 if (UFtxBAC >= (MAXFTXBAC-1))
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
218 1 return(FALSE);
219 1 }
248 BYTE ObtemMsgBAC (BYTE *msg)
249 {
250 1 BYTE i;
251 1
252 1 /* Existe mensagens na Fila de Recepcao. */
253 1 if (QFrxBAC > 0)
254 1 {
255 2 /* Sim. Copia a mensagem para o ponteiro. */
256 2 i = 0;
257 2 while (i < FrxBAC[PFrxBAC].m[0])
258 2 {
259 3 msg[i] = FrxBAC[PFrxBAC].m[i+1];
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
264 2 /* Atualiza indices da fila de recepcao. */
265 2 disable();
266 2 if (PFrxBAC >= (MAXFRXBAC-1))
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
302 void EnviaAckBAC (void)
303 {
304 1 TxMsgAckBAC();
305 1 FlagTxBAC = 2;
306 1 TimerTimeoutBAC = TimerRelogio3;
307 1 return;
308 1 }
333 void EnviaNackBAC (void)
89 void IniciaBAC (void)
90 {
91 1 Diagnostico[0x07] ++;
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
100 1 FlagEstadoBAC = 0;
101 1 FlagCpcBAC = 0;
102 1 FalhasBAC = 0;
103 1 NrtxBAC = MAXRETXBAC;
104 1 SemaforoTxBAC = 0x0F;
106 1 TimerJanelaBAC = TimerRelogio2;
107 1 ProgramaRS232C();
108 1 InsereTarefa(14, NIL, NIL, (14 ^ NIL ^ NIL));
109 1
110 1 #if MESTREBAC == 1
#endif
113 1 return;
114 1 }
141 void TestaFilaBAC (void)
142 {
143 1 Diagnostico[0x44]++;
144 1
145 1 disable();
146 1 if ((PFrxBAC >= MAXFRXBAC) ||
147 1 (UFrxBAC >= MAXFRXBAC) ||
148 1 (QFrxBAC > MAXFRXBAC) ||
149 1 (PFtxBAC >= MAXFTXBAC) ||
150 1 (UFtxBAC >= MAXFTXBAC) ||
151 1 (QFtxBAC > MAXFTXBAC))
152 1 {
153 2 /* Erro. */
154 2 FalhaFatal = 0x09;
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
190 BYTE EnviaMsgBAC (BYTE *msg, BYTE n)
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
195 1 if ((SemaforoTxBAC == 0) && (QFtxBAC < MAXFTXBAC) &&
196 1 (n < MAXBFTXBAC))
197 1 {
198 2 /* Copia a mensagem para a fila. */
199 2 i = 0;
200 2 while (i < n)
201 2 {
11ª Semana de Tecnologia Metroferroviária
Importância da
Qualidade de Software
em
Segurança Crítica
Eng. Christian Becker Bueno de Abreu
Prof. Dr. Paulo Sérgio Cugnasca

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Software - Definições
“Software”:
Criação intelectual compreendendo os programas,
procedimentos, regras e qualquer documentação correlata
de um sistema de processamento de dados
NOTA: O “software” não depende do meio no qual é
registrado.
Desenvolvimento:
Todas as atividades a serem realizadas para a criação de um
produto de Software.
[NBR ISO 9000-3]
Natureza do
Software
???

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Software - Definições
“Software”:
Criação intelectual compreendendo os programas,
procedimentos, regras e qualquer documentação correlata
de um sistema de processamento de dados
NOTA: O “software” não depende do meio no qual é
registrado.
Desenvolvimento:
Todas as atividades a serem realizadas para a criação de um
produto de Software.
[NBR ISO 9000-3]

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Qualidade & Segurança - Definições
Qualidade - indicadores
● Confiabilidade
● Funcionalidade
● Facilidade de uso
● Desempenho
● Capacidade
● Documentação
● Suporte, Instalação e
Manutenção
Segurança - S(t)
Probabilidade de um sistema
efetuar suas operações de
forma correta ou
descontinuar seu
funcionamento de forma a
não comprometer a operação
de outros sistemas ou
comprometer a Segurança

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Qualidade ∩ Segurança - Confiabilidade
Confiabilidade - R(t)
Probabilidade de operação
livre de falhas por um
período de tempo
especificado em um
determinado ambiente
QUALIDADEQUALIDADE
CONFIABILIDADECONFIABILIDADE
MTTF
0
R t . dt

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Medição da Confiabilidade
Medir a Confiabilidade:
Observação de falhas
+
Análise estatística.
Problemas:
- Início na etapa de testes:
Produto deve estar terminado
- Tempo necessário:
Software Ultra-confiabilidade
- Informações ignoradas:
Métodos empregados
Alternativa:
Especificação e Análise dos
Processos de Desenvolvimento
de Software.
Conformidade com Normas
Técnicas adequadas e Modelos
de ampla aceitação.
Avaliação da Confiabilidade
sobre Artefatos Intermediários
de cada fase do Processo de
Desenvolvimento.

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
CMU/SEI - CMMi
Representação em estágios:
A Capacidade do Processo
estabelece o seu
grau de refinamento e
institucionalização.

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
CMU/SEI - CMMi
Visibilidade:
CMMi nível 2

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Requisito Técnico de Software - Qualidade
Deve ser adotada a metodologia estabelecida no “Capability
Maturity Model Integration for Systems Engineering and
Software Engineering” (CMMI-SE/SW), versão 1.1 ou superior,
do “Software Engineering Institute / Carnegie Mellon University”
(SEI/CMU) para todo o Software fornecido, sendo que:
● Deve ser adotado CMMI-SE/SW nível dois (2) ou superior, na
representação em estágios “Staged Representation”;
● Deve ser comprovado pelo “Standard CMMI Appraisal Method
for Process Improvement” (SCAMPI), o emprego desta
metodologia por toda equipe envolvida no projeto.
[EPS 2004]

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Fail Safe (Falha Segura)
A validade deste conceito é, em geral, baseada na
experiência, mas tem aplicação limitada ao
desenvolvimento e uso de sistemas grandes e
complexos empregando microprocessadores
comerciais.
O crescimento exponencial no número de
combinações de falhas a serem consideradas
quando usando tais componentes significam que
uma abordagem determinística é, geralmente
impraticável. Com tais sistemas complexos, a
abordagem probabilística pode ser usada
efetivamente. [CENELEC 50126]
Exemplos de aplicação
em Software:
- Rotinas de diagnóstico
- Programação Defensiva

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Níveis de Risco
Determinação dos Níveis de Risco
*Freqüênciada
ocorrênciadeum
eventodeameaça
NíveisdeRisco
Freqüente Indesejável Intolerável Intolerável Intolerável
Provável Tolerável Indesejável Intolerável Intolerável
Ocasional Tolerável Indesejável Indesejável Intolerável
Remoto Negligenciável Tolerável Indesejável Indesejável
Improvável Negligenciável Negligenciável Tolerável Tolerável
Inacreditável Negligenciável Negligenciável Negligenciável Negligenciável
Insignificante Marginal Crítico Catastrófico
Níveisdegravidadedaconseqüênciadaameaça.

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
IEC 61508 - Parâmetros para determinar SIL
Conseqüência do Risco
C1 Perdas Pequenas.
C2 Perdas sérias e permanentes
para uma ou mais pessoas, ou
morte de uma pessoa.
C3 Morte de várias pessoas.
C4 Muitas pessoas assassinadas.
Freqüência e Tempo de Exposição
F1 Exposição de rara a freqüente na
região de perigo.
F2 Exposição de freqüente a
permanente na região de perigo.
Possibilidade de evitar o evento
P1 Possível sob certas condições.
P2 Quase impossível.
Probabilidade de ocorrências
indesejáveis
W1Probabilidade muito pequena de
que as ocorrências acontecerão.
W2Probabilidade pequena de que
as ocorrências acontecerão.
W3Probabilidade relativamente alta
de que as ocorrências
acontecerão.

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Redução de Risco Nível de Integridade de Segurança
- Sem Requisitos de Segurança
A Sem Requisitos Especiais de Segurança
B, C SIL 1
D SIL 2
E, F SIL 3
G SIL 4
H Sistemas de Proteção não Suficientes
IEC 61508 - Determinar Redução de Risco e SIL
W3 W2 W1
C1 A - -
C2
F1
P1 B A -
P2 C B A
F2
P1 D C B
P2 E D C
C3
F1 F E D
F2 G F E
C4 H G F
4 10-9
< u < 10-8
3 10-8
< u < 10-7
2 10-7
< u < 10-6
1 10-6
< u < 10-5

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
4 10-9
< u < 10-8
3 10-8
< u < 10-7
2 10-7
< u < 10-6
1 10-6
< u < 10-5
W3 W2 W1
C1 A - -
C2
F1
P1 B A -
P2 C B A
F2
P1 D C B
P2 E D C
C3
F1 F E D
F2 G F E
C4 H G F
B, C SIL 1
D SIL 2
E, F SIL 3
G SIL 4

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
B, C SIL 1
D SIL 2
E, F SIL 3
G SIL 4
W3 W2 W1
C1 A - -
C2
F1
P1 B A -
P2 C B A
F2
P1 D C B
P2 E D C
C3
F1 F E D
F2 G F E
C4 H G F
4 10-9
< u < 10-8
3 10-8
< u < 10-7
2 10-7
< u < 10-6
1 10-6
< u < 10-5

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Software & Segurança: EN50128 SWSIL
Tendo caracterizado o Nível de
Integridade de Segurança (SIL)
para o Sistema Metro-ferroviário,
o Software na área de Sinalização
para tal Sistema deverá possuir o
mesmo valor.
5.2.2 Os requisitos de nível de
integridade de segurança de
software (SWSIL) deverão ser
decididos com base no nível
de risco associado com a
utilização do software no
sistema e no nível de
integridade de segurança de
software.
[CENELEC 50128]

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
CENELEC 50128
4
3
2
1
0
4
3
2
1
0
SWSILSIL
Freqüência de
Ameaça
Conseqüência
Ameaça
Equipamentos
Sujeitos
a
Controle
Nível Risco:
Ausência
Proteção
Exige
Redução
Riscos
4
3
2
1
0
4
3
2
1
0
SWSIL
Freqüência de
Ameaça
Conseqüência
Ameaça
Equipamentos
Sujeitos
a
Controle
Nível Risco:
Ausência
Proteção
Exige
Redução
Riscos

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
CENELEC 50128 - Ciclo de Vida I

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
CENELEC 50128 - Ciclo de Vida II

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
CENELEC 50128 - Ciclo de Vida III

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Requisito Técnico de Software - Segurança
Os conceitos de “Fail Safe” devem ser utilizados no Software
relacionado às funções de Segurança Crítica ou Vitais.
Deve atender ao “Software Safety Integrity Level” (SIL)
quatro (4), conforme a norma IEC 61508 “Functional Safety of
Electrical/Electronic/Programmable Electronic Safety-Related
Systems”.
Devem ser atendidas as recomendações da norma CENELEC
50128 “Railway applications – Communications, Signaling and
Processing Systems – Software for Railway Control and
Protection Systems”.
[EPS 2004]

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
Emprego de Software em Sinalização - Horizonte
Considerações:
● Uso Intensivo de SW em Tempo Real e Segurança Crítica;
● Fatores de aumento natural do risco;
● Transmissão por meio aberto de Sinais Vitais;
● Determinação de distância por múltiplos sensores;
● Emprego limitado de Hardware fail-safe;
Os conceitos consagrados de Segurança de um Sistema de
Sinalização e Controle devem ser implementados de forma
completa e claramente verificáveis. [IEEE 1474-1]

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
O Software com Qualidade:
● Maior Garantia do Nível de Segurança
● Redução do Retrabalho
● Otimização de Recursos
● Controle sobre o Processo
● Controle sobre Tecnologias em Implantação
● Integra Experiência e Capacidade de Inovação
● Incorporação de Iniciativas dos maiores
Consumidores de Software mundiais e da
Produção Científico-acadêmica na área.

204 3 }
205 2
207 2
208 2
211 2 UFtxBAC = 0;
212 2 else
213 2 UFtxBAC ++;
214 2 QFtxBAC ++;
215 2
216 2 return(TRUE);
217 2 }
219 1 }
249 {
250 1 BYTE i;
251 1
254 1 {
256 2 i = 0;
258 2 {
260 3 i++;
261 3 }
262 2
263 2 /* [02] */
265 2 disable();
267 2 PFrxBAC = 0;
268 2 else
269 2 PFrxBAC ++;
270 2 QFrxBAC --;
271 2 enable();
272 2
273 2 return(i);
274 2 }
275 1
276 1 return(0);
277 1 }
303 {
307 1 return;
308 1 }
90 {
92 1 UFtxBAC = 0;
93 1 PFtxBAC = 0;
94 1 AFtxBAC = 0;
95 1 QFtxBAC = 0;
96 1 UFrxBAC = 0;
97 1 PFrxBAC = 0;
98 1 QFrxBAC = 0;
99 1 FlagTxBAC = 0;
109 1
#endif
113 1 return;
114 1 }
142 {
144 1
145 1 disable();
152 1 {
153 2 /* Erro. */
155 2 ErroFatal();
156 2 halt();
157 2 }
158 1 enable();
159 1 return;
160 1 }
191 {
192 1 BYTE i;
193 1
194 1 /* [01] */
197 1 {
199 2 i = 0;
200 2 while (i < n)
201 2 {
+ + +
“Nada disso é tudo,
Tudo isso é fundamental.”
[H Gessiger, Engenheiros do Hawaii]
Christian Becker Bueno de Abreu
cbecker@metrosp.com.br

11SMTF050922T03

Recommended

Recommended

More Related Content

What's hot

What's hot (11)

Viewers also liked

Viewers also liked (20)

Similar to 11SMTF050922T03

Similar to 11SMTF050922T03 (20)

11SMTF050922T03