Добавил:
Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
I&C Safety Guide DRAFT 20110803.doc
Скачиваний:
13
Добавлен:
01.02.2015
Размер:
720.38 Кб
Скачать

10.4. Development of software for systems should follow a previously defined life cycle, be duly documented and include thorough verification and validation. (See Chapter 6.)

10.5. Software requirements, design description, and code should be unambiguous, complete, consistent, well-structured, readable, understandable to their target audience (e.g., domain experts, safety engineers, software designers), verifiable, maintainable and documented.

SOFTWARE REQUIREMENTS

10.6. All software necessary to satisfy the I&C system requirements, including reused or automatically generated code, should have documented requirements in appropriate form complying with the recommendations of this chapter.

10.7. Software requirements should define what the software must do within the context of the entire application, and how the software will interact with other components of the system.

10.8. Software requirements should be established using a predetermined combination of techniques commensurate with the system’s importance to safety, which might include specification languages with well-defined syntax and semantics, models, analysis, and review.

10.9. The origin of every software requirement should be documented sufficiently to facilitate verification, traceability to higher-level documents and a demonstration that all relevant requirements have been addressed.

10.10. Software requirement should originate from the relevant processes of I&C life cycle and from processes that interface with the I&C life cycle, e.g., human factors engineering and cyber security activities. See Fig. 2.

10.11. Consideration should be given to potential failure conditions, operation modes, safety monitoring, self-supervision, failure detection, safe conditions to be attained in the event of a detected but unrecoverable failure, other fail safe behaviour, and input and output relationships relevant to safety. Resultant safety requirements should be identified as such.

10.12. The software requirements should include the necessary level of reliability and availability to be achieved. Any supporting software requirements necessary to ensure that this is achieved should also be defined.

10.13. The necessary level of reliability and availability might be defined quantitatively, or qualitatively for example in terms of the supporting software requirements referred to above and/or development processes (e.g., standards compliance).

10.14. Any software reliability model used for licensing should be justified.

10.15. The software requirements should include minimum precision, numerical accuracy, a description of the interfaces (e.g., between the software and the operator, sensors and actuators, computer hardware and other software, and systems), independence of execution threads, self-supervision, timing performance (including fault detection and recovery times) and security (such as validity checks and access privileges).

10.16. As far as possible, the software requirements should be written in terms of what needs to be achieved rather than how they are to be designed and implemented.

10.17. Necessary design constraints should be documented, justified and traceable.

10.18. The requirements specification should allow for the capabilities of the computers, tools and similar existing systems to ensure that the software requirements are feasible.

10.19. Software requirements documentation may include additional information as applicable to its target audience, e.g., background for specific requirements, risk considerations, recommendations for the design of functions or safety features.

10.20. A requirements tracking system should be used so that the software requirements can be traced through the design, implementation, integration, and validation stages of the development project.

SOFTWARE DESIGN

10.21. The software design should be established using a predetermined combination of techniques commensurate with the system’s importance to safety, which might include descriptions, logic diagrams and graphical representations with well defined syntax and semantics, models, analysis and review.

10.22. The software design for systems other than safety systems might for example be a proprietary standard framework used to operate code formed by software tools using application specific logic diagrams, or graphical representations, with configuration information, where this provides sufficient rigour.

10.23. The software design should demonstrably address all software requirements and the system hazards identified in previous analyses.

10.24. Design elements should be identified to a level sufficient to facilitate traceability.

10.25. The software design of safety system software should maximise simplicity at all levels, including overall architecture, external interfaces, internal interfaces between modules, and detailed design.

10.26. Simplicity in design is a key means for achieving and demonstrating safety, but will always involve trade-offs, for example with functionality, flexibility and cost. Whereas the recommendation of paragraph 10.25 applies strictly to safety systems, the balance will be affected, and hence complexity may increase, as the importance to safety reduces.

10.27. The software design architecture should be structured to allow for future modification, maintenance and upgrades, for example to ensure that an expected change is isolated within a minimum number of modules.

10.28. The software architecture should be hierarchical to provide levels of abstraction.

10.29. Use of information hiding where possible is encouraged to enable piecewise review and verification and to aid modification.

10.30. The software design should include the interfaces between the software and its external environment and the detailed design of all software modules.

10.31. The module description should completely define its function, its interface with other modules and the context of its function in the overall software.

10.32. Module interfaces should be consistent. In particular, both sides of each interface between modules should match, and there should be, as far as possible, a consistent partial ordering and use of variable names between module input and output interfaces.

10.33. If the system includes multiple processors and the software is distributed among them, the software design should include which software process runs on which processor and where data and displays are located.

10.34. The software design should ensure predictable and deterministic operation (including in terms of the functional and timing response to particular inputs), see paragraph 8.62.

10.35. Communication protocols should be deterministic and should not depend on the correct operation of external systems (see paragraph 8.75).

10.36. As the design is refined, the need for additional fault detection and self-supervision features should be considered and be included in the software design. See paragraphs 8.70-8.74.

10.37. On failure detection, appropriate action should be taken to meet the software requirements (see paragraph 10.11), in terms of recovery, halting procedures, and error messages and logs, to ensure that the system is maintained in a safe condition.

10.38. The software design documentation should include implementation constraints.

10.39. Implementation constraints include any need to ensure diversity, and the attributes of the programming languages, compilers, subroutine libraries and other supporting tools.

10.40. These constraints should be justified or be traceable to higher-level requirements or constraints.

10.41. The software design architecture should account for constraints on modules and interfaces that might result from the decision to use diversity.

SOFTWARE IMPLEMENTATION

10.42. The softwae implementation should be established using a predetermined combination of techniques commensurate with the system’s importance to safety, covering languages, tools, coding practices, analysis, review and testing (see also section [software verification and analysis]).

10.43. The software implementation should demonstrably address all software requirements and the software design.

10.44. The software implementation should maximise simplicity and ease of understanding, with future readability and maintainability taking precedence over ease of programming.

10.45. All code subject to human inspection should be adequately annotated.

10.46. The documentation of safety systems should include source and executable code listings, the results of unit and module interface tests, and sufficient contextual information to verify the code’s correctness with respect to its specification.

10.47. For safety systems, access to all parts of the executable code (including run time support code and fault supervision functions) is necessary to enable the testing guidance of this Safety Guide to be met.

10.48. For systems other than safety systems, the appropriate documentation will depend on the implementation platform, but might for example include all special code inserts, and a description of all functions (provided in the form of logic diagrams or graphical representations), together with all configuration information necessary to define the application fully.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]