metanorma-iso 2.0.1 → 2.0.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (13) hide show
  1. checksums.yaml +4 -4
  2. data/lib/isodoc/iso/html/style-human.css +16 -15
  3. data/lib/isodoc/iso/html/style-human.scss +3 -2
  4. data/lib/isodoc/iso/html/style-iso.css +18 -17
  5. data/lib/isodoc/iso/html/style-iso.scss +3 -2
  6. data/lib/isodoc/iso/iso.amendment.xsl +258 -82
  7. data/lib/isodoc/iso/iso.international-standard.xsl +258 -82
  8. data/lib/metanorma/iso/biblio.rng +2 -2
  9. data/lib/metanorma/iso/isodoc.rng +69 -1
  10. data/lib/metanorma/iso/version.rb +1 -1
  11. data/spec/metanorma/base_spec.rb +138 -127
  12. data/spec/vcr_cassettes/docrels.yml +21 -216
  13. metadata +2 -2
data/spec/vcr_cassettes/docrels.yml CHANGED
@@ -5,7 +5,7 @@ http_interactions:
5
5
  uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
6
6
  body:
7
7
  encoding: UTF-8
8
- string: '{"query":"ISO 123","hitsPerPage":100,"filters":"category:standard"}'
8
+ string: '{"query":"ISO 125","hitsPerPage":100,"filters":"category:standard"}'
9
9
  headers:
10
10
  User-Agent:
11
11
  - Algolia for Ruby (2.1.1), Ruby (3.0.3)
@@ -31,7 +31,7 @@ http_interactions:
31
31
  Server:
32
32
  - nginx
33
33
  Date:
34
- - Mon, 17 Jan 2022 09:56:48 GMT
34
+ - Sat, 22 Jan 2022 10:39:20 GMT
35
35
  Content-Type:
36
36
  - application/json; charset=UTF-8
37
37
  Transfer-Encoding:
@@ -39,7 +39,7 @@ http_interactions:
39
39
  Connection:
40
40
  - keep-alive
41
41
  X-Alg-Pt:
42
- - '3'
42
+ - '5'
43
43
  Accept-Encoding:
44
44
  - deflate, gzip
45
45
  Cache-Control:
@@ -57,12 +57,12 @@ http_interactions:
57
57
  body:
58
58
  encoding: ASCII-8BIT
59
59
  string: !binary |-
60
- {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/32/23281","uuid":"04723ea9-847a-4b2b-a32b-0d8f7d76903b","title":"ISO 123:2001 Rubber latex — Sampling","status":"Published","year":2021,"order":11,"text":"This International Standard specifies procedures for sampling natural rubber latex concentrate and for sampling synthetic rubber latices and artificial latices. It is also suitable for sampling rubber latex contained in drums, tank cars or tanks. The procedures may also be used for sampling plastics dispersions. ","objectID":"23281_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>:2001 Rubber latex — Sampling","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This International Standard specifies procedures for sampling natural rubber latex concentrate and for sampling synthetic rubber latices and artificial latices. It is also suitable for sampling rubber latex contained in drums, tank cars or tanks. The procedures may also be used for sampling plastics dispersions. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3926","uuid":"315a9a02-edd8-4919-9fc1-2dbaea82b24d","title":"ISO 123:1985 Rubber latex — Sampling","status":"Withdrawn","year":2001,"order":100,"objectID":"3926_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>:1985 Rubber latex — Sampling","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3925","uuid":"738cf8f2-6181-4dcd-a079-db69ee051821","title":"ISO 123:1974 Rubber latex — Sampling","status":"Withdrawn","year":1985,"order":100,"objectID":"3925_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>:1974 Rubber latex — Sampling","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/74/77439","uuid":"5dc33c0d-611a-4931-8a7f-a8ef8d3c115e","title":"ISO 12345:2021 Diesel engines — Cleanliness assessment of fuel injection equipment","status":"Published","year":2021,"order":11,"text":"This document specifies cleanliness assessment procedures for evaluating the amount of debris found within the clean side of diesel fuel injection assemblies, which could lead to a reduction in the system’s operational effectiveness. While other International Standards, e.g. ISO 16232, relate to cleanliness of components used in road vehicle fluid circuits, this document is focused on diesel fuel injection assemblies as supplied to diesel engine manufacturers or the service market. ","objectID":"77439_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>45:2021 Diesel engines — Cleanliness assessment of fuel injection equipment","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This document specifies cleanliness assessment procedures for evaluating the amount of debris found within the clean side of diesel fuel injection assemblies, which could lead to a reduction in the system’s operational effectiveness. While other International Standards, e.g. <em>ISO</em> 16232, relate to cleanliness of components used in road vehicle fluid circuits, this document is focused on diesel fuel injection assemblies as supplied to diesel engine manufacturers or the service market. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51391","uuid":"d1b37293-9f4e-4a99-b0eb-b873ae209b9f","title":"ISO 12344:2010 Thermal insulating products for building applications — Determination of bending behaviour","status":"Published","year":2021,"order":11,"text":"ISO 12344:2010 specifies the equipment and procedures for determining the bending behaviour of full-size products (Method A) and test specimens (Method B) under the action of three-point loading. It is applicable to thermal insulating products for building applications. The test is designed to determine the bending strength of products and their deflection at a given load. The method can be used to determine the resistance of the product to bending stresses during transport and application. ","objectID":"51391_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>44:2010 Thermal insulating products for building applications — Determination of bending behaviour","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>44:2010 specifies the equipment and procedures for determining the bending behaviour of full-size products (Method A) and test specimens (Method B) under the action of three-point loading. It is applicable to thermal insulating products for building applications. The test is designed to determine the bending strength of products and their deflection at a given load. The method can be used to determine the resistance of the product to bending stresses during transport and application. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/40/34026","uuid":"6f6a9d88-ede5-4e63-a3ad-b927c3017c74","title":"ISO 12357-2:2007 Commercial road vehicles — Drawbar couplings and eyes for rigid drawbars — Part 2: Strength tests for special applications","status":"Published","year":2021,"order":11,"text":"ISO 12357-2:2007 lays down test conditions and strength requirements to be met by: drawbar couplings and corresponding drawbar eyes for rigid drawbars which are provided for use on rigid drawbar trailers with a maximum design total mass exceeding 3,5 tonnes and a vertical static load exceeding 10 % of their design total mass, and/or a vertical static load greater than 1 000 kg and up to 2 000 kg; drawbar couplings and corresponding drawbar eyes for use on vehicle transport combinations, provided for a technical mass exceeding 3,5 tonnes. ","objectID":"34026_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>57-2:2007 Commercial road vehicles — Drawbar couplings and eyes for rigid drawbars — Part 2: Strength tests for special applications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>57-2:2007 lays down test conditions and strength requirements to be met by: drawbar couplings and corresponding drawbar eyes for rigid drawbars which are provided for use on rigid drawbar trailers with a maximum design total mass exceeding 3,5 tonnes and a vertical static load exceeding 10 % of their design total mass, and/or a vertical static load greater than 1 000 kg and up to 2 000 kg; drawbar couplings and corresponding drawbar eyes for use on vehicle transport combinations, provided for a technical mass exceeding 3,5 tonnes. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/12/1212","uuid":"7fa3ccb6-5565-45a2-b034-f769a71f1a89","title":"ISO 12357-1:1999 Commercial road vehicles — Drawbar couplings and eyes for rigid drawbars — Part 1: Strength tests for general cargo centre-axle trailers","status":"Published","year":2021,"order":11,"text":"This International Standard specifies the test conditions and strength requirements to be met by drawbar couplings (see ISO 3584) and the corresponding drawbar eyes (see ISO 1102 and ISO 8755) for rigid drawbars, which are provided for use with centre-axle trailers with a technical maximum mass C exceeding 3,5 t (tonnes). ","objectID":"1212_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>57-1:1999 Commercial road vehicles — Drawbar couplings and eyes for rigid drawbars — Part 1: Strength tests for general cargo centre-axle trailers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This International Standard specifies the test conditions and strength requirements to be met by drawbar couplings (see <em>ISO</em> 3584) and the corresponding drawbar eyes (see <em>ISO</em> 1102 and <em>ISO</em> 8755) for rigid drawbars, which are provided for use with centre-axle trailers with a technical maximum mass C exceeding 3,5 t (tonnes). ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/11/1194","uuid":"e9177aa9-0d15-40f1-b117-85a89ecccf6f","title":"ISO 12366:2001 Two-wheeled mopeds — Antilock braking systems (ABS) — Tests and measurement methods","status":"Published","year":2021,"order":11,"text":"This International Standard specifies tests and measurement methods for solo mopeds (defined in ISO 3833) equipped with one or more antilock, and one or more independent, braking systems. Its purpose is to establish uniform worldwide test procedures for such systems. This International Standard sets out procedures for the following types of straight-line braking tests:  utilization-of-adhesion test;  wheel-lock check test;  tests with ABS failed;  complementary tests that could assist in the assessment and development of braking systems. NOTE Reference is made in this International Standard to L-category vehicles, generally referring to solo mopeds (L1), drawn from Regulation No. 78 and the Consolidated Resolution on the Construction of Vehicles (R.E.3) of the United Nations Economic Commission for Europe (UN-ECE). The values given in this International Standard enclosed by square brackets are from the same regulation (02 series of amendments), and are included for information. ","objectID":"1194_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>66:2001 Two-wheeled mopeds — Antilock braking systems (ABS) — Tests and measurement methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This International Standard specifies tests and measurement methods for solo mopeds (defined in <em>ISO</em> 3833) equipped with one or more antilock, and one or more independent, braking systems. Its purpose is to establish uniform worldwide test procedures for such systems. This International Standard sets out procedures for the following types of straight-line braking tests:  utilization-of-adhesion test;  wheel-lock check test;  tests with ABS failed;  complementary tests that could assist in the assessment and development of braking systems. NOTE Reference is made in this International Standard to L-category vehicles, generally referring to solo mopeds (L1), drawn from Regulation No. 78 and the Consolidated Resolution on the Construction of Vehicles (R.E.3) of the United Nations Economic Commission for Europe (UN-ECE). The values given in this International Standard enclosed by square brackets are from the same regulation (02 series of amendments), and are included for information. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/80/68075","uuid":"ef203529-66c8-4bcf-b0a1-d0cb94be7db3","title":"ISO 12353-1:2020 Road vehicles — Traffic accident analysis — Part 1: Vocabulary","status":"Published","year":2020,"order":11,"text":"This document establishes a vocabulary relating to the investigation and analysis of road traffic accidents and to the application of accident data. It also lists other, commonly used terms in the domain. NOTE    Additional terms and definitions, related to configuration aspects of road vehicle collisions, can be found in ISO 6813. ","objectID":"68075_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>53-1:2020 Road vehicles — Traffic accident analysis — Part 1: Vocabulary","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This document establishes a vocabulary relating to the investigation and analysis of road traffic accidents and to the application of accident data. It also lists other, commonly used terms in the domain. NOTE    Additional terms and definitions, related to configuration aspects of road vehicle collisions, can be found in <em>ISO</em> 6813. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/92/59289","uuid":"4b6d43ef-d510-4819-a570-c38f13a13f0d","title":"ISO 12312-2:2015 Eye and face protection — Sunglasses and related eyewear — Part 2: Filters for direct observation of the sun","status":"Published","year":2020,"order":11,"text":"ISO 12312-2:2015 applies to all afocal (plano power) products intended for direct observation of the sun, such as solar eclipse viewing. ISO 12312-2:2015 does not apply to the following: a)    afocal (plano power) sunglasses and clip-ons for general use intended for protection against solar radiation; b)    eyewear for protection against radiation from artificial light sources, such as those used in solaria; c)    eye protectors specifically intended for sports (e.g. ski goggles or other types); d)    sunglasses that have been medically prescribed for attenuating solar radiation; e)    prescription sunglass lenses. ","objectID":"59289_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>12-2:2015 Eye and face protection — Sunglasses and related eyewear — Part 2: Filters for direct observation of the sun","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>12-2:2015 applies to all afocal (plano power) products intended for direct observation of the sun, such as solar eclipse viewing. <em>ISO</em> <em>123</em>12-2:2015 does not apply to the following: a)    afocal (plano power) sunglasses and clip-ons for general use intended for protection against solar radiation; b)    eyewear for protection against radiation from artificial light sources, such as those used in solaria; c)    eye protectors specifically intended for sports (e.g. ski goggles or other types); d)    sunglasses that have been medically prescribed for attenuating solar radiation; e)    prescription sunglass lenses. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/35/43503","uuid":"30511bd8-a74a-433a-9d5a-5551ff8d8570","title":"ISO 1230:2007 Photography — Determination of flash guide numbers for electronic flash equipment","status":"Published","year":2020,"order":11,"text":"ISO 1230:2007 specifies the definition and determination of the ISO guide number of electronic flash equipment. It does not specify the definitions and measuring methods for the light output of electronic flash equipment, which are specified in ISO 2827. ","objectID":"43503_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>0:2007 Photography — Determination of flash guide numbers for electronic flash equipment","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>0:2007 specifies the definition and determination of the <em>ISO</em> guide number of electronic flash equipment. It does not specify the definitions and measuring methods for the light output of electronic flash equipment, which are specified in <em>ISO</em> 2827. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/78/37827","uuid":"9ff519c3-1956-4997-91d9-2224cbd7a09a","title":"ISO 12319:2006 Aerospace — 'P' (loop style) clamps — Procurement specification","status":"Published","year":2020,"order":11,"text":"ISO 12319:2006 specifies the requirements for the procurement and quality assurance of 'P' (loop style) clamps used in the installation of aerospace fluid systems. ","objectID":"37827_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>19:2006 Aerospace — 'P' (loop style) clamps — Procurement specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>19:2006 specifies the requirements for the procurement and quality assurance of 'P' (loop style) clamps used in the installation of aerospace fluid systems. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/43/74356","uuid":"fd2737c7-904b-4bf5-98e6-f9622629dd21","title":"ISO 12381:2019 Health informatics — Explicit time-related expressions for healthcare-specific problems","status":"Published","year":2019,"order":11,"text":"This document specifies a set of representational primitives and semantic relations needed for an unambiguous representation of explicit time-related expressions in health informatics. This document does not introduce or force a specific ontology of time, nor does it force the use of a fixed representation scheme for such an ontology. Rather this document provides a set of principles for syntactic and semantic representation that allow the comparability of specific ontologies on time, and the exchange of time-related information that is expressed explicitly. This document applies to both the representation of actual phenomena occurring in the real world (e.g. registrations in medical records) and to the description of concepts (e.g. medical knowledge bases). This document is applicable to a)    developers of medical information systems where there might be a need for explicit time-related concepts for internal organization (e.g. temporal data bases, temporal reasoning systems), b)    information modellers or knowledge engineers building models for the systems mentioned in a), c)    experts involved in the development of semantic standards on precise subdomains in health care where time-related information needs to be covered, (e.g. in the study of pathochronology, i.e. the discipline dealing with the time course of specific diseases), and d)    developers of interchange formats for messages in which time-related information is embedded. This document is not intended to be used directly for —          representing what is true in time, —          reasoning about time, or —          representation of metrological time. ","objectID":"74356_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>81:2019 Health informatics — Explicit time-related expressions for healthcare-specific problems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This document specifies a set of representational primitives and semantic relations needed for an unambiguous representation of explicit time-related expressions in health informatics. This document does not introduce or force a specific ontology of time, nor does it force the use of a fixed representation scheme for such an ontology. Rather this document provides a set of principles for syntactic and semantic representation that allow the comparability of specific ontologies on time, and the exchange of time-related information that is expressed explicitly. This document applies to both the representation of actual phenomena occurring in the real world (e.g. registrations in medical records) and to the description of concepts (e.g. medical knowledge bases). This document is applicable to a)    developers of medical information systems where there might be a need for explicit time-related concepts for internal organization (e.g. temporal data bases, temporal reasoning systems), b)    information modellers or knowledge engineers building models for the systems mentioned in a), c)    experts involved in the development of semantic standards on precise subdomains in health care where time-related information needs to be covered, (e.g. in the study of pathochronology, i.e. the discipline dealing with the time course of specific diseases), and d)    developers of interchange formats for messages in which time-related information is embedded. This document is not intended to be used directly for —          representing what is true in time, —          reasoning about time, or —          representation of metrological time. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/59/25945","uuid":"fe82eb92-76f2-4eab-b8f1-b6b12a0ed1c9","title":"ISO 12353-2:2003 Road vehicles — Traffic accident analysis — Part 2: Guidelines for the use of impact severity measures","status":"Published","year":2019,"order":11,"text":"ISO 12353-2:2003 describes the suitability of various measures for the determination of impact severity in road vehicle accidents. It also summarizes the main characteristics of the methods used for determining impact severity. ","objectID":"25945_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>53-2:2003 Road vehicles — Traffic accident analysis — Part 2: Guidelines for the use of impact severity measures","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>53-2:2003 describes the suitability of various measures for the determination of impact severity in road vehicle accidents. It also summarizes the main characteristics of the methods used for determining impact severity. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/14/1473","uuid":"90f13b11-6c1d-415b-8a96-8e13a61c49ec","title":"ISO 12374:1995 Agricultural irrigation — Wiring and equipment for electrically driven or controlled irrigation machines","status":"Published","year":2019,"order":11,"text":"Provides detailed information for the application of electrical apparatus to electrically driven or controlled agricultural irrigation machines. Covers all electrical equipment necessary from the point of connection of electric power to the machine.Applies to electrical equipment for use on circuits operating at voltages from 30 V to 600 V. Intended to improve the degree of personal safety in operation and application of products and materials. ","objectID":"1473_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>74:1995 Agricultural irrigation — Wiring and equipment for electrically driven or controlled irrigation machines","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Provides detailed information for the application of electrical apparatus to electrically driven or controlled agricultural irrigation machines. Covers all electrical equipment necessary from the point of connection of electric power to the machine.Applies to electrical equipment for use on circuits operating at voltages from 30 V to 600 V. Intended to improve the degree of personal safety in operation and application of products and materials. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5854","uuid":"58691098-05e3-45db-9520-6a6eaba11b23","title":"ISO 1237:1981 Mustard seed — Specification","status":"Published","year":2018,"order":11,"text":"Establishes the requirements for this product. Describes sampling, methods of test, packing and marking. Annex A covers the determination of loss in mass at 103 degrees centigrade, Annex B the determination of allyl isothiocyanate, Annex C the determination of p-hydroxybenzyl isothiocyanate by means of the colorimetric method, Annex D the determination of p-hydroxybenzyl isothiocyanate by means of the argentimetric method and Annex E includes recommendations concerning storage and transport conditions. ","objectID":"5854_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>7:1981 Mustard seed — Specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Establishes the requirements for this product. Describes sampling, methods of test, packing and marking. Annex A covers the determination of loss in mass at 103 degrees centigrade, Annex B the determination of allyl isothiocyanate, Annex C the determination of p-hydroxybenzyl isothiocyanate by means of the colorimetric method, Annex D the determination of p-hydroxybenzyl isothiocyanate by means of the argentimetric method and Annex E includes recommendations concerning storage and transport conditions. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51389","uuid":"e5b1e088-6b1b-4eb8-ab46-1fdbb56a724f","title":"ISO 12315:2010 Aluminium oxide primarily used for production of aluminium — Method for calculating the Al2O3 content of smelter-grade alumina","status":"Published","year":2018,"order":11,"text":"ISO 12315:2010 describes methods for calculating and reporting the Al2O3 content of smelter-grade alumina, on either a dry or ignited basis, from the results of the determinations in accordance with ISO 806 and AS 2879.7. ","objectID":"51389_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>15:2010 Aluminium oxide primarily used for production of aluminium — Method for calculating the Al2O3 content of smelter-grade alumina","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>15:2010 describes methods for calculating and reporting the Al2O3 content of smelter-grade alumina, on either a dry or ignited basis, from the results of the determinations in accordance with <em>ISO</em> 806 and AS 2879.7. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51351","uuid":"d75b38e8-3b12-4285-b559-808d5a664485","title":"ISO 12312-1:2013 Eye and face protection — Sunglasses and related eyewear — Part 1: Sunglasses for general use","status":"Published","year":2018,"order":11,"text":"ISO 12312-1:2012 is applicable to all afocal (plano power) sunglasses and clip-ons for general use, including road use and driving, intended for protection against solar radiation. ","objectID":"51351_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>12-1:2013 Eye and face protection — Sunglasses and related eyewear — Part 1: Sunglasses for general use","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>12-1:2012 is applicable to all afocal (plano power) sunglasses and clip-ons for general use, including road use and driving, intended for protection against solar radiation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51350","uuid":"f147180b-c24f-46c1-9615-1e920d3af0db","title":"ISO 12311:2013 Personal protective equipment — Test methods for sunglasses and related eyewear","status":"Published","year":2018,"order":11,"text":"ISO 12311:2012 specifies reference test methods for determining the properties of sunglasses given in ISO 12312 (all parts). It is applicable to all sunglasses and related eyewear. Other test methods may be used if shown to be equivalent. ","objectID":"51350_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>11:2013 Personal protective equipment — Test methods for sunglasses and related eyewear","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>11:2012 specifies reference test methods for determining the properties of sunglasses given in <em>ISO</em> <em>123</em>12 (all parts). It is applicable to all sunglasses and related eyewear. Other test methods may be used if shown to be equivalent. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/65/36511","uuid":"59319e00-dc55-4b26-b5fc-9753a13219e9","title":"ISO 12301:2007 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics","status":"Published","year":2018,"order":11,"text":"ISO 12301:2007 specifies quality control techniques and inspection of the geometrical and material quality characteristics of the following types of plain bearings: thin-walled half-bearings with or without flange, as specified in ISO 3548; metallic thick-walled half-bearings (with and without flange) that are manufactured as halves but that are necessarily interchangeable and have the ratio s 3 : D o > 0,11; wrapped bushes, as specified in ISO 3547; unsplit metallic bushes (with and without flange) made from solid and multilayer materials and with outside diameters up to 230 mm; solid polymer bushes (with and without flange) with inside diameters up to 200 mm; ring-type thrust washers and pressed bimetallic half-thrust washers, as specified in ISO 6525 and ISO 6526, respectively; and bushes made from sintered material, as specified in ISO 2795. ","objectID":"36511_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>01:2007 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>01:2007 specifies quality control techniques and inspection of the geometrical and material quality characteristics of the following types of plain bearings: thin-walled half-bearings with or without flange, as specified in <em>ISO</em> 3548; metallic thick-walled half-bearings (with and without flange) that are manufactured as halves but that are necessarily interchangeable and have the ratio s 3 : D o > 0,11; wrapped bushes, as specified in <em>ISO</em> 3547; unsplit metallic bushes (with and without flange) made from solid and multilayer materials and with outside diameters up to 230 mm; solid polymer bushes (with and without flange) with inside diameters up to 200 mm; ring-type thrust washers and pressed bimetallic half-thrust washers, as specified in <em>ISO</em> 6525 and <em>ISO</em> 6526, respectively; and bushes made from sintered material, as specified in <em>ISO</em> 2795. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/00/20000","uuid":"5ad65cfd-d409-472e-aa48-b908cad0fe87","title":"ISO 1234:1997 Split pins","status":"Published","year":2018,"order":11,"objectID":"20000_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>4:1997 Split pins","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/02/70248","uuid":"0ac30206-4c37-481a-8467-b9928f134098","title":"ISO 12354-4:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 4: Transmission of indoor sound to the outside","status":"Published","year":2017,"order":11,"text":"ISO 12354-4:2017 specifies a calculation model to estimate the sound power level radiated by the envelope of a building due to airborne sound inside that building, primarily by means of measured sound pressure levels inside the building and measured data which characterize the sound transmission by the relevant elements and openings in the building envelope. These sound power levels, together with those of other sound sources in or in front of the building envelope, form the basis for the calculation of the sound pressure level at a chosen distance from a building as a measure for the acoustic performance of buildings. The prediction of the inside sound pressure level from knowledge of the indoor sound sources is outside the scope of this document. The prediction of the outdoor sound propagation is outside the scope of this document. NOTE          For simple propagation conditions an approach is given for the estimation of the sound pressure level in Annex E. ISO 12354-4:2017 describes the principles of the calculation model, lists the relevant quantities and defines its applications and restrictions. ","objectID":"70248_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>54-4:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 4: Transmission of indoor sound to the outside","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>54-4:2017 specifies a calculation model to estimate the sound power level radiated by the envelope of a building due to airborne sound inside that building, primarily by means of measured sound pressure levels inside the building and measured data which characterize the sound transmission by the relevant elements and openings in the building envelope. These sound power levels, together with those of other sound sources in or in front of the building envelope, form the basis for the calculation of the sound pressure level at a chosen distance from a building as a measure for the acoustic performance of buildings. The prediction of the inside sound pressure level from knowledge of the indoor sound sources is outside the scope of this document. The prediction of the outdoor sound propagation is outside the scope of this document. NOTE          For simple propagation conditions an approach is given for the estimation of the sound pressure level in Annex E. <em>ISO</em> <em>123</em>54-4:2017 describes the principles of the calculation model, lists the relevant quantities and defines its applications and restrictions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/02/70244","uuid":"8ed03afb-aeb7-4003-800b-fca5428d9129","title":"ISO 12354-3:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 3: Airborne sound insulation against outdoor sound","status":"Published","year":2017,"order":11,"text":"ISO 12354-3:2017 specifies a calculation model to estimate the sound insulation or the sound pressure level difference of a façade or other external surface of a building. The calculation is based on the sound reduction index of the different elements from which the façade is constructed and it includes direct and flanking transmission. The calculation gives results which correspond approximately to the results from field measurements in accordance with ISO 16283‑3. Calculations can be carried out for frequency bands or for single number ratings. The calculation results can also be used for calculating the indoor sound pressure level due to for instance road traffic (see Annex E). ISO 12354-3:2017 describes the principles of the calculation model, lists the relevant quantities and defines its applications and restrictions. ","objectID":"70244_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>54-3:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 3: Airborne sound insulation against outdoor sound","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>54-3:2017 specifies a calculation model to estimate the sound insulation or the sound pressure level difference of a façade or other external surface of a building. The calculation is based on the sound reduction index of the different elements from which the façade is constructed and it includes direct and flanking transmission. The calculation gives results which correspond approximately to the results from field measurements in accordance with <em>ISO</em> 16283‑3. Calculations can be carried out for frequency bands or for single number ratings. The calculation results can also be used for calculating the indoor sound pressure level due to for instance road traffic (see Annex E). <em>ISO</em> <em>123</em>54-3:2017 describes the principles of the calculation model, lists the relevant quantities and defines its applications and restrictions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/02/70243","uuid":"a1882379-fd3f-4936-bd5f-832a6a2818cb","title":"ISO 12354-2:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 2: Impact sound insulation between rooms","status":"Published","year":2017,"order":11,"text":"ISO 12354-2:2017 specifies calculation models designed to estimate the impact sound insulation between rooms in buildings, primarily using measured data which characterize direct or indirect flanking transmission by the participating building elements and theoretically-derived methods of sound propagation in structural elements. A detailed model is described for calculation in frequency bands, in the frequency range 1/3 octave 100 Hz to 3150 Hz in accordance with ISO 717‑1, possibly extended down to 1/3 octave 50 Hz if element data and junction data are available (see Annex E); the single number rating of buildings can be determined from the calculation results. A simplified model with a restricted field of application is deduced from this, calculating directly the single number rating, using the single number ratings of the elements; the uncertainty on the apparent impact sound pressure level calculated using the simplified model can be determined according to the method described in ISO 12354‑1:2017, Annex K (see Clause 5). ISO 12354-2:2017 describes the principles of the calculation scheme, lists the relevant quantities and defines its applications and restrictions. ","objectID":"70243_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>54-2:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 2: Impact sound insulation between rooms","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>54-2:2017 specifies calculation models designed to estimate the impact sound insulation between rooms in buildings, primarily using measured data which characterize direct or indirect flanking transmission by the participating building elements and theoretically-derived methods of sound propagation in structural elements. A detailed model is described for calculation in frequency bands, in the frequency range 1/3 octave 100 Hz to 3150 Hz in accordance with <em>ISO</em> 717‑1, possibly extended down to 1/3 octave 50 Hz if element data and junction data are available (see Annex E); the single number rating of buildings can be determined from the calculation results. A simplified model with a restricted field of application is deduced from this, calculating directly the single number rating, using the single number ratings of the elements; the uncertainty on the apparent impact sound pressure level calculated using the simplified model can be determined according to the method described in <em>ISO</em> <em>123</em>54‑1:2017, Annex K (see Clause 5). <em>ISO</em> <em>123</em>54-2:2017 describes the principles of the calculation scheme, lists the relevant quantities and defines its applications and restrictions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/02/70242","uuid":"675039ce-342b-471c-94eb-bb8d6ee6e156","title":"ISO 12354-1:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 1: Airborne sound insulation between rooms","status":"Published","year":2017,"order":11,"text":"ISO 12354-1:2017 specifies calculation models designed to estimate the airborne sound insulation between adjacent rooms in buildings, primarily using measured data which characterize direct or indirect flanking transmission by the participating building elements, and theoretically-derived methods of sound propagation in structural elements. A detailed model is described for calculation in frequency bands, in the frequency range 1/3 octave 100 Hz to 3 150 Hz in accordance with ISO 717‑1, possibly extended down to 1/3 octave 50 Hz if element data and junction data are available (see Annex I); the single number rating can be determined from the calculation results. A simplified model with a restricted field of application is deduced from this, calculating directly the single number rating, using the single number ratings of the elements; a method to determine uncertainty is proposed for the simplified model (see Annex K). ISO 12354-1:2017 describes the principles of the calculation scheme, lists the relevant quantities and defines its applications and restrictions. ","objectID":"70242_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>54-1:2017 Building acoustics — Estimation of acoustic performance of buildings from the performance of elements — Part 1: Airborne sound insulation between rooms","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>54-1:2017 specifies calculation models designed to estimate the airborne sound insulation between adjacent rooms in buildings, primarily using measured data which characterize direct or indirect flanking transmission by the participating building elements, and theoretically-derived methods of sound propagation in structural elements. A detailed model is described for calculation in frequency bands, in the frequency range 1/3 octave 100 Hz to 3 150 Hz in accordance with <em>ISO</em> 717‑1, possibly extended down to 1/3 octave 50 Hz if element data and junction data are available (see Annex I); the single number rating can be determined from the calculation results. A simplified model with a restricted field of application is deduced from this, calculating directly the single number rating, using the single number ratings of the elements; a method to determine uncertainty is proposed for the simplified model (see Annex K). <em>ISO</em> <em>123</em>54-1:2017 describes the principles of the calculation scheme, lists the relevant quantities and defines its applications and restrictions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/86/68625","uuid":"3a1b8b5d-2818-4e6c-a4cf-ab8930732c9c","title":"ISO 12308:2017 Plain bearings — Quality assurance of sample types — Definitions, applications and testing","status":"Published","year":2017,"order":11,"text":"ISO 12308:2017 defines the types of plain bearing samples exchanged between purchaser and manufacturer. In the field of internal combustion engines and other series production, it is necessary to work with different types of samples depending on the purpose. Types of samples are as follows. -      Samples used for tests and examinations which are carried out in the experimental stage and pilot lot stage. These include fitting samples, prototype samples and intermediate samples. -      Samples used to prove that the quality is in accordance with the quality requirements (dimensions, material and performance specification). These include initial samples and reference samples and, if necessary, intermediate samples. NOTE       See ISO 3534 (all parts) and ISO 9000 for further information. -      Samples which give selective information about particular quality characteristics of a plain bearing, relating to their conformity with the specifications. These involve reference and characteristic modification samples. ","objectID":"68625_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>08:2017 Plain bearings — Quality assurance of sample types — Definitions, applications and testing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>08:2017 defines the types of plain bearing samples exchanged between purchaser and manufacturer. In the field of internal combustion engines and other series production, it is necessary to work with different types of samples depending on the purpose. Types of samples are as follows. -      Samples used for tests and examinations which are carried out in the experimental stage and pilot lot stage. These include fitting samples, prototype samples and intermediate samples. -      Samples used to prove that the quality is in accordance with the quality requirements (dimensions, material and performance specification). These include initial samples and reference samples and, if necessary, intermediate samples. NOTE       See <em>ISO</em> 3534 (all parts) and <em>ISO</em> 9000 for further information. -      Samples which give selective information about particular quality characteristics of a plain bearing, relating to their conformity with the specifications. These involve reference and characteristic modification samples. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/86/68624","uuid":"689cd1fc-1084-49e7-80ed-82aa80e95aae","title":"ISO 12302:2017 Plain bearings — Quality characteristics — Statistical process control (SPC)","status":"Published","year":2017,"order":11,"text":"ISO 12302:2017 specifies for plain bearings (except thick-walled half-bearings) those quality characteristics in accordance with ISO 12301 which can be used to regulate and control a production process on the basis of statistical process control (SPC). It covers dimensional variables but does not take account of attributes. ","objectID":"68624_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>02:2017 Plain bearings — Quality characteristics — Statistical process control (SPC)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>02:2017 specifies for plain bearings (except thick-walled half-bearings) those quality characteristics in accordance with <em>ISO</em> <em>123</em>01 which can be used to regulate and control a production process on the basis of statistical process control (SPC). It covers dimensional variables but does not take account of attributes. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51395","uuid":"ec77add9-f625-48bd-8be9-d6a4790642f8","title":"ISO 12384:2010 Aerospace — Requirements for digital equipment for measurements of aircraft electrical power characteristics","status":"Published","year":2017,"order":11,"text":"ISO 12384:2010 specifies the requirements for digital measuring methods and digital measuring equipment for aircraft electrical power characteristics, including accuracy, algorithms and digital measuring equipment. The measuring equipment should be applied mainly for the use of laboratory or rig tests. ISO 12384:2010 can be applied to digital measuring equipment which is involved in the measurement of power electrical characteristics of the power supply system, power distributing systems and the utilization of equipment in aircrafts. ","objectID":"51395_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>84:2010 Aerospace — Requirements for digital equipment for measurements of aircraft electrical power characteristics","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>84:2010 specifies the requirements for digital measuring methods and digital measuring equipment for aircraft electrical power characteristics, including accuracy, algorithms and digital measuring equipment. The measuring equipment should be applied mainly for the use of laboratory or rig tests. <em>ISO</em> <em>123</em>84:2010 can be applied to digital measuring equipment which is involved in the measurement of power electrical characteristics of the power supply system, power distributing systems and the utilization of equipment in aircrafts. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/05/30571","uuid":"af63c3d4-5172-4997-8388-e85069c1c9d6","title":"ISO 12368:2001 Agricultural vehicles — Mechanical hook-type connections on towing vehicles — Test methods and requirements","status":"Published","year":2017,"order":11,"text":"This International Standard specifies a dynamic test method for mechanical hook-type connections and hook coupling devices, as well as a static test of their keeper plates. It is applicable to hooks meeting the requirements of ISO 6489-1 used on towing vehicles with an unladen mass of up to 10 t. Towing vehicles with a greater unladen mass are nevertheless treated as 10 t towing vehicles, especially with regard to their reference mass. ","objectID":"30571_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>68:2001 Agricultural vehicles — Mechanical hook-type connections on towing vehicles — Test methods and requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This International Standard specifies a dynamic test method for mechanical hook-type connections and hook coupling devices, as well as a static test of their keeper plates. It is applicable to hooks meeting the requirements of <em>ISO</em> 6489-1 used on towing vehicles with an unladen mass of up to 10 t. Towing vehicles with a greater unladen mass are nevertheless treated as 10 t towing vehicles, especially with regard to their reference mass. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/16/1680","uuid":"5371c655-c3f0-4b90-ad5f-e01eef36e63a","title":"ISO 12364:2001 Two-wheeled motorcycles — Antilock braking systems (ABS) — Tests and measurement methods","status":"Published","year":2017,"order":11,"text":"This International Standard specifies tests and measurement methods for solo motorcycles (defined in ISO 3833) equipped with one or more antilock, and one or more independent, braking systems. It sets out procedures for the following types of straight-line braking tests: utilization-of-adhesion test; wheel-lock check test; tests with ABS failed; complementary tests that could assist in the assessment and development of braking systems. ","objectID":"1680_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>64:2001 Two-wheeled motorcycles — Antilock braking systems (ABS) — Tests and measurement methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This International Standard specifies tests and measurement methods for solo motorcycles (defined in <em>ISO</em> 3833) equipped with one or more antilock, and one or more independent, braking systems. It sets out procedures for the following types of straight-line braking tests: utilization-of-adhesion test; wheel-lock check test; tests with ABS failed; complementary tests that could assist in the assessment and development of braking systems. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/71/67151","uuid":"dfc43ac1-c86a-48d1-97e6-782b297abeba","title":"ISO 12312-1:2013/Amd 1:2015 Eye and face protection — Sunglasses and related eyewear — Part 1: Sunglasses for general use — Amendment 1","status":"Published","year":2015,"order":11,"objectID":"67151_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>12-1:2013/Amd 1:2015 Eye and face protection — Sunglasses and related eyewear — Part 1: Sunglasses for general use — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/58/45803","uuid":"58e489ad-4614-445a-b1a8-e8074c2d56c6","title":"ISO 12357-1:1999/Cor 1:2007 Commercial road vehicles — Drawbar couplings and eyes for rigid drawbars — Part 1: Strength tests for general cargo centre-axle trailers — Technical Corrigendum 1","status":"Published","year":2007,"order":11,"objectID":"45803_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>57-1:1999/Cor 1:2007 Commercial road vehicles — Drawbar couplings and eyes for rigid drawbars — Part 1: Strength tests for general cargo centre-axle trailers — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/29/52966","uuid":"47a1692a-552f-49fa-88b8-d930bdf40b17","title":"ISO 12345:2013 Diesel engines — Cleanliness assessment of fuel injection equipment","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12345:2013 specifies cleanliness assessment procedures for evaluating the amount of debris found within the clean side of diesel fuel injection assemblies, which could lead to a reduction in the system's operational effectiveness. While other International Standards, e.g. the ISO 16232 series, relate to cleanliness of components used in road vehicle fluid circuits, ISO 12345:2013 is focused on diesel fuel injection assemblies as supplied to diesel engine manufacturers or the service market. ","objectID":"52966_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>45:2013 Diesel engines — Cleanliness assessment of fuel injection equipment","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>45:2013 specifies cleanliness assessment procedures for evaluating the amount of debris found within the clean side of diesel fuel injection assemblies, which could lead to a reduction in the system's operational effectiveness. While other International Standards, e.g. the <em>ISO</em> 16232 series, relate to cleanliness of components used in road vehicle fluid circuits, <em>ISO</em> <em>123</em>45:2013 is focused on diesel fuel injection assemblies as supplied to diesel engine manufacturers or the service market. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/43/34353","uuid":"6e26be20-b20c-4a10-845e-009c4d001b84","title":"ISO 12353-1:2002 Road vehicles — Traffic accident analysis — Part 1: Vocabulary","status":"Withdrawn","year":2020,"order":100,"text":"This part of ISO 12353 establishes a terminology relating to the investigation and analysis of road traffic accidents and to the application of accident data. ","objectID":"34353_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>53-1:2002 Road vehicles — Traffic accident analysis — Part 1: Vocabulary","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This part of <em>ISO</em> <em>123</em>53 establishes a terminology relating to the investigation and analysis of road traffic accidents and to the application of accident data. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/10/21090","uuid":"a2bd63f6-ce21-4116-96bf-89fb76bde082","title":"ISO 12308:1994 Plain bearings — Quality assurance — Sample types — Definitions, applications and testing","status":"Withdrawn","year":2017,"order":100,"text":"Defines different types of plain bearing samples such as are exchanged between purchaser and manufacturer: samples used for tests and examinations which are carried out in the experimental stage and pilot lot stage; samples used to prove that the quality is in accordance with the quality requirements (dimensions, material and performance specification); samples which give selective information about particular quality characteristics. ","objectID":"21090_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>08:1994 Plain bearings — Quality assurance — Sample types — Definitions, applications and testing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Defines different types of plain bearing samples such as are exchanged between purchaser and manufacturer: samples used for tests and examinations which are carried out in the experimental stage and pilot lot stage; samples used to prove that the quality is in accordance with the quality requirements (dimensions, material and performance specification); samples which give selective information about particular quality characteristics. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/53/15369","uuid":"ba0a169f-2034-4583-9425-0aaa32f277de","title":"ISO 12303:1995 Plain bearings — Quality characteristics — Calculation of machine and process capabilities","status":"Withdrawn","year":2017,"order":100,"objectID":"15369_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>03:1995 Plain bearings — Quality characteristics — Calculation of machine and process capabilities","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/53/15368","uuid":"a8ad51f5-11a8-4b7e-afa2-0d44a19240ee","title":"ISO 12302:1993 Plain bearings — Quality characteristics — Statistical process control (SPC)","status":"Withdrawn","year":2017,"order":100,"text":"Specifies for plain bearings (except thick-walled half-bearings) those quality characteristics in accordance with ISO 12301 which can be used to regulate and control a production process on the basis of statistical process control. Covers dimensional variables but does not take account of attributes. ","objectID":"15368_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>02:1993 Plain bearings — Quality characteristics — Statistical process control (SPC)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Specifies for plain bearings (except thick-walled half-bearings) those quality characteristics in accordance with <em>ISO</em> <em>123</em>01 which can be used to regulate and control a production process on the basis of statistical process control. Covers dimensional variables but does not take account of attributes. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5851","uuid":"a0738137-a4e9-4629-9635-e6674ca60c38","title":"ISO 1232:1976 Aluminium oxide primarily used for the production of aluminium — Determination of silica content — Reduced molybdosilicate spectrophotometric method","status":"Withdrawn","year":2016,"order":100,"text":"The method is applicable to products having a silica content between 0.005 % (m/m) and 0.025 % (m/m) provided that the content of phosphorus pentoxide plus vanadium pentoxide does not exceed 0.02 % (m/m). The principle of the method is based on the formation of oxidized molybdosilicate (yellow) under well-defined conditions of acidity, concentration of reagents, temperature and time. Selective reduction of the complex in a highly acidic medium of sulphuric acid and in the presence of tartaric acid. Spectrophotometric measurement of the reduced coloured complex at a wavelength of about 815 nm. - Replaces ISO Recommendation R 1232-1970. ","objectID":"5851_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>2:1976 Aluminium oxide primarily used for the production of aluminium — Determination of silica content — Reduced molybdosilicate spectrophotometric method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"The method is applicable to products having a silica content between 0.005 % (m/m) and 0.025 % (m/m) provided that the content of phosphorus pentoxide plus vanadium pentoxide does not exceed 0.02 % (m/m). The principle of the method is based on the formation of oxidized molybdosilicate (yellow) under well-defined conditions of acidity, concentration of reagents, temperature and time. Selective reduction of the complex in a highly acidic medium of sulphuric acid and in the presence of tartaric acid. Spectrophotometric measurement of the reduced coloured complex at a wavelength of about 815 nm. - Replaces <em>ISO</em> Recommendation R <em>123</em>2-1970. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/22/32253","uuid":"35262ae5-de1e-4848-ad07-dd6fe8dc5fb1","title":"ISO 12333:2000 Aerospace — Constant displacement hydraulic motors — General specifications for 35 000 kPa systems","status":"Withdrawn","year":2016,"order":100,"objectID":"32253_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>33:2000 Aerospace — Constant displacement hydraulic motors — General specifications for 35 000 kPa systems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/19/1999","uuid":"8f8b101f-0bcb-4af3-a80e-d269f649c24a","title":"ISO 12334:2000 Aerospace — Hydraulic, pressure-compensated, variable delivery pumps — General requirement for 35 000 kPa systems","status":"Withdrawn","year":2016,"order":100,"objectID":"1999_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>34:2000 Aerospace — Hydraulic, pressure-compensated, variable delivery pumps — General requirement for 35 000 kPa systems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/54/35484","uuid":"ed884b83-df9e-4189-a7f8-e8129907c762","title":"ISO 12345:2002 Diesel engines — Cleanliness assessment of fuel injection equipment","status":"Withdrawn","year":2013,"order":100,"text":"ISO 12345 specifies cleanliness assessment procedures for evaluating the amount of debris found within the constituent parts of a diesel fuel injection system that could lead to a reduction in the system's operational effectiveness. It is mainly concerned with new equipment not yet fitted to an engine, and is therefore aimed primarily at engine and fuel injection equipment manufacturers. ","objectID":"35484_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>45:2002 Diesel engines — Cleanliness assessment of fuel injection equipment","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em> <em>123</em>45 specifies cleanliness assessment procedures for evaluating the amount of debris found within the constituent parts of a diesel fuel injection system that could lead to a reduction in the system's operational effectiveness. It is mainly concerned with new equipment not yet fitted to an engine, and is therefore aimed primarily at engine and fuel injection equipment manufacturers. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5849","uuid":"a11b132a-4651-488d-ac09-11e7801cfc47","title":"ISO 1230:1992 Photography — Determination of flash guide numbers","status":"Withdrawn","year":2007,"order":100,"text":"Specifies a method for measuring the reflector factor. Contains formulae for calculating the ISO guide number for flash lamps (with and without integral factors resp.). Gives terms and definitions. ","objectID":"5849_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>0:1992 Photography — Determination of flash guide numbers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Specifies a method for measuring the reflector factor. Contains formulae for calculating the <em>ISO</em> guide number for flash lamps (with and without integral factors resp.). Gives terms and definitions. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/50/25064","uuid":"8c370063-650a-4529-9727-6facbc676a5a","title":"ISO 12301:1992/Cor 1:1995 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics — Technical Corrigendum 1","status":"Withdrawn","year":2007,"order":100,"text":"Contains some minor amendments. ","objectID":"25064_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>01:1992/Cor 1:1995 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Contains some minor amendments. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/22/22284","uuid":"291414bd-3134-4db2-93bb-669ca6ab0f16","title":"ISO 12307-2:2000 Plain bearings — Checking of wrapped bushes — Part 2: Checking the inside diameter","status":"Withdrawn","year":2007,"order":100,"objectID":"22284_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>07-2:2000 Plain bearings — Checking of wrapped bushes — Part 2: Checking the inside diameter","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/77/17783","uuid":"ffdbd746-3a16-45b7-8922-ea35959e5671","title":"ISO 12306:1994 Plain bearings — Measurement of wall thickness of thin-walled half-bearings and thin-walled bushes","status":"Withdrawn","year":2007,"order":100,"text":"Describes in accordance with ISO 12301 the checking methods (line measurement around the circumference, line measurement in the axial direction, point measurement) and requirements for measuring equipment. Is not applicable to thermoplastic bushes. ","objectID":"17783_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>06:1994 Plain bearings — Measurement of wall thickness of thin-walled half-bearings and thin-walled bushes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Describes in accordance with <em>ISO</em> <em>123</em>01 the checking methods (line measurement around the circumference, line measurement in the axial direction, point measurement) and requirements for measuring equipment. Is not applicable to thermoplastic bushes. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/54/15403","uuid":"a2ab6066-17d4-4631-bee7-f909f9fef80e","title":"ISO 12307-1:1994 Plain bearings — Wrapped bushes — Part 1: Checking the outside diameter","status":"Withdrawn","year":2007,"order":100,"text":"Specifies, in accordance with ISO 12301, the checking of the outside diameter of wrapped bushes (methods A and B specified in ISO 3547) and describes the necessary checking methods and measuring equipment. Checking of the outside diameter of wrapped bushes can only be carried out under a constraining load by use of specialized measuring equipment. The dimensions and tolerances of wrapped bushes are given in ISO 3547. Checking the wall thickness is the subject of ISO 12306. ","objectID":"15403_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>07-1:1994 Plain bearings — Wrapped bushes — Part 1: Checking the outside diameter","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Specifies, in accordance with <em>ISO</em> <em>123</em>01, the checking of the outside diameter of wrapped bushes (methods A and B specified in <em>ISO</em> 3547) and describes the necessary checking methods and measuring equipment. Checking of the outside diameter of wrapped bushes can only be carried out under a constraining load by use of specialized measuring equipment. The dimensions and tolerances of wrapped bushes are given in <em>ISO</em> 3547. Checking the wall thickness is the subject of <em>ISO</em> <em>123</em>06. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/53/15367","uuid":"32b5b3ed-3e61-43c4-b25e-5982a4d8d48d","title":"ISO 12301:1992 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics","status":"Withdrawn","year":2007,"order":100,"text":"Applies to metallic thin-walled half-bearings (ISO 3548), metallic thin-walled flanged bearings (ISO 6864), metallic thick-walled half-bearings (with and without flange), wrapped bushes (ISO 3547), unsplit metallic bushes (with and without flange) (ISO 4379), thermoplastic bushes (with and without flange), ring-type thrust washers and pressed bimetallic half-thrust washers (ISO 6525 and 6526), and plain bearings made from sintered material (ISO 2795). Annex A deals with calculation of tangential load. ","objectID":"15367_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>01:1992 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Applies to metallic thin-walled half-bearings (<em>ISO</em> 3548), metallic thin-walled flanged bearings (<em>ISO</em> 6864), metallic thick-walled half-bearings (with and without flange), wrapped bushes (<em>ISO</em> 3547), unsplit metallic bushes (with and without flange) (<em>ISO</em> 4379), thermoplastic bushes (with and without flange), ring-type thrust washers and pressed bimetallic half-thrust washers (<em>ISO</em> 6525 and 6526), and plain bearings made from sintered material (<em>ISO</em> 2795). Annex A deals with calculation of tangential load. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5853","uuid":"26ff09f4-2f11-46f5-849c-9fd1324c2d81","title":"ISO 1234:1976 Split pins — Metric series","status":"Withdrawn","year":1997,"order":100,"objectID":"5853_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>4:1976 Split pins — Metric series","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5848","uuid":"7d00ade5-46c2-49a4-8b0f-5878382912c3","title":"ISO 1230:1973 Photography — Determination of flash guide numbers","status":"Withdrawn","year":1992,"order":100,"objectID":"5848_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>0:1973 Photography — Determination of flash guide numbers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5852","uuid":"7ecde773-3545-49dd-9687-e4f68a0e4024","title":"ISO 1233:1975 Plastics — Determination of viscosity number of methyl methacrylate polymers and copolymers in dilute solution","status":"Withdrawn","year":1990,"order":100,"objectID":"5852_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>123</em>3:1975 Plastics — Determination of viscosity number of methyl methacrylate polymers and copolymers in dilute solution","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/57/75745","uuid":"f0a38fee-6a2e-4bd6-8102-35beef6be75e","title":"ISO 3547-7:2020 Plain bearings — Wrapped bushes — Part 7: Measurement of wall thickness of thin-walled bushes","status":"Published","year":2020,"order":11,"text":"This document describes, following ISO 12301, the checking methods and measuring equipment used for measuring the total wall thickness of thin-walled bushes in the finished state. NOTE    All dimensions in this document are given in millimetres. ","objectID":"75745_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3547-7:2020 Plain bearings — Wrapped bushes — Part 7: Measurement of wall thickness of thin-walled bushes","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document describes, following <em>ISO</em> <em>123</em>01, the checking methods and measuring equipment used for measuring the total wall thickness of thin-walled bushes in the finished state. NOTE    All dimensions in this document are given in millimetres. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/57/75744","uuid":"5a0e3af7-16ce-47c2-ace9-a1e410223f11","title":"ISO 3547-6:2020 Plain bearings — Wrapped bushes — Part 6: Checking the inside diameter","status":"Published","year":2020,"order":11,"text":"The document specifies, following ISO 12301, the checking of the inside diameter of wrapped bushes (see ISO 3547‑2:2017, method C) and describes the necessary checking methods and measuring equipment. NOTE 1  All dimensions in this document are given in millimetres except where otherwise noted/designated. NOTE 2  The dimensions and tolerances of wrapped bushes are given in ISO 3547‑1. NOTE 3  Checking of the wall thickness is the subject of ISO 3547‑7. NOTE 4  Checking of the outside diameter of wrapped bushes is the subject of ISO 3547‑5. ","objectID":"75744_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3547-6:2020 Plain bearings — Wrapped bushes — Part 6: Checking the inside diameter","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"The document specifies, following <em>ISO</em> <em>123</em>01, the checking of the inside diameter of wrapped bushes (see <em>ISO</em> 3547‑2:2017, method C) and describes the necessary checking methods and measuring equipment. NOTE 1  All dimensions in this document are given in millimetres except where otherwise noted/designated. NOTE 2  The dimensions and tolerances of wrapped bushes are given in <em>ISO</em> 3547‑1. NOTE 3  Checking of the wall thickness is the subject of <em>ISO</em> 3547‑7. NOTE 4  Checking of the outside diameter of wrapped bushes is the subject of <em>ISO</em> 3547‑5. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/57/75743","uuid":"fda688e6-93e8-47c2-96e4-5153588b6c7b","title":"ISO 3547-5:2020 Plain bearings — Wrapped bushes — Part 5: Checking the outside diameter","status":"Published","year":2020,"order":11,"text":"This document specifies, following ISO 12301, the checking of the outside diameter of wrapped bushes (ISO 3547‑2:2017, methods A, B and D) and describes the necessary checking methods and measuring equipment. NOTE    The dimensions and tolerances of wrapped bushes are given in ISO 3547‑1. Checking the wall thickness is the subject of ISO 3547‑7. ","objectID":"75743_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3547-5:2020 Plain bearings — Wrapped bushes — Part 5: Checking the outside diameter","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies, following <em>ISO</em> <em>123</em>01, the checking of the outside diameter of wrapped bushes (<em>ISO</em> 3547‑2:2017, methods A, B and D) and describes the necessary checking methods and measuring equipment. NOTE    The dimensions and tolerances of wrapped bushes are given in <em>ISO</em> 3547‑1. Checking the wall thickness is the subject of <em>ISO</em> 3547‑7. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/56/75681","uuid":"6ab1fbf5-4a97-4a15-930f-58f09c1fd231","title":"ISO 3548-2:2020 Plain bearings — Thin-walled half bearings with or without flange — Part 2: Measurement of wall thickness and flange thickness","status":"Published","year":2020,"order":11,"text":"This document specifies in accordance with ISO 12301 the checking of the wall-thickness of thin-walled half bearings with or without flange and describes the necessary checking methods and measuring equipment. It applies to a maximum bearing diameter of 150 mm. It can be applied to a bigger diameter, provided that there is an agreement between the supplier and the user. ","objectID":"75681_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3548-2:2020 Plain bearings — Thin-walled half bearings with or without flange — Part 2: Measurement of wall thickness and flange thickness","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies in accordance with <em>ISO</em> <em>123</em>01 the checking of the wall-thickness of thin-walled half bearings with or without flange and describes the necessary checking methods and measuring equipment. It applies to a maximum bearing diameter of 150 mm. It can be applied to a bigger diameter, provided that there is an agreement between the supplier and the user. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41337","uuid":"b05bb528-c110-4a78-a62b-adfb52b39cd1","title":"ISO 3547-7:2007 Plain bearings — Wrapped bushes — Part 7: Measurement of wall thickness of thin-walled bushes","status":"Withdrawn","year":2020,"order":100,"text":"ISO 3547:2007 describes, following ISO 12301, the checking methods and measuring equipment used for measuring the total wall thickness of thin-walled bushes in the finished state. ","objectID":"41337_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3547-7:2007 Plain bearings — Wrapped bushes — Part 7: Measurement of wall thickness of thin-walled bushes","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 3547:2007 describes, following <em>ISO</em> <em>123</em>01, the checking methods and measuring equipment used for measuring the total wall thickness of thin-walled bushes in the finished state. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41336","uuid":"16a9a5b4-9d3f-40a4-840e-449c2c278dda","title":"ISO 3547-6:2007 Plain bearings — Wrapped bushes — Part 6: Checking the inside diameter","status":"Withdrawn","year":2020,"order":100,"text":"ISO 3547-6:2007 specifies, following ISO 12301, the checking of the inside diameter of wrapped bushes and describes the necessary checking methods and measuring equipment. Wrapped bushes in the free condition are flexible, but after insertion they adapt largely to the shape of the housing bore due to the interference between the outside diameter of the bush and the housing bore. ","objectID":"41336_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3547-6:2007 Plain bearings — Wrapped bushes — Part 6: Checking the inside diameter","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 3547-6:2007 specifies, following <em>ISO</em> <em>123</em>01, the checking of the inside diameter of wrapped bushes and describes the necessary checking methods and measuring equipment. Wrapped bushes in the free condition are flexible, but after insertion they adapt largely to the shape of the housing bore due to the interference between the outside diameter of the bush and the housing bore. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41334","uuid":"db078642-6287-472a-8415-188c4a8818c0","title":"ISO 3547-5:2007 Plain bearings — Wrapped bushes — Part 5: Checking the outside diameter","status":"Withdrawn","year":2020,"order":100,"text":"ISO 3547-5:2007 specifies, following ISO 12301, the checking of the outside diameter of wrapped bushes (ISO 3547-2:2006, methods A, B and D) and describes the necessary checking methods and measuring equipment. Wrapped bushes in the free condition are flexible, but after insertion they adapt largely to the shape of the housing bore due to the oversize between the outside diameter of the bush and the housing bore. For this reason, checking of the outside diameter of wrapped bushes can only be carried out under a constraining load by use of specialized measuring equipment. ","objectID":"41334_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3547-5:2007 Plain bearings — Wrapped bushes — Part 5: Checking the outside diameter","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 3547-5:2007 specifies, following <em>ISO</em> <em>123</em>01, the checking of the outside diameter of wrapped bushes (<em>ISO</em> 3547-2:2006, methods A, B and D) and describes the necessary checking methods and measuring equipment. Wrapped bushes in the free condition are flexible, but after insertion they adapt largely to the shape of the housing bore due to the oversize between the outside diameter of the bush and the housing bore. For this reason, checking of the outside diameter of wrapped bushes can only be carried out under a constraining load by use of specialized measuring equipment. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/67/56709","uuid":"43959a11-b73b-422e-9a30-d681aff5482e","title":"ISO 3548-3:2012 Plain bearings — Thin-walled half bearings with or without flange — Part 3: Measurement of peripheral length","status":"Published","year":2021,"order":11,"text":"This part of ISO 3548 specifies, according to ISO 12301, the checking of the peripheral length of thin-walled half bearings with or without flange, and describes the necessary checking methods and measuring equipment. Thin-walled half bearings are flexible and, in the free condition, do not conform to a cylindrical profile. This is one reason the peripheral length of the half bearings can only be measured under a constraining load by use of specialized measuring equipment. In addition, measuring equipment different from that illustrated in this part of ISO 3548 can be used, provided the measuring accuracy of the equipment is consistent with the specifications given in Clause 17. This part of ISO 3548 does not include measurement of the parting line taper. This part of ISO 3548 applies to thin-walled half bearings, the specifications of which are given in ISO 3548-1 ","objectID":"56709_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3548-3:2012 Plain bearings — Thin-walled half bearings with or without flange — Part 3: Measurement of peripheral length","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This part of <em>ISO</em> 3548 specifies, according to <em>ISO</em> <em>123</em>01, the checking of the peripheral length of thin-walled half bearings with or without flange, and describes the necessary checking methods and measuring equipment. Thin-walled half bearings are flexible and, in the free condition, do not conform to a cylindrical profile. This is one reason the peripheral length of the half bearings can only be measured under a constraining load by use of specialized measuring equipment. In addition, measuring equipment different from that illustrated in this part of <em>ISO</em> 3548 can be used, provided the measuring accuracy of the equipment is consistent with the specifications given in Clause 17. This part of <em>ISO</em> 3548 does not include measurement of the parting line taper. This part of <em>ISO</em> 3548 applies to thin-walled half bearings, the specifications of which are given in <em>ISO</em> 3548-1 ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/44/44400","uuid":"22c379d0-ccd5-4cde-a314-006cdf1dcda2","title":"ISO 3548-2:2009 Plain bearings — Thin-walled half bearings with or without flange — Part 2: Measurement of wall thickness and flange thickness","status":"Withdrawn","year":2020,"order":100,"text":"ISO 3548-2:2009 specifies, in accordance with ISO 12301, the checking of the wall-thickness of thin-walled half bearings with or without flange and describes the required checking methods and measuring equipment. It applies to a maximum bearing diameter of 150 mm. If ISO 3548-2:2009 is applied to a greater diameter, an agreement can be formulated between the supplier and the user. ","objectID":"44400_0","_highlightResult":{"title":{"value":"<em>ISO</em> 3548-2:2009 Plain bearings — Thin-walled half bearings with or without flange — Part 2: Measurement of wall thickness and flange thickness","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 3548-2:2009 specifies, in accordance with <em>ISO</em> <em>123</em>01, the checking of the wall-thickness of thin-walled half bearings with or without flange and describes the required checking methods and measuring equipment. It applies to a maximum bearing diameter of 150 mm. If <em>ISO</em> 3548-2:2009 is applied to a greater diameter, an agreement can be formulated between the supplier and the user. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/71/57100","uuid":"cbc9bf3e-2476-46d8-8e0d-9a856f87a0f8","title":"ISO/TR 12353-3:2013 Road vehicles — Traffic accident analysis — Part 3: Guidelines for the interpretation of recorded crash pulse data to determine impact severity","status":"Published","year":2013,"order":11,"text":"ISO/TR 12353-3:2013 describes the determination of impact severity in road vehicle accidents as defined in ISO 12353-2, based on recorded acceleration and velocity data and derived parameters from vehicle crash pulse recorders or event data recorders, including data from self-contained devices or vehicle integrated functionalities. ","objectID":"57100_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>53-3:2013 Road vehicles — Traffic accident analysis — Part 3: Guidelines for the interpretation of recorded crash pulse data to determine impact severity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>53-3:2013 describes the determination of impact severity in road vehicle accidents as defined in <em>ISO</em> <em>123</em>53-2, based on recorded acceleration and velocity data and derived parameters from vehicle crash pulse recorders or event data recorders, including data from self-contained devices or vehicle integrated functionalities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/74/17431","uuid":"6f55b562-ef22-41e1-bf00-26e7d432e386","title":"ISO 9618:1996 Aerospace — Nuts, hexagonal, slotted (castellated), reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature)/120 degrees C, 450 MPa (at ambient temperature)/235 degrees C, 600 MPa (at ambient temperature)/425 degrees C, 900 MPa (at ambient temperature)/235 degrees C, 900 MPa (at ambient temperature)/315 degrees C, 900 MPa (at ambient temperature)/650 degrees C, 1 100 MPa (at ambient temperature)/235 degrees C, 1 100 MPa (at ambient temperature)/730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","status":"Withdrawn","year":2016,"order":100,"text":"Specifies the dimensions of hexagon slotted nuts of several classifications, reduced height, with MJ threads. Intended to be used with split pins in conformity with ISO 1234. ","objectID":"17431_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9618:1996 Aerospace — Nuts, hexagonal, slotted (castellated), reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature)/120 degrees C, 450 MPa (at ambient temperature)/235 degrees C, 600 MPa (at ambient temperature)/425 degrees C, 900 MPa (at ambient temperature)/235 degrees C, 900 MPa (at ambient temperature)/315 degrees C, 900 MPa (at ambient temperature)/650 degrees C, 1 100 MPa (at ambient temperature)/235 degrees C, 1 100 MPa (at ambient temperature)/730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"Specifies the dimensions of hexagon slotted nuts of several classifications, reduced height, with MJ threads. Intended to be used with split pins in conformity with <em>ISO</em> <em>123</em>4. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/46/74658","uuid":"d53463b5-af61-485b-8692-e6dbcec05d30","title":"ISO 10848-5:2020 Acoustics — Laboratory and field measurement of the flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 5: Radiation efficiencies of building elements","status":"Published","year":2020,"order":11,"text":"This document specifies measurement methods to characterize in the laboratory the acoustic radiation of a building element when it is directly excited by an airborne or structure-borne source. It is applicable to single-leaf and double-leaf elements (see ISO 12354-1:2017 Annex F, F2). The measured quantity can be used as input data for prediction methods, such as ISO 12354-1 and ISO 12354-2, to compare products, or to express a requirement. ","objectID":"74658_0","_highlightResult":{"title":{"value":"<em>ISO</em> 10848-5:2020 Acoustics — Laboratory and field measurement of the flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 5: Radiation efficiencies of building elements","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies measurement methods to characterize in the laboratory the acoustic radiation of a building element when it is directly excited by an airborne or structure-borne source. It is applicable to single-leaf and double-leaf elements (see <em>ISO</em> <em>123</em>54-1:2017 Annex F, F2). The measured quantity can be used as input data for prediction methods, such as <em>ISO</em> <em>123</em>54-1 and <em>ISO</em> <em>123</em>54-2, to compare products, or to express a requirement. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/72/67227","uuid":"faf45482-b0a7-42e9-b532-6322004d5ebf","title":"ISO 10848-2:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 2: Application to Type B elements when the junction has a small influence","status":"Published","year":2017,"order":11,"text":"ISO 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. This document considers only laboratory measurements. The measured quantities can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as ISO 12354‑1 and ISO 12354‑2. However, the measured quantities Dn,f, Ln,f and Lne0,f only represent the performance with the dimensions for the test specimens described in this document. ISO 10848-2:2017 is referred to in ISO 10848‑1:2017, 4.5 as being a supporting part of the frame document. It applies to Type B elements as defined in ISO 10848‑1, such as suspended ceilings, access floors, light uninterrupted façades or floating floors. The transmission from one room to another can occur simultaneously through the test element and via the plenum (if any). For measurements made according to this document, the total sound transmission is determined and it is not possible to separate the two kinds of transmission. ","objectID":"67227_0","_highlightResult":{"title":{"value":"<em>ISO</em> 10848-2:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 2: Application to Type B elements when the junction has a small influence","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. This document considers only laboratory measurements. The measured quantities can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as <em>ISO</em> <em>123</em>54‑1 and <em>ISO</em> <em>123</em>54‑2. However, the measured quantities Dn,f, Ln,f and Lne0,f only represent the performance with the dimensions for the test specimens described in this document. <em>ISO</em> 10848-2:2017 is referred to in <em>ISO</em> 10848‑1:2017, 4.5 as being a supporting part of the frame document. It applies to Type B elements as defined in <em>ISO</em> 10848‑1, such as suspended ceilings, access floors, light uninterrupted façades or floating floors. The transmission from one room to another can occur simultaneously through the test element and via the plenum (if any). For measurements made according to this document, the total sound transmission is determined and it is not possible to separate the two kinds of transmission. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/74/37474","uuid":"113f3df9-a02c-4855-b0f0-16ee1d7ba236","title":"ISO/TR 7861:2003 Road vehicles — Injury risk curves for evaluation of occupant protection in frontal impact","status":"Published","year":2003,"order":11,"text":"ISO/TR 7861:2002 presents injury risk curves that can be used for injury risk assessment in the evaluation of occupant protection in road-vehicle frontal impact. The measurements were made on frontal-impact crash test dummies which present acceptable levels of biofidelity response in accordance with ISO 12349-1 and ISO 12349-2 and which are used in the frontal-impact test procedures of existing International Standards. ","objectID":"37474_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR 7861:2003 Road vehicles — Injury risk curves for evaluation of occupant protection in frontal impact","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em>/TR 7861:2002 presents injury risk curves that can be used for injury risk assessment in the evaluation of occupant protection in road-vehicle frontal impact. The measurements were made on frontal-impact crash test dummies which present acceptable levels of biofidelity response in accordance with <em>ISO</em> <em>123</em>49-1 and <em>ISO</em> <em>123</em>49-2 and which are used in the frontal-impact test procedures of existing International Standards. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/68/16846","uuid":"e335ccd7-e4af-4b36-a218-6b2eabb5359d","title":"ISO 9218:2002 Aerospace — Washers, flat, for pulleys, in alloy steel and cadmium plated or in corrosion-resistant steel and passivated — Dimensions and masses","status":"Published","year":2020,"order":11,"text":"ISO 9218:2002 specifies the characteristics of flat washers in alloy steel and cadmium plated (classification 900 MPa/235 °C) or in corrosion-resistant steel and passivated (classification 900 MPa/450 °C). ISO 9218:2002 is applicable to washers used with ISO 9219 bolts, diameter code 050 and 060, ISO 9216 nuts and ISO 1234 split pins in the assembly of ISO 7939 pulleys. ISO 9218:2002 is also applicable to washers in the assembly of airframe rolling bearings or spherical bearings. ","objectID":"16846_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9218:2002 Aerospace — Washers, flat, for pulleys, in alloy steel and cadmium plated or in corrosion-resistant steel and passivated — Dimensions and masses","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 9218:2002 specifies the characteristics of flat washers in alloy steel and cadmium plated (classification 900 MPa/235 °C) or in corrosion-resistant steel and passivated (classification 900 MPa/450 °C). <em>ISO</em> 9218:2002 is applicable to washers used with <em>ISO</em> 9219 bolts, diameter code 050 and 060, <em>ISO</em> 9216 nuts and <em>ISO</em> <em>123</em>4 split pins in the assembly of <em>ISO</em> 7939 pulleys. <em>ISO</em> 9218:2002 is also applicable to washers in the assembly of airframe rolling bearings or spherical bearings. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/68/16845","uuid":"25cdc116-31cb-4acd-a0a2-6ba793069507","title":"ISO 9217:2002 Aerospace — Washers, chamfered, with counterbore, for pulleys, in alloy steel and cadmium plated or in corrosion-resistant steel and passivated — Dimensions and masses","status":"Published","year":2020,"order":11,"text":"ISO 9217:2002 specifies the characteristics of chamfered washers with counterbore in alloy steel and cadmium plated (classification 900 MPa/235 °C) or in corrosion-resistant steel and passivated (classification 900 MPa/450 °C). ISO 9217:2002 is applicable to washers used with ISO 9219 bolts, diameter code 080 to 250, ISO 9216 nuts and ISO 1234 split pins in the assembly of ISO 7939 pulleys. ISO 9217:2002 is also applicable to washers in the assembly of airframe rolling bearings or spherical bearings. ","objectID":"16845_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9217:2002 Aerospace — Washers, chamfered, with counterbore, for pulleys, in alloy steel and cadmium plated or in corrosion-resistant steel and passivated — Dimensions and masses","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 9217:2002 specifies the characteristics of chamfered washers with counterbore in alloy steel and cadmium plated (classification 900 MPa/235 °C) or in corrosion-resistant steel and passivated (classification 900 MPa/450 °C). <em>ISO</em> 9217:2002 is applicable to washers used with <em>ISO</em> 9219 bolts, diameter code 080 to 250, <em>ISO</em> 9216 nuts and <em>ISO</em> <em>123</em>4 split pins in the assembly of <em>ISO</em> 7939 pulleys. <em>ISO</em> 9217:2002 is also applicable to washers in the assembly of airframe rolling bearings or spherical bearings. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/68/16844","uuid":"465993d4-3ecc-47b9-8f37-6bd3321b9b2c","title":"ISO 9216:2002 Aerospace — Nuts, hexagonal, slotted (castellated), for pulleys, in alloy steel and cadmium plated or in corrosion-resistant steel and passivated — Dimensions and masses","status":"Published","year":2020,"order":11,"text":"ISO 9216:2002 specifies the characteristics of nuts, hexagonal, slotted/castellated, of reduced height and reduced width across flats, in alloy steel and cadmium plated (classification 900 MPa/235 °C) or in corrosion-resistant steel and passivated (classification 900 MPa/450 °C). ISO 9216:2002 is applicable to nuts used with ISO 9219 bolts, ISO 9217 and ISO 9218 washers, and ISO 1234 split pins in the assembly of ISO 7939 pulleys. ISO 9216:2002 is also applicable to nuts in the assembly of airframe rolling bearings or spherical bearings. ","objectID":"16844_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9216:2002 Aerospace — Nuts, hexagonal, slotted (castellated), for pulleys, in alloy steel and cadmium plated or in corrosion-resistant steel and passivated — Dimensions and masses","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 9216:2002 specifies the characteristics of nuts, hexagonal, slotted/castellated, of reduced height and reduced width across flats, in alloy steel and cadmium plated (classification 900 MPa/235 °C) or in corrosion-resistant steel and passivated (classification 900 MPa/450 °C). <em>ISO</em> 9216:2002 is applicable to nuts used with <em>ISO</em> 9219 bolts, <em>ISO</em> 9217 and <em>ISO</em> 9218 washers, and <em>ISO</em> <em>123</em>4 split pins in the assembly of <em>ISO</em> 7939 pulleys. <em>ISO</em> 9216:2002 is also applicable to nuts in the assembly of airframe rolling bearings or spherical bearings. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/68/16847","uuid":"9ffab211-de60-4faa-a61c-2b490c04dbb3","title":"ISO 9219:2002 Aerospace — Bolts, thin hexagonal head, for pulleys, close tolerance shank, short thread, in alloy steel and cadmium plated or in titanium alloy and MoS2 lubricated or in corrosion-resistant steel and passivated — Dimensions and masses","status":"Published","year":2020,"order":11,"text":"ISO 9219:2002 specifies the characteristics of bolts for pulleys, with thin hexagonal head, close tolerance shank and short thread, in alloy steel and cadmium plated (classification 1 100 MPa/235 °C), in titanium alloy and MoS 2 lubricated (classification 1 100 MPa/315 °C) or in corrosion-resistant steel and passivated. ISO 9219:2002 is applicable to bolts used with ISO 9217 and ISO 9218 washers, ISO 9216 nuts and ISO 1234 splint pins. ","objectID":"16847_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9219:2002 Aerospace — Bolts, thin hexagonal head, for pulleys, close tolerance shank, short thread, in alloy steel and cadmium plated or in titanium alloy and MoS2 lubricated or in corrosion-resistant steel and passivated — Dimensions and masses","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 9219:2002 specifies the characteristics of bolts for pulleys, with thin hexagonal head, close tolerance shank and short thread, in alloy steel and cadmium plated (classification 1 100 MPa/235 °C), in titanium alloy and MoS 2 lubricated (classification 1 100 MPa/315 °C) or in corrosion-resistant steel and passivated. <em>ISO</em> 9219:2002 is applicable to bolts used with <em>ISO</em> 9217 and <em>ISO</em> 9218 washers, <em>ISO</em> 9216 nuts and <em>ISO</em> <em>123</em>4 splint pins. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/63/66319","uuid":"d49f835e-14a5-47f1-8e54-ad45869daf48","title":"ISO 9618:2016 Aerospace — Nuts, hexagonal, slotted (castellated), reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature)/120 degrees C, 450 MPa (at ambient temperature)/235 degrees C, 600 MPa (at ambient temperature)/425 degrees C, 900 MPa (at ambient temperature)/235 degrees C, 900 MPa (at ambient temperature)/315 degrees C, 900 MPa (at ambient temperature)/650 degrees C, 1 100 MPa (at ambient temperature)/235 degrees C, 1 100 MPa (at ambient temperature)/730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","status":"Published","year":2021,"order":11,"text":"ISO 9618:2016 specifies the dimensions of hexagon slotted (castellated) nuts, reduced height, normal across flats, with MJ threads, of classifications: 450 MPa/120 °C, 450 MPa/235 °C, 600 MPa/425 °C, 900 MPa/235 °C, 900 MPa/315 °C, 900 MPa/650 °C, 1 100 MPa/235 °C, 1 100 MPa/730 °C, and 1 250 MPa/600 °C. These nuts are intended to be used with split pins in conformity with ISO 1234. ISO 9618:2016 is applicable for the compilation of aerospace product standards. ","objectID":"66319_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9618:2016 Aerospace — Nuts, hexagonal, slotted (castellated), reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature)/120 degrees C, 450 MPa (at ambient temperature)/235 degrees C, 600 MPa (at ambient temperature)/425 degrees C, 900 MPa (at ambient temperature)/235 degrees C, 900 MPa (at ambient temperature)/315 degrees C, 900 MPa (at ambient temperature)/650 degrees C, 1 100 MPa (at ambient temperature)/235 degrees C, 1 100 MPa (at ambient temperature)/730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 9618:2016 specifies the dimensions of hexagon slotted (castellated) nuts, reduced height, normal across flats, with MJ threads, of classifications: 450 MPa/120 °C, 450 MPa/235 °C, 600 MPa/425 °C, 900 MPa/235 °C, 900 MPa/315 °C, 900 MPa/650 °C, 1 100 MPa/235 °C, 1 100 MPa/730 °C, and 1 250 MPa/600 °C. These nuts are intended to be used with split pins in conformity with <em>ISO</em> <em>123</em>4. <em>ISO</em> 9618:2016 is applicable for the compilation of aerospace product standards. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/42/74267","uuid":"16e3afda-4073-4a10-9f07-59b7fdf79ee1","title":"ISO 19734:2021 Eye and face protection — Guidance on selection, use and maintenance","status":"Published","year":2021,"order":11,"text":"This document gives guidance to specifiers and users on the control of eye and face hazards including physical, mechanical, chemical, optical radiation and biological and on the selection, use and maintenance of eye and face protectors. This document applies to —     occupational use, —      tasks that are performed similarly to those in an occupation but not in the workplace, e.g. \"do-it-yourself\", and —     schools, educational and research establishments. This document does not apply to eye and face protection for —     ionizing radiation, —     low frequency radio waves, —     microwaves, —     sports or vehicular usage, and —     sunglasses for general (not occupational) use ? see ISO 12312-1. NOTE     The ISO 18527 (all parts) sets requirements for eye protectors for some sports. Brief advice on protection when using lasers is included but for detailed advice, see IEC/TR 60825-14. This document is neither a whole nor partial substitute for risk assessment, which is an essential part of any eye and face protection programme. Although this document has been written to help specifiers and users, any recommendations in this document are to be interpreted as guidance only and not intended to replace any national regulatory requirements. Risk assessment is the sole responsibility of the employer and not the PPE manufacturer or its authorised representative. ","objectID":"74267_0","_highlightResult":{"title":{"value":"<em>ISO</em> 19734:2021 Eye and face protection — Guidance on selection, use and maintenance","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document gives guidance to specifiers and users on the control of eye and face hazards including physical, mechanical, chemical, optical radiation and biological and on the selection, use and maintenance of eye and face protectors. This document applies to —     occupational use, —      tasks that are performed similarly to those in an occupation but not in the workplace, e.g. \"do-it-yourself\", and —     schools, educational and research establishments. This document does not apply to eye and face protection for —     ionizing radiation, —     low frequency radio waves, —     microwaves, —     sports or vehicular usage, and —     sunglasses for general (not occupational) use ? see <em>ISO</em> <em>123</em>12-1. NOTE     The <em>ISO</em> 18527 (all parts) sets requirements for eye protectors for some sports. Brief advice on protection when using lasers is included but for detailed advice, see IEC/TR 60825-14. This document is neither a whole nor partial substitute for risk assessment, which is an essential part of any eye and face protection programme. Although this document has been written to help specifiers and users, any recommendations in this document are to be interpreted as guidance only and not intended to replace any national regulatory requirements. Risk assessment is the sole responsibility of the employer and not the PPE manufacturer or its authorised representative. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/72/67229","uuid":"1ccff668-35cb-4c86-bfd9-23ac46b38fa3","title":"ISO 10848-4:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 4: Application to junctions with at least one Type A element","status":"Published","year":2017,"order":11,"text":"ISO 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. ISO 10848-4:2017 specifies laboratory and field measurements of buildings where at least one of the elements that form the construction under test is a Type A element (defined in ISO 10848‑1). Laboratory measurements are used to quantify the performance of the junction with suppressed flanking transmission from the laboratory structure. Field measurements are used to characterize the in situ performance and it is not usually possible to suppress unwanted flanking transmission sufficiently; hence, the results are primarily representative of the performance of that junction when installed in that particular building structure. The measured quantities can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as ISO 12354‑1 and ISO 12354‑2. ","objectID":"67229_0","_highlightResult":{"title":{"value":"<em>ISO</em> 10848-4:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 4: Application to junctions with at least one Type A element","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. <em>ISO</em> 10848-4:2017 specifies laboratory and field measurements of buildings where at least one of the elements that form the construction under test is a Type A element (defined in <em>ISO</em> 10848‑1). Laboratory measurements are used to quantify the performance of the junction with suppressed flanking transmission from the laboratory structure. Field measurements are used to characterize the in situ performance and it is not usually possible to suppress unwanted flanking transmission sufficiently; hence, the results are primarily representative of the performance of that junction when installed in that particular building structure. The measured quantities can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as <em>ISO</em> <em>123</em>54‑1 and <em>ISO</em> <em>123</em>54‑2. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/26/72629","uuid":"2a3a2379-05bb-4814-b2e3-7e6d563786dc","title":"ISO 12609-1:2021 Eye and face protection against intense light sources used on humans and animals for cosmetic and medical applications — Part 1: Specification for products","status":"Published","year":2021,"order":11,"text":"This document specifies general requirements for operators' eye protectors for intense light source (ILS) equipment used on humans and animals for cosmetic and medical applications against excessive exposure to optical radiation in the spectral range 250 nm to 3 000 nm, with the exception of laser radiation. This document is applicable to devices intended for patient protection during ILS procedures, except for treatment in the periorbital area. For guidance on patient eye protection during ILS procedures, see ISO/TR 22463. For guidance on the use and selection of ILS eye protectors, see ISO 12609-2. This document does not apply to: —    laser protectors, for which ISO 19818-1 applies; —    protectors for medically prescribed applications (not occupational), e.g. eye protection for severe dry eye, tints prescribed for medical conditions; —    protectors specifically intended for protection against only solar radiation and used in non-occupational environments for which the ISO 12312 (all parts) applies; —    protectors used with tanning equipment; —    protectors intended to protect against ionizing radiation, e.g. X-rays, for which IEC 61331-3 applies. ","objectID":"72629_0","_highlightResult":{"title":{"value":"<em>ISO</em> 12609-1:2021 Eye and face protection against intense light sources used on humans and animals for cosmetic and medical applications — Part 1: Specification for products","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies general requirements for operators' eye protectors for intense light source (ILS) equipment used on humans and animals for cosmetic and medical applications against excessive exposure to optical radiation in the spectral range 250 nm to 3 000 nm, with the exception of laser radiation. This document is applicable to devices intended for patient protection during ILS procedures, except for treatment in the periorbital area. For guidance on patient eye protection during ILS procedures, see <em>ISO</em>/TR 22463. For guidance on the use and selection of ILS eye protectors, see <em>ISO</em> 12609-2. This document does not apply to: —    laser protectors, for which <em>ISO</em> 19818-1 applies; —    protectors for medically prescribed applications (not occupational), e.g. eye protection for severe dry eye, tints prescribed for medical conditions; —    protectors specifically intended for protection against only solar radiation and used in non-occupational environments for which the <em>ISO</em> <em>123</em>12 (all parts) applies; —    protectors used with tanning equipment; —    protectors intended to protect against ionizing radiation, e.g. X-rays, for which IEC 61331-3 applies. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/25/62527","uuid":"4828525e-3532-46c5-9851-0009cefe89d4","title":"ISO 16321-1:2021 Eye and face protection for occupational use — Part 1: General requirements","status":"Published","year":2021,"order":11,"text":"This document specifies general requirements for eye and face protectors. These protectors are intended to provide protection for the eyes and faces of persons against one or more common occupational hazards such as impacts from flying particles and fragments, optical radiation, dusts, splashing liquids, molten metals, heat, flame, hot solids, harmful gases, vapours and aerosols. Additional requirements for eye and face protectors used during welding and related techniques and for mesh protectors are given in ISO 16321-2 and ISO 16321-3, respectively. This document applies to: —     all plano as well as corrective and prescription lensed protectors and components; —     those eye and face protectors used for occupational-type tasks that are performed similarly to an occupation, e.g. \"do-it-yourself\"; —     those eye and face protectors used in educational establishments. This document does not apply to: —     protectors specifically intended for protection against only solar radiation and used in non- occupational environments for which the ISO 12312 series applies; —     protectors for medically prescribed applications (not occupational), e.g. eye protection for severe dry eye, tints prescribed for medical conditions; —     patient eye protectors during diagnosis or treatment (e.g. ISO/TR 22463); —     protectors for use during medical or e.g. aesthetic applications, e.g. intense light sources (ILS) for which the ISO 12609 series applies; —     protectors specifically intended for sports for which the ISO 18527 series applies; —     laser protectors; —     face protectors intended for live-working to protect against short-circuit electric arcs for which IEC 62819 applies; —     protectors intended to protect against ionizing radiation, e.g. X-rays, for which IEC 61331-3 applies. ","objectID":"62527_0","_highlightResult":{"title":{"value":"<em>ISO</em> 16321-1:2021 Eye and face protection for occupational use — Part 1: General requirements","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies general requirements for eye and face protectors. These protectors are intended to provide protection for the eyes and faces of persons against one or more common occupational hazards such as impacts from flying particles and fragments, optical radiation, dusts, splashing liquids, molten metals, heat, flame, hot solids, harmful gases, vapours and aerosols. Additional requirements for eye and face protectors used during welding and related techniques and for mesh protectors are given in <em>ISO</em> 16321-2 and <em>ISO</em> 16321-3, respectively. This document applies to: —     all plano as well as corrective and prescription lensed protectors and components; —     those eye and face protectors used for occupational-type tasks that are performed similarly to an occupation, e.g. \"do-it-yourself\"; —     those eye and face protectors used in educational establishments. This document does not apply to: —     protectors specifically intended for protection against only solar radiation and used in non- occupational environments for which the <em>ISO</em> <em>123</em>12 series applies; —     protectors for medically prescribed applications (not occupational), e.g. eye protection for severe dry eye, tints prescribed for medical conditions; —     patient eye protectors during diagnosis or treatment (e.g. <em>ISO</em>/TR 22463); —     protectors for use during medical or e.g. aesthetic applications, e.g. intense light sources (ILS) for which the <em>ISO</em> 12609 series applies; —     protectors specifically intended for sports for which the <em>ISO</em> 18527 series applies; —     laser protectors; —     face protectors intended for live-working to protect against short-circuit electric arcs for which IEC 62819 applies; —     protectors intended to protect against ionizing radiation, e.g. X-rays, for which IEC 61331-3 applies. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/72/67228","uuid":"ec60765e-ad9e-4660-9fae-033952db7671","title":"ISO 10848-3:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 3: Application to Type B elements when the junction has a substantial influence","status":"Published","year":2017,"order":11,"text":"ISO 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. ISO 10848-3:2017 specifies laboratory and field measurements of buildings for Type B elements (defined in ISO 10848‑1) when the junction has a substantial influence. Laboratory measurements are used to quantify the performance of the junction with suppressed flanking transmission from the laboratory structure. Field measurements are used to characterize the in situ performance and it is not usually possible to suppress unwanted flanking transmission sufficiently; hence, the results can only be considered representative of the performance of that junction when installed in that particular building structure. ISO 10848-3:2017 is referred to in ISO 10848‑1:2017, 4.5 as being a supporting part to the frame document and applies to Type B elements that are structurally connected as defined in ISO 10848‑1. The measured quantities can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as ISO 12354‑1 and ISO 12354‑2. The relevant quantity to be measured is selected according to ISO 10848‑1:2017, 4.5. The performance of the building components is expressed either as an overall quantity for the combination of elements and junction (such as Dn,f,ij and/or Ln,f,ij and/or Lne0,f,ij) or as the normalized direction-average velocity level difference  of a junction. Dn,f,ij, Ln,f,ij, Lne0,f,ij and  depend on the actual dimensions of the elements. ","objectID":"67228_0","_highlightResult":{"title":{"value":"<em>ISO</em> 10848-3:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 3: Application to Type B elements when the junction has a substantial influence","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. <em>ISO</em> 10848-3:2017 specifies laboratory and field measurements of buildings for Type B elements (defined in <em>ISO</em> 10848‑1) when the junction has a substantial influence. Laboratory measurements are used to quantify the performance of the junction with suppressed flanking transmission from the laboratory structure. Field measurements are used to characterize the in situ performance and it is not usually possible to suppress unwanted flanking transmission sufficiently; hence, the results can only be considered representative of the performance of that junction when installed in that particular building structure. <em>ISO</em> 10848-3:2017 is referred to in <em>ISO</em> 10848‑1:2017, 4.5 as being a supporting part to the frame document and applies to Type B elements that are structurally connected as defined in <em>ISO</em> 10848‑1. The measured quantities can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as <em>ISO</em> <em>123</em>54‑1 and <em>ISO</em> <em>123</em>54‑2. The relevant quantity to be measured is selected according to <em>ISO</em> 10848‑1:2017, 4.5. The performance of the building components is expressed either as an overall quantity for the combination of elements and junction (such as Dn,f,ij and/or Ln,f,ij and/or Lne0,f,ij) or as the normalized direction-average velocity level difference  of a junction. Dn,f,ij, Ln,f,ij, Lne0,f,ij and  depend on the actual dimensions of the elements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/72/67226","uuid":"fe3f7d1d-c2a5-43e2-aa6d-06cf0496bb8e","title":"ISO 10848-1:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 1: Frame document","status":"Published","year":2017,"order":11,"text":"ISO 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. These measurements are performed in a laboratory test facility or in the field. The performance of the building components is expressed either as an overall quantity for the combination of elements and junction (such as the normalized flanking level difference and/or normalized flanking impact sound pressure level) or as the vibration reduction index of a junction or the normalized direction-average vibration level difference of a junction. Two approaches are used for structure-borne sound sources in buildings, a normalized flanking equipment sound pressure level and a transmission function that can be used to estimate sound pressure levels in a receiving room due to structure-borne excitation by service equipment in a source room. The former approach assumes that flanking transmission is limited to one junction (or no junction if the element supporting the equipment is the separating element), and the latter considers the combination of direct (if any) and all flanking transmission paths. ISO 10848-1:2017 contains definitions, general requirements for test elements and test rooms, and measurement methods. Guidelines are given for the selection of the quantity to be measured, depending on the junction and the types of building elements involved. Other parts of ISO 10848 specify the application for different types of junction and building elements. The quantities characterizing the flanking transmission can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as ISO 12354‑1 and ISO 12354‑2. ","objectID":"67226_0","_highlightResult":{"title":{"value":"<em>ISO</em> 10848-1:2017 Acoustics — Laboratory and field measurement of flanking transmission for airborne, impact and building service equipment sound between adjoining rooms — Part 1: Frame document","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 10848 (all parts) specifies measurement methods to characterize the flanking transmission of one or several building components. These measurements are performed in a laboratory test facility or in the field. The performance of the building components is expressed either as an overall quantity for the combination of elements and junction (such as the normalized flanking level difference and/or normalized flanking impact sound pressure level) or as the vibration reduction index of a junction or the normalized direction-average vibration level difference of a junction. Two approaches are used for structure-borne sound sources in buildings, a normalized flanking equipment sound pressure level and a transmission function that can be used to estimate sound pressure levels in a receiving room due to structure-borne excitation by service equipment in a source room. The former approach assumes that flanking transmission is limited to one junction (or no junction if the element supporting the equipment is the separating element), and the latter considers the combination of direct (if any) and all flanking transmission paths. <em>ISO</em> 10848-1:2017 contains definitions, general requirements for test elements and test rooms, and measurement methods. Guidelines are given for the selection of the quantity to be measured, depending on the junction and the types of building elements involved. Other parts of <em>ISO</em> 10848 specify the application for different types of junction and building elements. The quantities characterizing the flanking transmission can be used to compare different products, or to express a requirement, or as input data for prediction methods, such as <em>ISO</em> <em>123</em>54‑1 and <em>ISO</em> <em>123</em>54‑2. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/04/443","uuid":"61894074-0bfa-488f-a848-c3957e552187","title":"ISO/R 123:1968 Title missing - Legacy paper document","status":"Withdrawn","year":1973,"order":100,"objectID":"443_0","_highlightResult":{"title":{"value":"<em>ISO</em>/R <em>123</em>:1968 Title missing - Legacy paper document","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51402","uuid":"effa37e5-c04d-4937-a9f8-27616bae0c07","title":"ISO/TR 12389:2009 Methods of testing cement — Report of a test programme — Chemical analysis by x-ray fluorescence","status":"Published","year":2021,"order":11,"text":"ISO/TS 12389:2009 describes the results of the inter-laboratory testing of the chemical analysis of cement by x-ray fluorescence. In the first instance, the inter-laboratory testing was carried out in Japan and Asian countries in accordance with JIS R 5204:2002. A total of 30 laboratories, 16 in Japan and 14 outside Japan, participated in the original testing programme. A further 12 European laboratories participated in tests with the same materials in 2005 in accordance with EN 196-2, a development by CEN/TC 51/WG 15/TG 1 of JIS R 5204. The latest version, developed as ISO 29581-2, is, as of the date of publication of this Technical Report, in the process of being circulated for technical enquiry. The test samples used were Portland cement conforming to CEM I of EN 197-1 and a mixture of Portland cement and blast furnace slag. The mixture corresponded to the composition of Portland blast furnace slag cement, class B, specified in JIS R 5211 and CEM III/A of EN 197-1. Cement reference materials for x-ray fluorescence analysis (No. 601A) are used for the calibration standards, and certified reference materials JCA-CRM-1 and JCA-CRM-2 are used as the validation materials. Constituents analysed include SiO 2 , Al 2 O 3 , Fe 2 O 3 , CaO, MgO, SO 3 , Na 2 O, K 2 O, TiO 2 , P 2 O 5 , MnO and SrO. The loss on ignition is also determined. The ISO round robin is a method-performance study conducted under close to optimum conditions with clear calibration and measurement guidelines. This is conducive to producing “best practice” values representative of the ideal situation. However, ISO 29581-2 is intended for use under everyday conditions in laboratories that operate to “good practice”. The results are presented for some international round robins carried out by a large number of laboratories demonstrating the suitability of ISO 29581-2 as a means for comparing the everyday performance of laboratories. ","objectID":"51402_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>89:2009 Methods of testing cement — Report of a test programme — Chemical analysis by x-ray fluorescence","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TS <em>123</em>89:2009 describes the results of the inter-laboratory testing of the chemical analysis of cement by x-ray fluorescence. In the first instance, the inter-laboratory testing was carried out in Japan and Asian countries in accordance with JIS R 5204:2002. A total of 30 laboratories, 16 in Japan and 14 outside Japan, participated in the original testing programme. A further 12 European laboratories participated in tests with the same materials in 2005 in accordance with EN 196-2, a development by CEN/TC 51/WG 15/TG 1 of JIS R 5204. The latest version, developed as <em>ISO</em> 29581-2, is, as of the date of publication of this Technical Report, in the process of being circulated for technical enquiry. The test samples used were Portland cement conforming to CEM I of EN 197-1 and a mixture of Portland cement and blast furnace slag. The mixture corresponded to the composition of Portland blast furnace slag cement, class B, specified in JIS R 5211 and CEM III/A of EN 197-1. Cement reference materials for x-ray fluorescence analysis (No. 601A) are used for the calibration standards, and certified reference materials JCA-CRM-1 and JCA-CRM-2 are used as the validation materials. Constituents analysed include SiO 2 , Al 2 O 3 , Fe 2 O 3 , CaO, MgO, SO 3 , Na 2 O, K 2 O, TiO 2 , P 2 O 5 , MnO and SrO. The loss on ignition is also determined. The <em>ISO</em> round robin is a method-performance study conducted under close to optimum conditions with clear calibration and measurement guidelines. This is conducive to producing “best practice” values representative of the ideal situation. However, <em>ISO</em> 29581-2 is intended for use under everyday conditions in laboratories that operate to “good practice”. The results are presented for some international round robins carried out by a large number of laboratories demonstrating the suitability of <em>ISO</em> 29581-2 as a means for comparing the everyday performance of laboratories. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/75/37537","uuid":"77091190-1b76-4772-83b0-2f1517e9b9a6","title":"ISO/TR 12391-4:2002 Gas cylinders — Refillable seamless steel — Performance tests — Part 4: Flawed-cylinder cycle test","status":"Published","year":2017,"order":11,"text":"This part of ISO/TR 12391 applies to seamless steel refillable cylinders of all sizes from 0,5 l up to and including 150 l water capacity produced of steel with tensile strength, R m, greater than 1 100 MPa. It can also be applied to cylinders produced from steels used at lower tensile strengths. In particular, it provides the technical rationale and background to guide future alterations of existing ISO standards or for developing advanced design standards. This part of ISO/TR 12391 is a summary and compilation of the test results obtained during the development of the \"flawed-cylinder cycle test\". The \"flawed-cylinder cycle test\" was developed as part of a co-operative project under the direction of ISO/TC 58/SC 3/WG 14. The \"flawed-cylinder cycle test\" is a test method to evaluate the fatigue performance of steel cylinders that are used to transport high pressure, compressed gases. The concept and development of the flawed-cylinder cycle test is described in ISO/TR 12391-1. The details of the test method and the criteria for acceptable fatigue performance of steel cylinders are given in 9.2.6 of ISO 9809-2:2000, \"flawed-cylinder cycle test\". In this part of ISO/TR 12391, test results are reported for more than a hundred flawed-cylinder cycle tests that were conducted on seamless steel cylinders ranging in measured tensile strength from less than 800 MPa to greater than 1 350 MPa. The test method is intended to be used for the selection of materials and design parameters in the development of new cylinder designs. ","objectID":"37537_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>91-4:2002 Gas cylinders — Refillable seamless steel — Performance tests — Part 4: Flawed-cylinder cycle test","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This part of <em>ISO</em>/TR <em>123</em>91 applies to seamless steel refillable cylinders of all sizes from 0,5 l up to and including 150 l water capacity produced of steel with tensile strength, R m, greater than 1 100 MPa. It can also be applied to cylinders produced from steels used at lower tensile strengths. In particular, it provides the technical rationale and background to guide future alterations of existing <em>ISO</em> standards or for developing advanced design standards. This part of <em>ISO</em>/TR <em>123</em>91 is a summary and compilation of the test results obtained during the development of the \"flawed-cylinder cycle test\". The \"flawed-cylinder cycle test\" was developed as part of a co-operative project under the direction of <em>ISO</em>/TC 58/SC 3/WG 14. The \"flawed-cylinder cycle test\" is a test method to evaluate the fatigue performance of steel cylinders that are used to transport high pressure, compressed gases. The concept and development of the flawed-cylinder cycle test is described in <em>ISO</em>/TR <em>123</em>91-1. The details of the test method and the criteria for acceptable fatigue performance of steel cylinders are given in 9.2.6 of <em>ISO</em> 9809-2:2000, \"flawed-cylinder cycle test\". In this part of <em>ISO</em>/TR <em>123</em>91, test results are reported for more than a hundred flawed-cylinder cycle tests that were conducted on seamless steel cylinders ranging in measured tensile strength from less than 800 MPa to greater than 1 350 MPa. The test method is intended to be used for the selection of materials and design parameters in the development of new cylinder designs. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/74/37437","uuid":"9cc28534-766d-46f6-8465-7ab7ba0b19c6","title":"ISO/TR 12391-3:2002 Gas cylinders — Refillable seamless steel — Performance tests — Part 3: Fracture performance tests — Cyclical burst tests","status":"Published","year":2017,"order":11,"text":"ISO/TR 12391-3 applies to seamless refillable cylinders of all sizes from 0,5 l up to and including 150 l water capacity produced of steel with tensile strength greater than 1 100 MPa. It can also be applied to cylinders produced from steels used at lower tensile strengths. In particular, it provides the technical rationale and background to guide future alterations of existing ISO standards or for developing advanced design standards. ISO/TR 12391-3 is a summary and compilation of the test results obtained during the development of the Flawed-cylinder Cyclical-burst Test. The test is an alternate test method to the flawed-cylinder burst test with monotonic pressurization and is used to evaluate the fracture performance of steel cylinders which are used to transport high-pressure compressed gases. In ISO/TR 12391-3 test results are reported for more than one hundred flawed-cylinder cyclical burst tests that were conducted on seamless steel cylinders that ranged in tensile strength from 750 MPa to 1 210 MPa. The test method is intended to be used both for the selection of materials and to establish design parameters in the development of new cylinders as well as for an efficient quality control test to be used during the production of cylinders. ","objectID":"37437_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>91-3:2002 Gas cylinders — Refillable seamless steel — Performance tests — Part 3: Fracture performance tests — Cyclical burst tests","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>91-3 applies to seamless refillable cylinders of all sizes from 0,5 l up to and including 150 l water capacity produced of steel with tensile strength greater than 1 100 MPa. It can also be applied to cylinders produced from steels used at lower tensile strengths. In particular, it provides the technical rationale and background to guide future alterations of existing <em>ISO</em> standards or for developing advanced design standards. <em>ISO</em>/TR <em>123</em>91-3 is a summary and compilation of the test results obtained during the development of the Flawed-cylinder Cyclical-burst Test. The test is an alternate test method to the flawed-cylinder burst test with monotonic pressurization and is used to evaluate the fracture performance of steel cylinders which are used to transport high-pressure compressed gases. In <em>ISO</em>/TR <em>123</em>91-3 test results are reported for more than one hundred flawed-cylinder cyclical burst tests that were conducted on seamless steel cylinders that ranged in tensile strength from 750 MPa to 1 210 MPa. The test method is intended to be used both for the selection of materials and to establish design parameters in the development of new cylinders as well as for an efficient quality control test to be used during the production of cylinders. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/74/37436","uuid":"754d2d48-f056-42e1-985c-f3fd8890e63c","title":"ISO/TR 12391-2:2002 Gas cylinders — Refillable seamless steel — Performance tests — Part 2: Fracture performance tests — Monotonic burst tests","status":"Published","year":2017,"order":11,"text":"This part of ISO/TR 12391 is a summary and compilation of the test results obtained during the development of the \"Flawed-Cylinder Burst Test\". The concept and development of the flawed cylinder burst test is described in ISO/TR 12391-1. The test is a method for evaluating the fracture performance of steel cylinders that are used to transport high pressure, compressed gases. In this part of ISO/TR 12391, test results are reported for several hundred flawed cylinder burst tests that were conducted on seamless steel cylinders ranging in tensile strength from less than 750 MPa up to about 1 400 MPa. This test method has been shown to reliably predict the fracture performance of seamless steel cylinders. The test method is intended to be used both for the selection of materials and design parameters in the development of new cylinder designs as well as for an efficient quality control test to be used during the production of cylinders. ","objectID":"37436_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>91-2:2002 Gas cylinders — Refillable seamless steel — Performance tests — Part 2: Fracture performance tests — Monotonic burst tests","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This part of <em>ISO</em>/TR <em>123</em>91 is a summary and compilation of the test results obtained during the development of the \"Flawed-Cylinder Burst Test\". The concept and development of the flawed cylinder burst test is described in <em>ISO</em>/TR <em>123</em>91-1. The test is a method for evaluating the fracture performance of steel cylinders that are used to transport high pressure, compressed gases. In this part of <em>ISO</em>/TR <em>123</em>91, test results are reported for several hundred flawed cylinder burst tests that were conducted on seamless steel cylinders ranging in tensile strength from less than 750 MPa up to about 1 400 MPa. This test method has been shown to reliably predict the fracture performance of seamless steel cylinders. The test method is intended to be used both for the selection of materials and design parameters in the development of new cylinder designs as well as for an efficient quality control test to be used during the production of cylinders. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/35/33518","uuid":"3c347d50-60b2-4039-8cc6-2bc8982adf43","title":"ISO/TR 12391-1:2001 Gas cylinders — Refillable seamless steel — Performance tests — Part 1: Philosophy, background and conclusions","status":"Published","year":2017,"order":11,"text":"This part of ISO/TR 12931 applies to seamless steel refillable cylinders of all sizes from 0,5 l up to and including 150 l water capacity produced of steel with tensile strength ( R m) greater than 1 100 MPa. It can also be applied to cylinders produced of steels used at lower tensile strengths. In particular, it provides the technical rationale and background to guide future alterations of existing ISO standards or for developing advanced design standards. ","objectID":"33518_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>91-1:2001 Gas cylinders — Refillable seamless steel — Performance tests — Part 1: Philosophy, background and conclusions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This part of <em>ISO</em>/TR 12931 applies to seamless steel refillable cylinders of all sizes from 0,5 l up to and including 150 l water capacity produced of steel with tensile strength ( R m) greater than 1 100 MPa. It can also be applied to cylinders produced of steels used at lower tensile strengths. In particular, it provides the technical rationale and background to guide future alterations of existing <em>ISO</em> standards or for developing advanced design standards. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/50/65083","uuid":"84bdf3be-6cfc-433b-83f8-dbea95928ff0","title":"ISO/TR 12349-2:2015 Road vehicles — Dummies for restraint system testing — Part 2: Child dummies","status":"Published","year":2015,"order":11,"text":"ISO/TR 12349-2:2015 specifies the infant and child crash test dummies that are recommended by ISO for use in evaluating child restraints in frontal impacts and out-of-position interactions with frontal or side airbags. ","objectID":"65083_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>49-2:2015 Road vehicles — Dummies for restraint system testing — Part 2: Child dummies","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>49-2:2015 specifies the infant and child crash test dummies that are recommended by <em>ISO</em> for use in evaluating child restraints in frontal impacts and out-of-position interactions with frontal or side airbags. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/50/65082","uuid":"2e2df71a-e6b7-47a1-9466-13584dff9fe5","title":"ISO/TR 12349-1:2015 Road vehicles — Dummies for restraint system testing — Part 1: Adult dummies","status":"Published","year":2015,"order":11,"text":"ISO/TR 12349-1:2015 specifies the adult crash test dummies that are recommended by ISO for use in evaluating the occupant protection potential of restraint systems in frontal, side, and rear impact test procedures and out-of-position airbag test procedures. ","objectID":"65082_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>49-1:2015 Road vehicles — Dummies for restraint system testing — Part 1: Adult dummies","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>49-1:2015 specifies the adult crash test dummies that are recommended by <em>ISO</em> for use in evaluating the occupant protection potential of restraint systems in frontal, side, and rear impact test procedures and out-of-position airbag test procedures. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51346","uuid":"62826984-9276-44f0-9a7a-7f734bc14b92","title":"ISO/TR 12310:2015 Health informatics — Principles and guidelines for the measurement of conformance in the implementation of terminological systems","status":"Published","year":2015,"order":11,"text":"ISO/TR 12310:2015 is to define a framework of good practices for terminology system maintenance and the principles for which conformance can be demonstrated. The primary focus is the application of terminology system to Electronic Health Record (EHR) systems, although the principles and guidelines can be applied broadly in health informatics The scope of ISO/TR 12310:2015 will include, at a minimum, the following considerations for keeping terminology systems and associated reference material clinically and/or technically relevant and valid: ?   governance models and practices; ?   high level processes; ?   requirements for managing the change. ","objectID":"51346_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>10:2015 Health informatics — Principles and guidelines for the measurement of conformance in the implementation of terminological systems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>10:2015 is to define a framework of good practices for terminology system maintenance and the principles for which conformance can be demonstrated. The primary focus is the application of terminology system to Electronic Health Record (EHR) systems, although the principles and guidelines can be applied broadly in health informatics The scope of <em>ISO</em>/TR <em>123</em>10:2015 will include, at a minimum, the following considerations for keeping terminology systems and associated reference material clinically and/or technically relevant and valid: ?   governance models and practices; ?   high level processes; ?   requirements for managing the change. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51344","uuid":"26b66fb1-1c0b-460d-9718-b94393f621bf","title":"ISO/TR 12300:2014 Health informatics — Principles of mapping between terminological systems","status":"Published","year":2014,"order":11,"text":"ISO/TR 12300:2014 provides guidance for organizations charged with creating or applying maps to meet their business needs. It explains the risks inherent in the mapping process and discusses the issues that need to be considered in the development, maintenance, and use of maps in health care. This Technical Report also identifies variations in process, precision, and administration when mapping for different purposes and in different environments. Importantly, this Technical Report establishes and harmonizes the basic principles for developing, maintaining, and using maps and gives guidelines for good practice that underpin the mapping process. Terminological resources includes terminologies, classifications, and code systems used in the regulatory environment as it relates to healthcare and reporting requirements in healthcare. This Technical Report is general in nature and does not describe the specific methods applied in the mapping process nor does it describe maps between databases and data sets, even though many of the principles stated here will apply to those types of maps. This Technical Report does not include consideration of the intellectual property rights and expectations of the owners of terminologies or classifications. It is the responsibility of the mapper and process to ensure that these legal rights are protected and acknowledged as part of the mapping processes. ","objectID":"51344_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>00:2014 Health informatics — Principles of mapping between terminological systems","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>00:2014 provides guidance for organizations charged with creating or applying maps to meet their business needs. It explains the risks inherent in the mapping process and discusses the issues that need to be considered in the development, maintenance, and use of maps in health care. This Technical Report also identifies variations in process, precision, and administration when mapping for different purposes and in different environments. Importantly, this Technical Report establishes and harmonizes the basic principles for developing, maintaining, and using maps and gives guidelines for good practice that underpin the mapping process. Terminological resources includes terminologies, classifications, and code systems used in the regulatory environment as it relates to healthcare and reporting requirements in healthcare. This Technical Report is general in nature and does not describe the specific methods applied in the mapping process nor does it describe maps between databases and data sets, even though many of the principles stated here will apply to those types of maps. This Technical Report does not include consideration of the intellectual property rights and expectations of the owners of terminologies or classifications. It is the responsibility of the mapper and process to ensure that these legal rights are protected and acknowledged as part of the mapping processes. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/58/55888","uuid":"52dd67d0-7f2a-447a-966a-cd78283c91bc","title":"ISO/TR 12350:2013 Road vehicles — Injury risk curves for the evaluation of occupant protection in side impact tests","status":"Published","year":2013,"order":11,"text":"ISO/TR 12350:2013 provides injury risk curves to assess occupant protection in side impact tests. The curves are given for the WorldSID 50th, a mid-size adult male side impact dummy. These dummies are used during tests carried out according to ISO 10997 or which are under investigation by regulatory bodies and consumer testing organizations. ","objectID":"55888_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>50:2013 Road vehicles — Injury risk curves for the evaluation of occupant protection in side impact tests","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>50:2013 provides injury risk curves to assess occupant protection in side impact tests. The curves are given for the WorldSID 50th, a mid-size adult male side impact dummy. These dummies are used during tests carried out according to <em>ISO</em> 10997 or which are under investigation by regulatory bodies and consumer testing organizations. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51345","uuid":"7dffa07a-d452-4a59-872b-a2791be54bcc","title":"ISO/TR 12309:2009 Health informatics — Guidelines for terminology development organizations","status":"Published","year":2009,"order":11,"text":"ISO/TR 12309:2009 specifies principles and processes that should be exhibited by developers of healthcare terminologies in support of international healthcare terminology standardization. The primary target group for ISO/TR 12309:2009 is those establishing or reviewing organizations , and those evaluating the services or products maintained by such organizations , in the context of international healthcare terminology standardization. It complements standards such as ISO 17115 and ISO 17117 (which address the content of terminologies) by specifying good governance requirements for the lifecycle of those terminologies. ","objectID":"51345_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>09:2009 Health informatics — Guidelines for terminology development organizations","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>09:2009 specifies principles and processes that should be exhibited by developers of healthcare terminologies in support of international healthcare terminology standardization. The primary target group for <em>ISO</em>/TR <em>123</em>09:2009 is those establishing or reviewing organizations , and those evaluating the services or products maintained by such organizations , in the context of international healthcare terminology standardization. It complements standards such as <em>ISO</em> 17115 and <em>ISO</em> 17117 (which address the content of terminologies) by specifying good governance requirements for the lifecycle of those terminologies. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/78/27880","uuid":"c8157033-02c8-4170-be9e-ae7fd11f45aa","title":"ISO/TR 12351:1999 Road vehicles — Determination of head contact and duration in impact tests","status":"Published","year":1999,"order":11,"text":"This Technical Report gives methods to determine the instant of head contact and the duration of this contact during impact tests. The determination of head engagement and disengagement times are used in the calculation of the contact head injury criteria (HIC). ","objectID":"27880_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>51:1999 Road vehicles — Determination of head contact and duration in impact tests","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"This Technical Report gives methods to determine the instant of head contact and the duration of this contact during impact tests. The determination of head engagement and disengagement times are used in the calculation of the contact head injury criteria (HIC). ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/75/77506","uuid":"9890d5e2-379d-4a05-b195-a8fadda6f825","title":"ISO/DIS 12311 Personal protective equipment — Test methods for sunglasses and related eyewear","status":"Under development","year":2021,"order":12,"objectID":"77506_0","_highlightResult":{"title":{"value":"<em>ISO</em>/DIS <em>123</em>11 Personal protective equipment — Test methods for sunglasses and related eyewear","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/73/77321","uuid":"c38e7c89-beeb-4f53-89a3-cd15190c8f85","title":"ISO/FDIS 12312-1 Eye and face protection — Sunglasses and related eyewear — Part 1: Sunglasses for general use","status":"Under development","year":2021,"order":12,"objectID":"77321_0","_highlightResult":{"title":{"value":"<em>ISO</em>/FDIS <em>123</em>12-1 Eye and face protection — Sunglasses and related eyewear — Part 1: Sunglasses for general use","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/26/72628","uuid":"3d61a1de-13a4-4eb3-a51e-c1beb2451c48","title":"ISO/FDIS 12312-3 Eye and face protection — Sunglasses and related eyewear — Part 3: Sunglasses for running, cycling and similar active lifestyles","status":"Under development","year":2021,"order":12,"objectID":"72628_0","_highlightResult":{"title":{"value":"<em>ISO</em>/FDIS <em>123</em>12-3 Eye and face protection — Sunglasses and related eyewear — Part 3: Sunglasses for running, cycling and similar active lifestyles","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/71/77118","uuid":"7fca266e-6b39-4f84-aa9c-1dc26b0c5109","title":"ISO/CD 12301 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics","status":"Deleted","year":2022,"order":100,"objectID":"77118_0","_highlightResult":{"title":{"value":"<em>ISO</em>/CD <em>123</em>01 Plain bearings — Quality control techniques and inspection of geometrical and material quality characteristics","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/01/30149","uuid":"90d9924d-1b86-4f12-9470-c950ed62931a","title":"ISO/TR 12349-2:1999 Road vehicles — Dummies for restraint system testing — Part 2: Child dummies","status":"Withdrawn","year":2015,"order":100,"objectID":"30149_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>49-2:1999 Road vehicles — Dummies for restraint system testing — Part 2: Child dummies","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/01/30148","uuid":"514787ae-2c71-4add-9e26-14ad676c49c4","title":"ISO/TR 12349-1:1999 Road vehicles — Dummies for restraint system testing — Part 1: Adult dummies","status":"Withdrawn","year":2015,"order":100,"objectID":"30148_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>49-1:1999 Road vehicles — Dummies for restraint system testing — Part 1: Adult dummies","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/78/37835","uuid":"e5993559-bee3-43b1-8da7-4155a11af47b","title":"ISO/TR 12350:2004 Road vehicles - Injury risk curves for evaluation of occupant protection in side impact","status":"Withdrawn","year":2013,"order":100,"text":"ISO/TR 12350:2004 provides injury risk curves for the evaluation of occupant protection in side impacts on road vehicles. The measurements concerned are performed on two lateral impact dummies, EuroSID 1 and BioSID, which present acceptable levels of biofidelity response in accordance with ISO/TR 9790 and are used in tests carried out according to ISO 10997. ","objectID":"37835_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>50:2004 Road vehicles - Injury risk curves for evaluation of occupant protection in side impact","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"<em>ISO</em>/TR <em>123</em>50:2004 provides injury risk curves for the evaluation of occupant protection in side impacts on road vehicles. The measurements concerned are performed on two lateral impact dummies, EuroSID 1 and BioSID, which present acceptable levels of biofidelity response in accordance with <em>ISO</em>/TR 9790 and are used in tests carried out according to <em>ISO</em> 10997. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/61/26108","uuid":"4e10ffb6-da25-4c6c-8017-9f67c6eb0532","title":"ISO/TR 12369:1994/Amd 1:1999 Agricultural tractors and machinery — Electrical power transmission connectors — Amendment 1","status":"Withdrawn","year":2013,"order":100,"objectID":"26108_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>69:1994/Amd 1:1999 Agricultural tractors and machinery — Electrical power transmission connectors — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/15/1536","uuid":"b5cf2ce2-1954-4692-ac41-0fbbf30f3d22","title":"ISO/TR 12369:1994 Agricultural tractors and machinery — Electrical power transmission connectors","status":"Withdrawn","year":2013,"order":100,"text":"Gives the essential interface dimension of a socket and plug coupling to transmit 12 V electrical power from agricultural tractors to agricultural implements and machinery. Does not apply to any other voltage system. ","objectID":"1536_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>69:1994 Agricultural tractors and machinery — Electrical power transmission connectors","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]},"text":{"value":"Gives the essential interface dimension of a socket and plug coupling to transmit 12 V electrical power from agricultural tractors to agricultural implements and machinery. Does not apply to any other voltage system. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/15/1513","uuid":"ad6525d8-10e9-4217-a479-0b02bbad43d2","title":"ISO/TR 12343:1997 Road vehicles — Symbols for electrotechnical diagrams","status":"Withdrawn","year":2013,"order":100,"objectID":"1513_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>123</em>43:1997 Road vehicles — Symbols for electrotechnical diagrams","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5850","uuid":"ec159892-1183-4b83-9e6f-4d57b3748d20","title":"ISO/R 1231:1970 Withdrawal of ISO/R 1231-1970","status":"Withdrawn","year":1980,"order":100,"objectID":"5850_0","_highlightResult":{"title":{"value":"<em>ISO</em>/R <em>123</em>1:1970 Withdrawal of <em>ISO</em>/R <em>123</em>1-1970","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/10/51016","uuid":"6de497e1-a26e-448f-adf4-2e94d952af6b","title":"ISO 8381:2008 Milk-based infant foods — Determination of fat content — Gravimetric method (Reference method)","status":"Published","year":2017,"order":11,"text":"ISO 8381¦IDF 123:2008 specifies the reference method for the determination of the fat content of milk-based infant foods. The method is applicable to liquid, concentrated and dried milk-based infant foods with no, or not more than a mass fraction of 5 % (dry matter) of such added matter as starch, dextrin, vegetables, fruit and meat. The method is not applicable to products which do not dissolve completely in ammonia owing to the presence of starch or dextrin at mass fractions of more than a few percent, or to the presence of hard lumps. The method is also not applicable to products which contain free fatty acids in significant quantities. The results obtained for these products will be too low. ","objectID":"51016_0","_highlightResult":{"title":{"value":"<em>ISO</em> 8381:2008 Milk-based infant foods — Determination of fat content — Gravimetric method (Reference method)","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 8381¦IDF <em>123</em>:2008 specifies the reference method for the determination of the fat content of milk-based infant foods. The method is applicable to liquid, concentrated and dried milk-based infant foods with no, or not more than a mass fraction of 5 % (dry matter) of such added matter as starch, dextrin, vegetables, fruit and meat. The method is not applicable to products which do not dissolve completely in ammonia owing to the presence of starch or dextrin at mass fractions of more than a few percent, or to the presence of hard lumps. The method is also not applicable to products which contain free fatty acids in significant quantities. The results obtained for these products will be too low. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","123"]}}}],"nbHits":144,"page":0,"nbPages":2,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 123","params":"query=ISO+123&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":3}
60
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/28/72849","uuid":"14819547-4274-4772-96fd-13a48f9559a0","title":"ISO 125:2020 Natural rubber latex concentrate — Determination of alkalinity","status":"Published","year":2020,"order":11,"text":"This document specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. NOTE    A method for the determination of the alkalinity of polychloroprene latex is specified in ISO 13773. ","objectID":"72849_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:2020 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. NOTE    A method for the determination of the alkalinity of polychloroprene latex is specified in <em>ISO</em> 13773. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/92/59265","uuid":"555cf5b2-606b-4fb0-a80f-0cd3dd2ff916","title":"ISO 125:2011 Natural rubber latex concentrate — Determination of alkalinity","status":"Withdrawn","year":2020,"order":100,"text":"ISO 125:2011 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","objectID":"59265_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:2011 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>:2011 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/70/27006","uuid":"8b786006-44e1-44af-abaf-d1cfa5b43881","title":"ISO 125:2003 Natural rubber latex concentrate — Determination of alkalinity","status":"Withdrawn","year":2011,"order":100,"text":"ISO 125:2003 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","objectID":"27006_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:2003 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>:2003 specifies a method for the determination of the alkalinity of natural rubber latex concentrate. The method is not necessarily suitable for latices from natural sources other than Hevea brasiliensis or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3931","uuid":"df9a2ef4-f3cd-4203-9f5e-1cab903195d1","title":"ISO 125:1990 Natural rubber latex concentrate — Determination of alkalinity","status":"Withdrawn","year":2003,"order":100,"text":"Covers the method for materials which contain preservative agents and have been submitted to some type of concentration process. Replaces the second edition (ISO 125-1977). ","objectID":"3931_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:1990 Natural rubber latex concentrate — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Covers the method for materials which contain preservative agents and have been submitted to some type of concentration process. Replaces the second edition (<em>ISO</em> <em>125</em>-1977). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3930","uuid":"8014c0c4-04b2-45f4-b650-d92194bf9a19","title":"ISO 125:1983 Rubber latex, natural — Determination of alkalinity","status":"Withdrawn","year":1990,"order":100,"objectID":"3930_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:1983 Rubber latex, natural — Determination of alkalinity","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/16/1686","uuid":"9ca69834-968d-4270-99c3-42b3066c93be","title":"ISO 125:1977 Title missing - Legacy paper document","status":"Withdrawn","year":1982,"order":100,"objectID":"1686_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:1977 Title missing - Legacy paper document","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/16/1684","uuid":"f85d5e53-e9fe-4696-b8ca-3357cb6c1873","title":"ISO 125:1977 Title missing - Legacy paper document","status":"Withdrawn","year":1982,"order":100,"objectID":"1684_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:1977 Title missing - Legacy paper document","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/16/1683","uuid":"3f0eb0d1-ab0e-42f2-af0d-39d6660c4c58","title":"ISO 125:1974 Title missing - Legacy paper document","status":"Withdrawn","year":1979,"order":100,"objectID":"1683_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>:1974 Title missing - Legacy paper document","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/49/64988","uuid":"fc4e9639-6999-4e9e-a2c2-1c043980f5a5","title":"ISO 12572:2016 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties — Cup method","status":"Published","year":2022,"order":11,"text":"ISO 12572:2016 specifies a method based on cup tests for determining the water vapour permeance of building products and the water vapour permeability of building materials under isothermal conditions. Different sets of test conditions are specified. The general principles are applicable to all hygroscopic and non-hygroscopic building materials and products, including insulation materials and including those with facings and integral skins. Annexes give details of test methods suitable for different material types. The results obtained by this method are suitable for design purposes, production control and for inclusion in product specifications. ","objectID":"64988_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>72:2016 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties — Cup method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>72:2016 specifies a method based on cup tests for determining the water vapour permeance of building products and the water vapour permeability of building materials under isothermal conditions. Different sets of test conditions are specified. The general principles are applicable to all hygroscopic and non-hygroscopic building materials and products, including insulation materials and including those with facings and integral skins. Annexes give details of test methods suitable for different material types. The results obtained by this method are suitable for design purposes, production control and for inclusion in product specifications. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/25/62574","uuid":"b2c4da80-02ac-46c2-aa23-67926d79dcc6","title":"ISO 12540:2017 Glass in building — Tempered soda lime silicate safety glass","status":"Published","year":2022,"order":11,"text":"ISO 12540:2017 covers product definitions, product characteristics, i.e. tolerances, flatness, edgework, etc., fracture characteristics, including fragmentation, and the physical and mechanical characteristics of flat tempered soda lime silicate safety glass for use in buildings. ISO 12540:2017 does not cover curved (bent) glass according to ISO 11485. Other requirements, not specified in this document, can apply to thermally toughened soda lime silicate safety glass which is incorporated into assemblies, e.g. laminated glass or insulating glass units, or undergo an additional treatment, e.g. coating. The additional requirements are specified in the appropriate glass product standard. Thermally toughened soda lime silicate safety glass, in this case, does not lose its mechanical or thermal characteristics. ","objectID":"62574_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>40:2017 Glass in building — Tempered soda lime silicate safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>40:2017 covers product definitions, product characteristics, i.e. tolerances, flatness, edgework, etc., fracture characteristics, including fragmentation, and the physical and mechanical characteristics of flat tempered soda lime silicate safety glass for use in buildings. <em>ISO</em> <em>125</em>40:2017 does not cover curved (bent) glass according to <em>ISO</em> 11485. Other requirements, not specified in this document, can apply to thermally toughened soda lime silicate safety glass which is incorporated into assemblies, e.g. laminated glass or insulating glass units, or undergo an additional treatment, e.g. coating. The additional requirements are specified in the appropriate glass product standard. Thermally toughened soda lime silicate safety glass, in this case, does not lose its mechanical or thermal characteristics. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/04/50473","uuid":"b74f62a6-9e76-4be0-841f-ae1e0f934a6e","title":"ISO 12500-4:2009 Filters for compressed air — Methods of test — Part 4: Water","status":"Published","year":2022,"order":11,"text":"The test method described in ISO 12500-4:2009 is designed to determine the water-removal efficiency and operational pressure drop of any device designed for water removal from compressed air described as wall flow in accordance with ISO 8573-2. ","objectID":"50473_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-4:2009 Filters for compressed air — Methods of test — Part 4: Water","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"The test method described in <em>ISO</em> <em>125</em>00-4:2009 is designed to determine the water-removal efficiency and operational pressure drop of any device designed for water removal from compressed air described as wall flow in accordance with <em>ISO</em> 8573-2. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/95/79595","uuid":"f8577a09-6841-4ab3-a003-c8e59da08c43","title":"ISO 12571:2021 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","status":"Published","year":2021,"order":11,"text":"This document specifies two alternative methods for determining hygroscopic sorption properties of porous building materials and products: a) using desiccators and weighing cups (desiccator method); b) using a climatic chamber (climatic chamber method). The desiccator method is the reference method. This document does not specify the method for sampling. The methods specified in this document can be used to determine the moisture content of a sample in equilibrium with air at a specific temperature and humidity. ","objectID":"79595_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>71:2021 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies two alternative methods for determining hygroscopic sorption properties of porous building materials and products: a) using desiccators and weighing cups (desiccator method); b) using a climatic chamber (climatic chamber method). The desiccator method is the reference method. This document does not specify the method for sampling. The methods specified in this document can be used to determine the moisture content of a sample in equilibrium with air at a specific temperature and humidity. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/55/75501","uuid":"88f93119-1a89-49b7-800f-3c720cdb9ee5","title":"ISO 12543-6:2021 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","status":"Published","year":2021,"order":11,"text":"This document specifies defects of finished sizes and test methods with regard to the appearance of laminated glass and laminated safety glass when looking through the glass. All references to laminated glass in this document refer to both laminated glass and laminated safety glass. NOTE      Special attention is paid to acceptability criteria in the vision area. This document is applicable to finished sizes at the time of supply. ","objectID":"75501_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6:2021 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies defects of finished sizes and test methods with regard to the appearance of laminated glass and laminated safety glass when looking through the glass. All references to laminated glass in this document refer to both laminated glass and laminated safety glass. NOTE      Special attention is paid to acceptability criteria in the vision area. This document is applicable to finished sizes at the time of supply. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/55/75500","uuid":"439a9e94-bfe3-4f78-990c-924ff4ee4c91","title":"ISO 12543-5:2021 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","status":"Published","year":2021,"order":11,"text":"This document specifies dimensions, limit deviations and edge finishes of laminated glass and laminated safety glass for use in building. This document is not applicable to panes having an area less than 0,05 m 2 . ","objectID":"75500_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-5:2021 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies dimensions, limit deviations and edge finishes of laminated glass and laminated safety glass for use in building. This document is not applicable to panes having an area less than 0,05 m 2 . ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/54/75499","uuid":"7f8ae6c7-185e-452d-b871-280e17e2b9a2","title":"ISO 12543-4:2021 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","status":"Published","year":2021,"order":11,"text":"This document specifies test methods relating to resistance to high temperature, humidity and radiation for laminated glass and laminated safety glass for use in building. ","objectID":"75499_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-4:2021 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies test methods relating to resistance to high temperature, humidity and radiation for laminated glass and laminated safety glass for use in building. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/54/75498","uuid":"6a3eecfa-05b4-46ef-a465-b851c433e06b","title":"ISO 12543-3:2021 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","status":"Published","year":2021,"order":11,"text":"This document specifies performance requirements for laminated glass as defined in ISO 12543-1. NOTE       Any defects that are found in installed laminated safety glass are dealt with in ISO 12543-6. ","objectID":"75498_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-3:2021 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies performance requirements for laminated glass as defined in <em>ISO</em> <em>125</em>43-1. NOTE       Any defects that are found in installed laminated safety glass are dealt with in <em>ISO</em> <em>125</em>43-6. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/54/75497","uuid":"f085ce52-8c1c-4868-b348-2987a1a2b618","title":"ISO 12543-2:2021 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","status":"Published","year":2021,"order":11,"text":"This document specifies performance requirements for laminated safety glass as defined in ISO 12543-1. NOTE       Any defects that are found in installed laminated safety glass are dealt with in ISO 12543-6. ","objectID":"75497_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-2:2021 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document specifies performance requirements for laminated safety glass as defined in <em>ISO</em> <em>125</em>43-1. NOTE       Any defects that are found in installed laminated safety glass are dealt with in <em>ISO</em> <em>125</em>43-6. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/28/72871","uuid":"37257217-0b94-457a-ba48-5cced0197f71","title":"ISO 12543-1:2021 Glass in building — Laminated glass and laminated safety glass — Part 1: Vocabulary and description of component parts","status":"Published","year":2021,"order":11,"text":"This document defines terms and describes component parts for laminated glass and laminated safety glass for use in building. ","objectID":"72871_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-1:2021 Glass in building — Laminated glass and laminated safety glass — Part 1: Vocabulary and description of component parts","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This document defines terms and describes component parts for laminated glass and laminated safety glass for use in building. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/20/72090","uuid":"8a16ecd1-73bf-4f32-9c09-fec5b403ec1e","title":"ISO 12511:1997/Amd 1:2021 Earth-moving machinery — Hour meters — Amendment 1","status":"Published","year":2021,"order":11,"objectID":"72090_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>11:1997/Amd 1:2021 Earth-moving machinery — Hour meters — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/84/68415","uuid":"01d7b214-9da5-4e44-b158-6bceaac0dc37","title":"ISO 12505-2:2016 Skin barrier for ostomy aids — Test methods — Part 2: Wet integrity and adhesive strength","status":"Published","year":2021,"order":11,"text":"ISO 12505-2:2016 specifies test methods dealing with face plates of skin barriers for ostomy aids. ISO 12505-2:2016 does not cover medical properties (cytotoxicity, sensitization, irritation/intracutaneous reactivity, buffering effect, microbiological effects, etc.). ","objectID":"68415_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>05-2:2016 Skin barrier for ostomy aids — Test methods — Part 2: Wet integrity and adhesive strength","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>05-2:2016 specifies test methods dealing with face plates of skin barriers for ostomy aids. <em>ISO</em> <em>125</em>05-2:2016 does not cover medical properties (cytotoxicity, sensitization, irritation/intracutaneous reactivity, buffering effect, microbiological effects, etc.). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/15/61598","uuid":"348ddefe-eeba-416a-a4a5-764aaaed0f0a","title":"ISO 12578:2016 Timber structures — Glued laminated timber — Component performance requirements","status":"Published","year":2021,"order":11,"text":"ISO 12578:2016 specifies requirements for the components of glued laminated timber members for structural use. ISO 12578:2016 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, this International Standard also applies to broad leaf species if the tests specified in this International Standard show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather resistant adhesives (see 5.3). ISO 12578:2016 does not apply to the determination of strength and stiffness characteristics. Annex B contains informative materials for formaldehyde emission. ","objectID":"61598_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>78:2016 Timber structures — Glued laminated timber — Component performance requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>78:2016 specifies requirements for the components of glued laminated timber members for structural use. <em>ISO</em> <em>125</em>78:2016 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, this International Standard also applies to broad leaf species if the tests specified in this International Standard show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather resistant adhesives (see 5.3). <em>ISO</em> <em>125</em>78:2016 does not apply to the determination of strength and stiffness characteristics. Annex B contains informative materials for formaldehyde emission. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/01/60178","uuid":"3b12f72a-90ef-4b31-8924-b041b2f872af","title":"ISO 12505-1:2014 Skin barrier for ostomy aids — Test methods — Part 1: Size, surface pH and water-absorbency","status":"Published","year":2021,"order":11,"text":"ISO 12505-1:2014 specifies test methods dealing with a face plate of skin barriers for ostomy aids. ","objectID":"60178_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>05-1:2014 Skin barrier for ostomy aids — Test methods — Part 1: Size, surface pH and water-absorbency","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>05-1:2014 specifies test methods dealing with a face plate of skin barriers for ostomy aids. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51529","uuid":"fd619bd6-bb2d-4424-8351-f4a25ffcd3e8","title":"ISO 12573:2010 Aircraft — Tubing tolerances — Inch series","status":"Published","year":2021,"order":11,"text":"ISO 12573:2010 specifies the dimensional tolerances to be applied to round section inch series tubing used in aircraft. ","objectID":"51529_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>73:2010 Aircraft — Tubing tolerances — Inch series","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>73:2010 specifies the dimensional tolerances to be applied to round section inch series tubing used in aircraft. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/07/20776","uuid":"4fea251f-7465-48de-9c0a-8698d9377c2a","title":"ISO 12508:1994 Earth-moving machinery — Operator station and maintenance areas — Bluntness of edges","status":"Published","year":2021,"order":11,"text":"Defines the permissible limits of the sharpness of edges and corners, so reduce the risk of injury to the operator or maintenance personnel while operating earth-moving machinery and performing maintenance. ","objectID":"20776_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>08:1994 Earth-moving machinery — Operator station and maintenance areas — Bluntness of edges","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Defines the permissible limits of the sharpness of edges and corners, so reduce the risk of injury to the operator or maintenance personnel while operating earth-moving machinery and performing maintenance. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51530","uuid":"6393b16c-0b35-42fd-b488-d99091245312","title":"ISO 12584:2013 Aerospace — Hydraulic fluid components — Expression of particulate contamination levels","status":"Published","year":2020,"order":11,"text":"ISO 12584:2013 defines the method of reporting and communicating the contamination (or cleanliness) level of components used in aerospace fluid systems. It also presents a coding system which allows cleanliness data to be reported, both in a shortened manner and in a complete manner, when communicating for reporting contamination level measurement results and for specifying cleanliness requirements. ","objectID":"51530_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>84:2013 Aerospace — Hydraulic fluid components — Expression of particulate contamination levels","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>84:2013 defines the method of reporting and communicating the contamination (or cleanliness) level of components used in aerospace fluid systems. It also presents a coding system which allows cleanliness data to be reported, both in a shortened manner and in a complete manner, when communicating for reporting contamination level measurement results and for specifying cleanliness requirements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/03/50327","uuid":"87e4c965-686a-472a-8178-8337a06c0dd5","title":"ISO 12567-1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors","status":"Published","year":2020,"order":11,"text":"ISO 12567-1:2010 specifies a method to measure the thermal transmittance of a door or window system. It is applicable to all effects of frames, sashes, shutters, blinds, screens, panels, door leaves and fittings. It is not applicable to edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen, effects of air leakage through the specimen, and roof windows and projecting products, where the external face projects beyond the cold side roof surface. ","objectID":"50327_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>67-1:2010 specifies a method to measure the thermal transmittance of a door or window system. It is applicable to all effects of frames, sashes, shutters, blinds, screens, panels, door leaves and fittings. It is not applicable to edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen, effects of air leakage through the specimen, and roof windows and projecting products, where the external face projects beyond the cold side roof surface. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/41/44113","uuid":"89e3e265-69e2-4690-bd85-81b819f1f253","title":"ISO 12500-3:2009 Filters for compressed air — Test methods — Part 3: Particulates","status":"Published","year":2020,"order":11,"text":"ISO 12500-3:2009 provides a guide for choosing an appropriate method of determining the solid particulate removal efficiency rating by particle size of filters used in compressed air systems. ISO 12500-3:2009 specifies the layouts and procedures for testing these filters. Measurement methods are recommended based on the size range of the particulates that the filter being tested has been designed to remove. The test is performed as a “type-test” on filters as being representative of a range. The following two particle diameter size ranges are identified in ISO 12500-3:2009: a fine filter range, 0,01 < 5,0 μm, and a coarse filter range, ≥ 5,0 ≤ 40 μm. ","objectID":"44113_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-3:2009 Filters for compressed air — Test methods — Part 3: Particulates","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>00-3:2009 provides a guide for choosing an appropriate method of determining the solid particulate removal efficiency rating by particle size of filters used in compressed air systems. <em>ISO</em> <em>125</em>00-3:2009 specifies the layouts and procedures for testing these filters. Measurement methods are recommended based on the size range of the particulates that the filter being tested has been designed to remove. The test is performed as a “type-test” on filters as being representative of a range. The following two particle diameter size ranges are identified in <em>ISO</em> <em>125</em>00-3:2009: a fine filter range, 0,01 < 5,0 μm, and a coarse filter range, ≥ 5,0 ≤ 40 μm. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/11/41150","uuid":"6d5b04cd-7f35-4200-aab2-a6e4b123e149","title":"ISO 12500-1:2007 Filters for compressed air —  Test methods — Part 1: Oil aerosols","status":"Published","year":2020,"order":11,"text":"ISO 12500-1:2007 specifies the test layout and test procedures required for testing coalescing filters used in compressed-air systems to determine their effectiveness in removing oil aerosols. ISO 12500-1:2007 provides the means to indicate performance characteristics of the pressure drop and the capability of removing oil aerosols. ISO 12500-1:2007 defines one method of presenting filter performance as outlet oil aerosol concentration stated in milligrams per cubic metre from results obtained under standard rating parameters. ","objectID":"41150_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-1:2007 Filters for compressed air —  Test methods — Part 1: Oil aerosols","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>00-1:2007 specifies the test layout and test procedures required for testing coalescing filters used in compressed-air systems to determine their effectiveness in removing oil aerosols. <em>ISO</em> <em>125</em>00-1:2007 provides the means to indicate performance characteristics of the pressure drop and the capability of removing oil aerosols. <em>ISO</em> <em>125</em>00-1:2007 defines one method of presenting filter performance as outlet oil aerosol concentration stated in milligrams per cubic metre from results obtained under standard rating parameters. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/08/40843","uuid":"c054d880-188c-4abb-ba21-cca2a8e2157a","title":"ISO 12580:2007 Timber structures — Glued laminated timber — Methods of test for glue-line delamination","status":"Published","year":2019,"order":11,"text":"ISO 12580:2007 specifies five delamination methods for factory quality assurance of the glue line of glued laminated timber. ","objectID":"40843_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>80:2007 Timber structures — Glued laminated timber — Methods of test for glue-line delamination","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>80:2007 specifies five delamination methods for factory quality assurance of the glue line of glued laminated timber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/03/40330","uuid":"c1bb57fb-1b4d-4700-a553-970a33b0df21","title":"ISO 12509:2004 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","status":"Published","year":2019,"order":11,"text":"ISO 12509:2004 specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth moving machines. It is applicable to self-propelled wheel or crawler earth-moving machines as defined in ISO 6165, intended for off-road, as well as on-road, use. It is not applicable to pedestrian-controlled machines. ","objectID":"40330_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>09:2004 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>09:2004 specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth moving machines. It is applicable to self-propelled wheel or crawler earth-moving machines as defined in <em>ISO</em> 6165, intended for off-road, as well as on-road, use. It is not applicable to pedestrian-controlled machines. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/00/40053","uuid":"a853358f-73ba-4813-aaac-c4861338ab10","title":"ISO 12567-2:2005 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 2: Roof windows and other projecting windows","status":"Published","year":2019,"order":11,"text":"ISO 12567-2:2005 specifies a method to measure the thermal transmittance of roof windows and projecting windows. It does not include: edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen and effects of air leakage through the specimen. ","objectID":"40053_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-2:2005 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 2: Roof windows and other projecting windows","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>67-2:2005 specifies a method to measure the thermal transmittance of roof windows and projecting windows. It does not include: edge effects occurring outside the perimeter of the specimen, energy transfer due to solar radiation on the specimen and effects of air leakage through the specimen. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/25/2565","uuid":"74c73339-92b6-4593-9cd8-92647a146434","title":"ISO 12576-1:2001 Thermal insulation — Insulating materials and products for buildings — Conformity control systems — Part 1: Factory-made products","status":"Published","year":2019,"order":11,"text":"This part of ISO 12576 establishes five systems for the conformity control of thermal insulating materials and products for buildings that are factory made. Its purpose is to provide uniform methods that are used to determine whether a production or a consignment of a thermal insulating material should be accepted as conforming to the relevant specification requirements. This part of ISO 12576 provides minimum requirements for each of the systems. Other systems may be additionally applied when agreed upon between the supplier and purchaser. ","objectID":"2565_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>76-1:2001 Thermal insulation — Insulating materials and products for buildings — Conformity control systems — Part 1: Factory-made products","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"This part of <em>ISO</em> <em>125</em>76 establishes five systems for the conformity control of thermal insulating materials and products for buildings that are factory made. Its purpose is to provide uniform methods that are used to determine whether a production or a consignment of a thermal insulating material should be accepted as conforming to the relevant specification requirements. This part of <em>ISO</em> <em>125</em>76 provides minimum requirements for each of the systems. Other systems may be additionally applied when agreed upon between the supplier and purchaser. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/24/2444","uuid":"ca8ea987-fe87-4cf1-9a1c-62facb484665","title":"ISO 12570:2000 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature","status":"Published","year":2019,"order":11,"objectID":"2444_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>70:2000 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/21/2133","uuid":"71ccf225-8d6e-4bd3-81a6-ae12332af3b3","title":"ISO 12511:1997 Earth-moving machinery — Hour meters","status":"Published","year":2019,"order":11,"objectID":"2133_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>11:1997 Earth-moving machinery — Hour meters","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/24/72409","uuid":"f7038083-239b-4fbd-98d5-1f6070862731","title":"ISO 12570:2000/Amd 2:2018 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 2","status":"Published","year":2018,"order":11,"objectID":"72409_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>70:2000/Amd 2:2018 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 2","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/57/45746","uuid":"e4cc0fc7-b28a-4061-a1e8-c9486f90d4cb","title":"ISO 12576-2:2008 Thermal insulation products — Conformity control systems — Part 2: In-situ products","status":"Published","year":2018,"order":11,"text":"ISO 12576-2:2008 establishes three systems for the conformity control of thermal insulating products that are manufactured on-site from components produced in a factory and provides the minimum requirements for each system. Examples of these types of products are loose fill and spray-applied insulations. The purpose of ISO 12576-2:2008 is to provide uniform methods to determine whether the production of a thermal-insulating product is acceptable as conforming to the relevant specification requirements once it is installed on site. ","objectID":"45746_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>76-2:2008 Thermal insulation products — Conformity control systems — Part 2: In-situ products","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>76-2:2008 establishes three systems for the conformity control of thermal insulating products that are manufactured on-site from components produced in a factory and provides the minimum requirements for each system. Examples of these types of products are loose fill and spray-applied insulations. The purpose of <em>ISO</em> <em>125</em>76-2:2008 is to provide uniform methods to determine whether the production of a thermal-insulating product is acceptable as conforming to the relevant specification requirements once it is installed on site. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/05/40543","uuid":"ba88a7d9-053b-49f4-90fa-6fe4fb741eeb","title":"ISO 12575-2:2007 Thermal insulation products — Exterior  insulating systems for foundations — Part 2: Principal responsibilities of installers","status":"Published","year":2018,"order":11,"text":"ISO 12575-2:2007 specifies the responsibilities of the installers of exterior insulating systems for foundations such that a product that is manufactured and packaged in accordance with ISO 12575-1 is able to provide the properties declared by the manufacturer when installed according to ISO 12575-2:2007. ISO 12575-2:2007 stipulates responsibilities of the installer in the installation of the exterior insulation system, documentation of the installation and a declaration by the installer that all requirements of ISO 12575-2:2007 have been met. ISO 12575-2:2007 does not specify the fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in ISO 12575-1. The installer can be required to meet additional requirements specified in local regulations or the customer's requirements. ","objectID":"40543_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>75-2:2007 Thermal insulation products — Exterior  insulating systems for foundations — Part 2: Principal responsibilities of installers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>75-2:2007 specifies the responsibilities of the installers of exterior insulating systems for foundations such that a product that is manufactured and packaged in accordance with <em>ISO</em> <em>125</em>75-1 is able to provide the properties declared by the manufacturer when installed according to <em>ISO</em> <em>125</em>75-2:2007. <em>ISO</em> <em>125</em>75-2:2007 stipulates responsibilities of the installer in the installation of the exterior insulation system, documentation of the installation and a declaration by the installer that all requirements of <em>ISO</em> <em>125</em>75-2:2007 have been met. <em>ISO</em> <em>125</em>75-2:2007 does not specify the fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in <em>ISO</em> <em>125</em>75-1. The installer can be required to meet additional requirements specified in local regulations or the customer's requirements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/05/40542","uuid":"cb6077e5-845b-440f-8923-897c8f03becd","title":"ISO 12575-1:2012 Thermal insulation products — Exterior insulating systems for foundations — Part 1: Material specification","status":"Published","year":2018,"order":11,"text":"ISO 12575-1:2012 specifies the basic performance requirements for the insulating materials that form part of insulating systems used on the exterior of foundations and slabs where the insulation is in direct contact with the ground. ISO 12575-1:2012 does not address exterior insulating systems for foundations permanently immersed in water. ","objectID":"40542_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>75-1:2012 Thermal insulation products — Exterior insulating systems for foundations — Part 1: Material specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>75-1:2012 specifies the basic performance requirements for the insulating materials that form part of insulating systems used on the exterior of foundations and slabs where the insulation is in direct contact with the ground. <em>ISO</em> <em>125</em>75-1:2012 does not address exterior insulating systems for foundations permanently immersed in water. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/24/32428","uuid":"f917d126-4907-4c9e-b35d-1fd2865aed8a","title":"ISO 12510:2004 Earth-moving machinery — Operation and maintenance — Maintainability guidelines","status":"Published","year":2018,"order":11,"text":"ISO 12510:2004 establishes guidelines for the incorporation of design features that promote safety, efficiency, reliability and ease of maintenance and service operations on earth-moving machinery as defined in ISO 6165. ","objectID":"32428_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>10:2004 Earth-moving machinery — Operation and maintenance — Maintainability guidelines","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>10:2004 establishes guidelines for the incorporation of design features that promote safety, efficiency, reliability and ease of maintenance and service operations on earth-moving machinery as defined in <em>ISO</em> 6165. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/98/69817","uuid":"b0700e2d-1de9-42fe-834d-65274f841436","title":"ISO 12569:2017 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","status":"Published","year":2017,"order":11,"text":"ISO 12569:2017 establishes methods to obtain the ventilation rate or specific airflow rate in a building space (which is considered to be a single zone) using a tracer gas. The measurement methods apply for spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. ISO 12569:2017 provides three measurement methods using a tracer gas: concentration decay method, continuous dose method, and constant concentration method. NOTE          Specific measurement conditions are given in Table 1. ","objectID":"69817_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2017 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>69:2017 establishes methods to obtain the ventilation rate or specific airflow rate in a building space (which is considered to be a single zone) using a tracer gas. The measurement methods apply for spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. <em>ISO</em> <em>125</em>69:2017 provides three measurement methods using a tracer gas: concentration decay method, continuous dose method, and constant concentration method. NOTE          Specific measurement conditions are given in Table 1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/11/41151","uuid":"47363d72-0931-4770-9afa-44044ab65bf4","title":"ISO 12500-2:2007 Filters for compressed air — Test methods — Part 2: Oil vapours","status":"Published","year":2017,"order":11,"text":"ISO 12500-2:2007 specifies the test layout and test procedures required for testing hydrocarbon vapour adsorbent filters used in compressed air systems to determine their effectiveness in removing hydrocarbon vapours. The performance characteristics to be identified are the adsorptive capacity and the pressure drop. ISO 12500-2:2007 defines one method of presenting filter performance as hydrocarbon-vapour capacity, expressed in milligrams, from results obtained under test conditions. ","objectID":"41151_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>00-2:2007 Filters for compressed air — Test methods — Part 2: Oil vapours","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>00-2:2007 specifies the test layout and test procedures required for testing hydrocarbon vapour adsorbent filters used in compressed air systems to determine their effectiveness in removing hydrocarbon vapours. The performance characteristics to be identified are the adsorptive capacity and the pressure drop. <em>ISO</em> <em>125</em>00-2:2007 defines one method of presenting filter performance as hydrocarbon-vapour capacity, expressed in milligrams, from results obtained under test conditions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/08/40842","uuid":"1ff9e0e1-f4b0-4325-9009-0c13115ae4da","title":"ISO 12579:2007 Timber structures — Glued laminated timber — Method of test for shear strength of glue lines","status":"Published","year":2017,"order":11,"text":"ISO 12579:2007 specifies a production quality-control test method for measuring the shear strength of the glue line of glued laminated timber. ","objectID":"40842_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>79:2007 Timber structures — Glued laminated timber — Method of test for shear strength of glue lines","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>79:2007 specifies a production quality-control test method for measuring the shear strength of the glue line of glued laminated timber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/79/57974","uuid":"731fe194-8e9a-4b29-adfe-65c4ec604b67","title":"ISO 12570:2000/Amd 1:2013 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 1","status":"Published","year":2013,"order":11,"objectID":"57974_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>70:2000/Amd 1:2013 Hygrothermal performance of building materials and products —  Determination of moisture content by drying at elevated temperature — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/72/57224","uuid":"f0f4210c-0761-40ec-99e9-65c0358e98bc","title":"ISO 12567-1:2010/Cor 1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors — Technical Corrigendum 1","status":"Published","year":2010,"order":11,"objectID":"57224_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-1:2010/Cor 1:2010 Thermal performance of windows and doors — Determination of thermal transmittance by the hot-box method — Part 1: Complete windows and doors — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/15/61531","uuid":"43b2f7c7-2075-448c-a950-2a0c9a6effd2","title":"ISO 12543-6:2011/Cor 1:2012 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance — Technical Corrigendum 1","status":"Withdrawn","year":2021,"order":100,"objectID":"61531_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6:2011/Cor 1:2012 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/13/61388","uuid":"18c94541-5190-4037-9d2f-dd669278ab4a","title":"ISO 12571:2013 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12571:2013 specifies two alternative methods for determining hygroscopic sorption properties of porous building materials and products: a) using desiccators and weighing cups (desiccator method); b) using a climatic chamber (climatic chamber method). The desiccator method is the reference method. ISO 12571:2013 does not specify the method for sampling. The methods specified in ISO 12571:2013 can be used to determine the moisture content of a sample in equilibrium with air at a specific temperature and humidity. ","objectID":"61388_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>71:2013 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>71:2013 specifies two alternative methods for determining hygroscopic sorption properties of porous building materials and products: a) using desiccators and weighing cups (desiccator method); b) using a climatic chamber (climatic chamber method). The desiccator method is the reference method. <em>ISO</em> <em>125</em>71:2013 does not specify the method for sampling. The methods specified in <em>ISO</em> <em>125</em>71:2013 can be used to determine the moisture content of a sample in equilibrium with air at a specific temperature and humidity. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46380","uuid":"30992f55-09d0-4752-a8db-659847517c2b","title":"ISO 12543-6:2011 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12543-6:2011 specifies defects of finished sizes and test methods with regard to the appearance of laminated glass when looking through the glass. ISO 12543-6:2011 is applicable to finished sizes at the time of supply. ","objectID":"46380_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6:2011 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-6:2011 specifies defects of finished sizes and test methods with regard to the appearance of laminated glass when looking through the glass. <em>ISO</em> <em>125</em>43-6:2011 is applicable to finished sizes at the time of supply. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46379","uuid":"11750bd0-e628-4c2a-9995-f96ef6138eed","title":"ISO 12543-5:2011 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12543-5:2011 specifies dimensions, limit deviations and edge finishes of laminated glass and laminated safety glass for use in building. ","objectID":"46379_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-5:2011 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-5:2011 specifies dimensions, limit deviations and edge finishes of laminated glass and laminated safety glass for use in building. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46378","uuid":"0513c926-322b-4293-accf-0533a189d00d","title":"ISO 12543-4:2011 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12543-4:2011 specifies test methods in respect of resistance to high temperature, humidity and radiation for laminated glass and laminated safety glass for use in building. ","objectID":"46378_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-4:2011 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-4:2011 specifies test methods in respect of resistance to high temperature, humidity and radiation for laminated glass and laminated safety glass for use in building. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46377","uuid":"b4f82b67-ee82-44d5-bd5f-352d2325f92b","title":"ISO 12543-3:2011 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12543-3:2011 specifies performance requirements for laminated glass as defined in ISO 12543-1. ","objectID":"46377_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-3:2011 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-3:2011 specifies performance requirements for laminated glass as defined in <em>ISO</em> <em>125</em>43-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46376","uuid":"8a44c9c8-2e29-4af7-9d40-aa1fa3be8459","title":"ISO 12543-2:2011 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12543-2:2011 specifies performance requirements for laminated safety glass as defined in ISO 12543-1. ","objectID":"46376_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-2:2011 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-2:2011 specifies performance requirements for laminated safety glass as defined in <em>ISO</em> <em>125</em>43-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/63/46375","uuid":"102885a1-1f79-4b67-b258-cdc0bf9f0b3f","title":"ISO 12543-1:2011 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","status":"Withdrawn","year":2021,"order":100,"text":"ISO 12543-1:2011 defines terms and describes component parts for laminated glass and laminated safety glass for use in building. ","objectID":"46375_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-1:2011 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-1:2011 defines terms and describes component parts for laminated glass and laminated safety glass for use in building. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/46/74661","uuid":"451f1bea-68a0-4551-8db5-ea52058d8f26","title":"ISO 12569:2017/DAmd 1 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method — Amendment 1","status":"Deleted","year":2019,"order":100,"objectID":"74661_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2017/DAmd 1 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/05/40546","uuid":"0267bfed-e73c-4e9a-b4fa-94539ebad444","title":"ISO 12574-2:2008 Thermal insulation — Cellulose-fibre loose-fill for horizontal applications in ventilated roof spaces — Part 2: Principal responsibilities of installers","status":"Withdrawn","year":2019,"order":100,"text":"ISO 12574-2:2008 gives the principal responsibilities of the installers of cellulose-fibre loose-fill thermal insulation products for buildings. If a product is manufactured and packaged according to ISO 12574-1 and then installed in ventilated roof spaces as described in ISO 9774, it is expected to provide the properties declared by the manufacturer. ISO 12574-2:2008 gives the principal responsibilities of the installer in the installation of the product, in the documentation of the installation and in the declaration that all requirements of this part of ISO 12574 have been met. ISO 12574-2:2008 does not specify fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in government regulations. It is necessary that the installer ensure, when installing the product, that the product installed is suitable for the application, based on the government regulations and the manufacturer's recommendations. The installer can be required to meet ancillary (additional) requirements that are specified in local regulations or the customer's requirements. ","objectID":"40546_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>74-2:2008 Thermal insulation — Cellulose-fibre loose-fill for horizontal applications in ventilated roof spaces — Part 2: Principal responsibilities of installers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>74-2:2008 gives the principal responsibilities of the installers of cellulose-fibre loose-fill thermal insulation products for buildings. If a product is manufactured and packaged according to <em>ISO</em> <em>125</em>74-1 and then installed in ventilated roof spaces as described in <em>ISO</em> 9774, it is expected to provide the properties declared by the manufacturer. <em>ISO</em> <em>125</em>74-2:2008 gives the principal responsibilities of the installer in the installation of the product, in the documentation of the installation and in the declaration that all requirements of this part of <em>ISO</em> <em>125</em>74 have been met. <em>ISO</em> <em>125</em>74-2:2008 does not specify fitness of the product for the intended use beyond those aspects relating to installation. Many aspects relating to the fitness for use are specified in government regulations. It is necessary that the installer ensure, when installing the product, that the product installed is suitable for the application, based on the government regulations and the manufacturer's recommendations. The installer can be required to meet ancillary (additional) requirements that are specified in local regulations or the customer's requirements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/64/56470","uuid":"18869879-5ac6-45f4-80c9-4df41565704c","title":"ISO 12569:2012 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","status":"Withdrawn","year":2017,"order":100,"text":"ISO 12569:2012 establishes an engineering standard by which to obtain the ventilation rate/specific airflow rate, using a tracer gas in a building space, which is considered to be of a single zone. The measurement method is valid in spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. ISO 12569:2012 provides three measurement methods using a tracer gas: (1) concentration decay method, (2) continuous dose method, and (3) constant concentration method. ","objectID":"56470_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2012 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>69:2012 establishes an engineering standard by which to obtain the ventilation rate/specific airflow rate, using a tracer gas in a building space, which is considered to be of a single zone. The measurement method is valid in spaces where the combined conditions concerning the uniformity of tracer gas concentration, measurement of the exhaust gas concentration, effective mixed zone and/or fluctuation of ventilation are satisfied. <em>ISO</em> <em>125</em>69:2012 provides three measurement methods using a tracer gas: (1) concentration decay method, (2) continuous dose method, and (3) constant concentration method. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/09/40959","uuid":"6f35ecbd-20ac-43b8-8e30-082493d73471","title":"ISO 12578:2008 Timber structures — Glued laminated timber — Component performance and production requirements","status":"Withdrawn","year":2016,"order":100,"text":"ISO 12578:2008 specifies requirements for the components of glued laminated timber members and minimum requirements for the production of such members for structural use. ISO 12578:2008 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, ISO 12578:2008 also applies to broad-leaf species if the tests specified in ISO 12578:2008 show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather-resistant adhesives. ISO 12578:2008 does not apply to the determination of strength and stiffness characteristics. ","objectID":"40959_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>78:2008 Timber structures — Glued laminated timber — Component performance and production requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>78:2008 specifies requirements for the components of glued laminated timber members and minimum requirements for the production of such members for structural use. <em>ISO</em> <em>125</em>78:2008 is applicable to products with a finished lamination thickness of not more than 50 mm. Although most glued laminated timber is made from coniferous species, <em>ISO</em> <em>125</em>78:2008 also applies to broad-leaf species if the tests specified in <em>ISO</em> <em>125</em>78:2008 show that a satisfactory glue bond can be achieved. The basic requirements apply to structural members of all service classes; however, special precautions are necessary for service class 3, for example, the use of weather-resistant adhesives. <em>ISO</em> <em>125</em>78:2008 does not apply to the determination of strength and stiffness characteristics. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/40/34000","uuid":"16256905-ac81-42aa-a444-30aef87617dd","title":"ISO 12572:2001 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties","status":"Withdrawn","year":2016,"order":100,"objectID":"34000_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>72:2001 Hygrothermal performance of building materials and products — Determination of water vapour transmission properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/24/2408","uuid":"78f10b8b-d573-4f2f-a3b3-424218e85e02","title":"ISO 12571:2000 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","status":"Withdrawn","year":2013,"order":100,"objectID":"2408_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>71:2000 Hygrothermal performance of building materials and products — Determination of hygroscopic sorption properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/33/33382","uuid":"80415c8d-6c9a-4762-9fa4-70d7ac54f446","title":"ISO 12569:2000 Thermal performance of buildings — Determination of air change in buildings — Tracer gas dilution method","status":"Withdrawn","year":2012,"order":100,"objectID":"33382_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>69:2000 Thermal performance of buildings — Determination of air change in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/83/38329","uuid":"19d1b031-fa87-4e60-8a90-119280567111","title":"ISO 12543-2:2004 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","status":"Withdrawn","year":2011,"order":100,"text":"ISO 12543-2:2004 specifies performance requirements for laminated safety glass. ","objectID":"38329_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-2:2004 Glass in building — Laminated glass and laminated safety glass — Part 2: Laminated safety glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> <em>125</em>43-2:2004 specifies performance requirements for laminated safety glass. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25265","uuid":"f72b4d08-2c3d-4e5a-ac43-b3ebab4b4745","title":"ISO 12543-6:1998 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","status":"Withdrawn","year":2011,"order":100,"objectID":"25265_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-6:1998 Glass in building — Laminated glass and laminated safety glass — Part 6: Appearance","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25259","uuid":"1a36bb5e-a501-4586-b588-8512884cb17d","title":"ISO 12543-5:1998 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","status":"Withdrawn","year":2011,"order":100,"objectID":"25259_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-5:1998 Glass in building — Laminated glass and laminated safety glass — Part 5: Dimensions and edge finishing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25258","uuid":"2e5e4c67-c2cb-4e58-a665-aabd2032e014","title":"ISO 12543-4:1998 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","status":"Withdrawn","year":2011,"order":100,"objectID":"25258_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-4:1998 Glass in building — Laminated glass and laminated safety glass — Part 4: Test methods for durability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/52/25257","uuid":"bbb27051-4616-4506-b267-7cf7f3ff815f","title":"ISO 12543-3:1998 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","status":"Withdrawn","year":2011,"order":100,"objectID":"25257_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-3:1998 Glass in building — Laminated glass and laminated safety glass — Part 3: Laminated glass","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/17/1705","uuid":"a7a06ef8-9f85-422d-b7aa-e6511cb436cf","title":"ISO 12543-1:1998 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","status":"Withdrawn","year":2011,"order":100,"objectID":"1705_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>43-1:1998 Glass in building — Laminated glass and laminated safety glass — Part 1: Definitions and description of component parts","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/25/2533","uuid":"c3373f51-7c94-444c-84a0-66281b73853f","title":"ISO 12567-1:2000 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 1: Complete windows and doors","status":"Withdrawn","year":2010,"order":100,"objectID":"2533_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>67-1:2000 Thermal performance of windows and doors — Determination of thermal transmittance by hot box method — Part 1: Complete windows and doors","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/18/1845","uuid":"04379487-f548-4427-aa83-0f9b2c388eeb","title":"ISO 12509:1995 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","status":"Withdrawn","year":2004,"order":100,"text":"Specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth-moving machines. Applies to self-propelled wheel or crawler earth-moving machines as defined in ISO 6165, intended for off-road use as well as on-road use. Does not include pedestrian controlled machines. ","objectID":"1845_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>09:1995 Earth-moving machinery — Lighting, signalling and marking lights, and reflex-reflector devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Specifies the minimum requirements for installation and performance of lighting, signalling and marking lights, and reflex-reflector devices on earth-moving machines. Applies to self-propelled wheel or crawler earth-moving machines as defined in <em>ISO</em> 6165, intended for off-road use as well as on-road use. Does not include pedestrian controlled machines. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5864","uuid":"6aec10b4-9ce2-40a4-ac69-1ea0f2ef8d3a","title":"ISO 1250:1972 Mineral solvents for paints — White spirits and related hydrocarbon solvents","status":"Withdrawn","year":1985,"order":100,"objectID":"5864_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>125</em>0:1972 Mineral solvents for paints — White spirits and related hydrocarbon solvents","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/09/70904","uuid":"95e7b0fa-f3ae-4b29-a184-3001dd504ae7","title":"ISO 7783:2018 Paints and varnishes — Determination of water-vapour transmission properties — Cup method","status":"Published","year":2018,"order":11,"text":"This document specifies a method for determining the water-vapour transmission properties of coatings of paints, varnishes and related products. It supplements ISO 12572. As far as possible, the procedure, the definitions and the calculations have been taken over from ISO 12572. ISO 12572 can be consulted, if necessary, to obtain a better understanding of the procedure specified in this document. Water-vapour transmission rates of more than 680 g/(m2⋅d) (i.e. water-vapour diffusion-equivalent air layer thicknesses, sd, of less than 0,03 m) are not accurately quantified by the test method described in this document. ","objectID":"70904_0","_highlightResult":{"title":{"value":"<em>ISO</em> 7783:2018 Paints and varnishes — Determination of water-vapour transmission properties — Cup method","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies a method for determining the water-vapour transmission properties of coatings of paints, varnishes and related products. It supplements <em>ISO</em> <em>125</em>72. As far as possible, the procedure, the definitions and the calculations have been taken over from <em>ISO</em> <em>125</em>72. <em>ISO</em> <em>125</em>72 can be consulted, if necessary, to obtain a better understanding of the procedure specified in this document. Water-vapour transmission rates of more than 680 g/(m2⋅d) (i.e. water-vapour diffusion-equivalent air layer thicknesses, sd, of less than 0,03 m) are not accurately quantified by the test method described in this document. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/14/61432","uuid":"ad73d9c6-1290-4a71-ab64-def1780a89a3","title":"ISO 18100:2017 Timber structures — Finger-jointed timber — Manufacturing and production requirements","status":"Published","year":2022,"order":11,"text":"ISO 18100:2017 specifies the product and performance requirements for finger-jointed structural timber made from sawn timber elements. ISO 18100:2017 does not cover products made using impressed (die-formed) joints or finger-jointed laminations for glued laminated timber, which is covered in ISO 12578. ","objectID":"61432_0","_highlightResult":{"title":{"value":"<em>ISO</em> 18100:2017 Timber structures — Finger-jointed timber — Manufacturing and production requirements","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 18100:2017 specifies the product and performance requirements for finger-jointed structural timber made from sawn timber elements. <em>ISO</em> 18100:2017 does not cover products made using impressed (die-formed) joints or finger-jointed laminations for glued laminated timber, which is covered in <em>ISO</em> <em>125</em>78. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/48/64839","uuid":"ee7465a7-59be-4dee-9573-888ae8f10eca","title":"ISO 9241-125:2017 Ergonomics of human-system interaction — Part 125: Guidance on visual presentation of information","status":"Published","year":2017,"order":11,"text":"ISO 9241-125:2017 provides guidance for the visual presentation of information controlled by software, irrespective of the device. It includes specific properties such as the syntactic or semantic aspects of information, e.g. coding techniques, and gives provisions for the organization of information taking account of human perception and memory capabilities. Those of its provisions that do not apply to specific types of visual interfaces clearly indicate any limitations to their applicability. It does not address specific details of charts, graphs or information visualization. ISO 9241-125:2017 can be utilized throughout the design process (e.g. as specification and guidance for designers during design or as a basis for heuristic evaluation). Its provisions for the presentation of information depend upon the visual design approach, the task, the user, the environment and the single or multiple technologies that might be used for presenting the information. Consequently, this document cannot be applied without knowledge of the context of use. It is not intended to be used as a prescriptive set of rules to be applied in its entirety but rather assumes that the designer has proper information available concerning task and user requirements and understands the use of available technology. Some of the provisions of this document are based on Latin-based language usage and might not apply, or might need to be modified, for use with languages that use other alphabets. In applying those that assume a specific language base (e.g. alphabetic ordering of coding information, items in a list), it is important that care is taken to follow its intent of the standard when translation is required to a different language. ISO 9241-125:2017 does not address auditory or tactile/haptic presentation of information or modality shifting for the presentation of visual information in other modalities. NOTE       ISO 9241‑112 provides high-level ergonomic guidance that applies to all modalities. ","objectID":"64839_0","_highlightResult":{"title":{"value":"<em>ISO</em> 9241-<em>125</em>:2017 Ergonomics of human-system interaction — Part <em>125</em>: Guidance on visual presentation of information","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em> 9241-<em>125</em>:2017 provides guidance for the visual presentation of information controlled by software, irrespective of the device. It includes specific properties such as the syntactic or semantic aspects of information, e.g. coding techniques, and gives provisions for the organization of information taking account of human perception and memory capabilities. Those of its provisions that do not apply to specific types of visual interfaces clearly indicate any limitations to their applicability. It does not address specific details of charts, graphs or information visualization. <em>ISO</em> 9241-<em>125</em>:2017 can be utilized throughout the design process (e.g. as specification and guidance for designers during design or as a basis for heuristic evaluation). Its provisions for the presentation of information depend upon the visual design approach, the task, the user, the environment and the single or multiple technologies that might be used for presenting the information. Consequently, this document cannot be applied without knowledge of the context of use. It is not intended to be used as a prescriptive set of rules to be applied in its entirety but rather assumes that the designer has proper information available concerning task and user requirements and understands the use of available technology. Some of the provisions of this document are based on Latin-based language usage and might not apply, or might need to be modified, for use with languages that use other alphabets. In applying those that assume a specific language base (e.g. alphabetic ordering of coding information, items in a list), it is important that care is taken to follow its intent of the standard when translation is required to a different language. <em>ISO</em> 9241-<em>125</em>:2017 does not address auditory or tactile/haptic presentation of information or modality shifting for the presentation of visual information in other modalities. NOTE       <em>ISO</em> 9241‑112 provides high-level ergonomic guidance that applies to all modalities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/04/445","uuid":"abe47dd4-c4a9-4f94-aae5-46995d521b1e","title":"ISO/R 125:1966 Title missing - Legacy paper document","status":"Withdrawn","year":1971,"order":100,"objectID":"445_0","_highlightResult":{"title":{"value":"<em>ISO</em>/R <em>125</em>:1966 Title missing - Legacy paper document","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/67/66763","uuid":"31b1fee8-1773-4b75-b2fb-7f6b71f63dde","title":"ISO/TS 12512:2017 Glass reinforced thermosetting plastic (GRP) pipes — Determination of initial specific ring stiffness using segment test species cut from a pipe","status":"Published","year":2021,"order":11,"text":"ISO/TS 12512:2017 specifies a method for determining the initial specific ring stiffness of pipes having a nominal size of DN 2000 or larger, using segment test pieces cut from a glass-reinforced thermosetting plastics (GRP) pipe. ","objectID":"66763_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS <em>125</em>12:2017 Glass reinforced thermosetting plastic (GRP) pipes — Determination of initial specific ring stiffness using segment test species cut from a pipe","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS <em>125</em>12:2017 specifies a method for determining the initial specific ring stiffness of pipes having a nominal size of DN 2000 or larger, using segment test pieces cut from a glass-reinforced thermosetting plastics (GRP) pipe. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51542","uuid":"43e413ae-7681-42c9-9d72-d8f978fdf4ae","title":"ISO/TR 12591:2013 White tea — Definition","status":"Published","year":2020,"order":11,"text":"ISO/TR 12591:2013 contains information regarding the manufacture and chemical analysis of the tea referred to as white tea in international trade. It provides an internationally agreed definition of white tea based on the plant source and production methods used. ","objectID":"51542_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>125</em>91:2013 White tea — Definition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TR <em>125</em>91:2013 contains information regarding the manufacture and chemical analysis of the tea referred to as white tea in international trade. It provides an internationally agreed definition of white tea based on the plant source and production methods used. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/76/77689","uuid":"e7fe71f4-fa0a-4479-aedd-d5ad37045e1c","title":"ISO/DIS 12509 Earth-moving machinery and rough-terrain trucks — Lighting, signalling and marking lights, and reflex reflector devices","status":"Under development","year":2021,"order":12,"objectID":"77689_0","_highlightResult":{"title":{"value":"<em>ISO</em>/DIS <em>125</em>09 Earth-moving machinery and rough-terrain trucks — Lighting, signalling and marking lights, and reflex reflector devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/04/80461","uuid":"384fd8fe-353d-4cc7-b879-6cc4e28872b4","title":"ISO/AWI 12569 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","status":"Under development","year":2020,"order":12,"objectID":"80461_0","_highlightResult":{"title":{"value":"<em>ISO</em>/AWI <em>125</em>69 Thermal performance of buildings and materials — Determination of specific airflow rate in buildings — Tracer gas dilution method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/75/77531","uuid":"2f9e9389-6de8-4d4a-9382-0f4d751f1dcc","title":"ISO/CD 12591 White tea — Definition and basic requirements","status":"Deleted","year":2020,"order":100,"objectID":"77531_0","_highlightResult":{"title":{"value":"<em>ISO</em>/CD <em>125</em>91 White tea — Definition and basic requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/77/27742","uuid":"5c6efdc5-f537-4bc0-8c36-3c4e71192165","title":"ISO/TR 12596:1995/Cor 1:1996 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines — Technical Corrigendum 1","status":"Withdrawn","year":2005,"order":100,"text":"Replaces the equation in note 6. ","objectID":"27742_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>125</em>96:1995/Cor 1:1996 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Replaces the equation in note 6. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/20/2020","uuid":"620b8716-8169-471e-940d-dfcee08c8094","title":"ISO/TR 12596:1995 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines","status":"Withdrawn","year":2005,"order":100,"text":"Gives recommendations for the design, installation and commissioning of solar heating systems for swimming pools, using direct circulation of pool water to the solar collectors. Does not include electrical safety requirements and does not deal with the pool filtration systems. ","objectID":"2020_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TR <em>125</em>96:1995 Solar heating — Swimming-pool heating systems — Dimensions, design and installation guidelines","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"Gives recommendations for the design, installation and commissioning of solar heating systems for swimming pools, using direct circulation of pool water to the solar collectors. Does not include electrical safety requirements and does not deal with the pool filtration systems. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/73/77379","uuid":"cf143ce5-f0bd-4b33-899b-580b18b1be06","title":"ISO/TS 10303-1250:2018 Industrial automation systems and integration — Product data representation and exchange — Part 1250: Application module: Attachment slot","status":"Published","year":2021,"order":11,"text":"ISO/TS 10303-1250:2018-11 specifies the application module for\n         Attachment slot. The following are within the scope of \n         ISO/TS 10303-1250:2018-11: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","objectID":"77379_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2018 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>0: Application module: Attachment slot","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2018-11 specifies the application module for\n         Attachment slot. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>0:2018-11: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/26/52641","uuid":"97d15797-0739-4cb4-989b-045b9a71bbb7","title":"ISO/TS 10303-1252:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1252: Application module: Probability","status":"Published","year":2021,"order":11,"text":"ISO/TS 10303-1252:2010-03 specifies the application module for\n         Probability. The following are within the scope of \n         ISO/TS 10303-1252:2010-03: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","objectID":"52641_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>2: Application module: Probability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2010-03 specifies the application module for\n         Probability. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>2:2010-03: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38992","uuid":"c28a2d0e-191d-443e-8576-dbc4910c4713","title":"ISO/TS 10303-1254:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1254: Application module: Condition evaluation","status":"Published","year":2021,"order":11,"text":"ISO/TS 10303-1254:2004 specifies the application module for\n         Condition evaluation. The following are within the scope of \n         ISO/TS 10303-1254:2004: identification of the evaluation of a condition specified by a textual\n                 description that resulted in a logical; recording of parameter values evaluated and the logical result of\n                 the evaluation. ","objectID":"38992_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>4:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>4: Application module: Condition evaluation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>4:2004 specifies the application module for\n         Condition evaluation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>4:2004: identification of the evaluation of a condition specified by a textual\n                 description that resulted in a logical; recording of parameter values evaluated and the logical result of\n                 the evaluation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38990","uuid":"56ce79f3-f7da-4f74-80e0-887f3cae22a5","title":"ISO/TS 10303-1257:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1257: Application module: Condition characterized","status":"Published","year":2021,"order":11,"text":"ISO/TS 10303-1257:2004 specifies the application module for\n         Condition characterized. The following are within the scope of \n         ISO/TS 10303-1257:2004: approval assignments; date and time information; identification assignment; person and organization information; assignment of properties. ","objectID":"38990_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>7:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>7: Application module: Condition characterized","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>7:2004 specifies the application module for\n         Condition characterized. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>7:2004: approval assignments; date and time information; identification assignment; person and organization information; assignment of properties. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78628","uuid":"e0cbaa7f-f8a1-42e2-8b12-b0b7f2208bb6","title":"ISO/TS 10303-1259:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1259: Application module: Activity as realized","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1259:2019 specifies the application module for\n         Activity as realized. The following are within the scope of \n         ISO/TS 10303-1259:2019: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","objectID":"78628_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>9: Application module: Activity as realized","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2019 specifies the application module for\n         Activity as realized. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>9:2019: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78627","uuid":"f1d2f0a2-982c-4997-9387-eb2b2134e692","title":"ISO/TS 10303-1256:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1256: Application module: State observed","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1256:2019 specifies the application module for\n         State observed. The following are within the scope of \n         ISO/TS 10303-1256:2019: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","objectID":"78627_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>6: Application module: State observed","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2019 specifies the application module for\n         State observed. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>6:2019: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78626","uuid":"471a1fac-1693-4320-95d7-45e46232dd27","title":"ISO/TS 10303-1253:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1253: Application module: Condition","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1253:2019 specifies the application module for\n         Condition. The following are within the scope of \n         ISO/TS 10303-1253:2019: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","objectID":"78626_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>3: Application module: Condition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2019 specifies the application module for\n         Condition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>3:2019: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/86/78625","uuid":"3d97eaf9-780a-40eb-a156-335c3e72b651","title":"ISO/TS 10303-1251:2019 Industrial automation systems and integration — Product data representation and exchange — Part 1251: Application module: Interface","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1251:2019 specifies the application module for\n         Interface. The following are within the scope of \n         ISO/TS 10303-1251:2019: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","objectID":"78625_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2019 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>1: Application module: Interface","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2019 specifies the application module for\n         Interface. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>1:2019: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/06/60633","uuid":"0fe35040-5f6b-4927-b344-b5fbba72df2d","title":"ISO/TS 10303-1258:2011 Industrial automation systems and integration — Product data representation and exchange — Part 1258: Application module: Observation","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1258:2011-10 specifies the application module for\n         Observation. The following are within the scope of \n         ISO/TS 10303-1258:2011-10: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","objectID":"60633_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2011 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>8: Application module: Observation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2011-10 specifies the application module for\n         Observation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>8:2011-10: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/06/60632","uuid":"0ca6c985-f766-44e3-b32b-2d9ee00046a7","title":"ISO/TS 10303-1255:2011 Industrial automation systems and integration — Product data representation and exchange — Part 1255: Application module: State definition","status":"Published","year":2019,"order":11,"text":"ISO/TS 10303-1255:2011-10 specifies the application module for\n         State definition. The following are within the scope of \n         ISO/TS 10303-1255:2011-10: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","objectID":"60632_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2011 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>5: Application module: State definition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2011-10 specifies the application module for\n         State definition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>5:2011-10: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/73/77381","uuid":"8966f023-55a6-432d-a989-d059870debb8","title":"ISO/TS 10303-1253:2018 Industrial automation systems and integration — Product data representation and exchange — Part 1253: Application module: Condition","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1253:2018-11 specifies the application module for\n         Condition. The following are within the scope of \n         ISO/TS 10303-1253:2018-11: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","objectID":"77381_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2018 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>3: Application module: Condition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2018-11 specifies the application module for\n         Condition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>3:2018-11: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/06/60631","uuid":"11a98f1c-a4fd-4655-b67c-25235933f643","title":"ISO/TS 10303-1251:2011 Industrial automation systems and integration — Product data representation and exchange — Part 1251: Application module: Interface","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1251:2011-10 specifies the application module for\n         Interface. The following are within the scope of \n         ISO/TS 10303-1251:2011-10: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","objectID":"60631_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2011 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>1: Application module: Interface","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2011-10 specifies the application module for\n         Interface. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>1:2011-10: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/62/56237","uuid":"07a7b68a-8558-4763-871b-7a2d3322233d","title":"ISO/TS 10303-1259:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1259: Application module: Activity as realized","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1259:2010-03 specifies the application module for\n         Activity as realized. The following are within the scope of \n         ISO/TS 10303-1259:2010-03: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","objectID":"56237_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>9: Application module: Activity as realized","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>9:2010-03 specifies the application module for\n         Activity as realized. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>9:2010-03: the historical occurrence of an activity; the relationship of the historical occurrence of an activity to planned or defined activities. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/26/52643","uuid":"21de7b2c-11d2-45b8-b81b-e2f36f468e97","title":"ISO/TS 10303-1256:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1256: Application module: State observed","status":"Withdrawn","year":2019,"order":100,"text":"ISO/TS 10303-1256:2010-03 specifies the application module for\n         State observed. The following are within the scope of \n         ISO/TS 10303-1256:2010-03: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","objectID":"52643_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>6: Application module: State observed","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>6:2010-03 specifies the application module for\n         State observed. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>6:2010-03: identification of individual or realized states; relationship between two or more states; relationship between an individual or realized state and the product, activity, \n               people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/89/38989","uuid":"372320af-1ae4-4c67-9e1e-c517e23bb586","title":"ISO/TS 10303-1253:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1253: Application module: Condition","status":"Withdrawn","year":2018,"order":100,"text":"ISO/TS 10303-1253:2004 specifies the application module for\n         Condition. The following are within the scope of \n         ISO/TS 10303-1253:2004: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","objectID":"38989_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>3: Application module: Condition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>3:2004 specifies the application module for\n         Condition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>3:2004: condition specified by a textual description with a logical result; use of external entities as input to a condition expression; condition assignment; condition relationships. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/84/38465","uuid":"d0952d61-2c24-4727-a89c-f30f71d5e8ab","title":"ISO/TS 10303-1250:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1250: Application module: Attachment slot","status":"Withdrawn","year":2018,"order":100,"text":"ISO/TS 10303-1250:2004 specifies the application module for\n         Attachment slot. The following are within the scope of \n         ISO/TS 10303-1250:2004: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","objectID":"38465_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>0: Application module: Attachment slot","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>0:2004 specifies the application module for\n         Attachment slot. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>0:2004: identification of positions within an assembly of parts to which\n                 component parts may be attached; identification of parts that are attached to identified positions\n                 within an assembly. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/63/56356","uuid":"de7b6ddd-b003-46b0-8f49-fe5a7200f7fd","title":"ISO/TS 10303-1258:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1258: Application module: Observation","status":"Withdrawn","year":2012,"order":100,"text":"ISO/TS 10303-1258:2010-03 specifies the application module for\n         Observation. The following are within the scope of \n         ISO/TS 10303-1258:2010-03: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","objectID":"56356_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>8: Application module: Observation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2010-03 specifies the application module for\n         Observation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>8:2010-03: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/63/56335","uuid":"52a58cc2-156a-456d-be35-d7f082c01963","title":"ISO/TS 10303-1251:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1251: Application module: Interface","status":"Withdrawn","year":2012,"order":100,"text":"ISO/TS 10303-1251:2010-03 specifies the application module for\n         Interface. The following are within the scope of \n         ISO/TS 10303-1251:2010-03: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","objectID":"56335_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>1: Application module: Interface","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>1:2010-03 specifies the application module for\n         Interface. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>1:2010-03: the identification of the interface specification; the identification of a version of an interface specification; the representation of an interaction or connection between two or more products; the identification of the interface connector, the part of a product with which one or\n               more other products or the environment will interact. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/26/52642","uuid":"9acd39cc-64bb-4fd1-8e68-5a9c6cf25e65","title":"ISO/TS 10303-1255:2010 Industrial automation systems and integration — Product data representation and exchange — Part 1255: Application module: State definition","status":"Withdrawn","year":2012,"order":100,"text":"ISO/TS 10303-1255:2010-03 specifies the application module for\n         State definition. The following are within the scope of \n         ISO/TS 10303-1255:2010-03: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","objectID":"52642_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2010 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>5: Application module: State definition","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>5:2010-03 specifies the application module for\n         State definition. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>5:2010-03: definition of state; definition of what is needed for a state definition to exist; relationship between two or more state definitions; relationship between a state definition or type of state and the product, activity, \n             people or organization that it affects. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/93/39332","uuid":"711221b9-9d69-47b1-9359-9d60ff8f8e50","title":"ISO/TS 10303-1258:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1258: Application module: Observation","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1258:2004 specifies the application module for\n         Observation. The following are within the scope of \n         ISO/TS 10303-1258:2004: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","objectID":"39332_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>8: Application module: Observation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>8:2004 specifies the application module for\n         Observation. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>8:2004: the observation of historical facts about products, resources, and activities which are otherwise outside of the scope of\n            the standard; the association of an observation to the thing observed; the association of an observation to its context; the association of an observation to the actual activity taking place when it was observed; the association of the observation with the observer; the association of the observation to its consequences; the association of observations with each other; the aggregation of observations; the record of the date and time that the observation was made; the classification of the observation; the formal verification or confirmation of the observation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/93/39330","uuid":"4eb4b214-e041-4e49-9394-dc1d2e2b8e9d","title":"ISO/TS 10303-1252:2004 Industrial automation systems and integration — Product data representation and exchange — Part 1252: Application module: Probability","status":"Withdrawn","year":2010,"order":100,"text":"ISO/TS 10303-1252:2004 specifies the application module for\n         Probability. The following are within the scope of \n         ISO/TS 10303-1252:2004: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","objectID":"39330_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2004 Industrial automation systems and integration — Product data representation and exchange — Part <em>125</em>2: Application module: Probability","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]},"text":{"value":"<em>ISO</em>/TS 10303-<em>125</em>2:2004 specifies the application module for\n         Probability. The following are within the scope of \n         <em>ISO</em>/TS 10303-<em>125</em>2:2004: the specification of a numerical value for a probability; the specification of probability by classification; the designation of persons or organizations specifying the probability. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","125"]}}}],"nbHits":197,"page":0,"nbPages":2,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 125","params":"query=ISO+125&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":5}
61
61
  http_version:
62
- recorded_at: Mon, 17 Jan 2022 09:56:49 GMT
62
+ recorded_at: Sat, 22 Jan 2022 10:39:20 GMT
63
63
  - request:
64
64
  method: get
65
- uri: https://www.iso.org/contents/data/standard/02/32/23281.html
65
+ uri: https://www.iso.org/contents/data/standard/07/28/72849.html
66
66
  body:
67
67
  encoding: US-ASCII
68
68
  string: ''
@@ -89,218 +89,23 @@ http_interactions:
89
89
  Set-Cookie:
90
90
  - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
91
91
  Secure
92
- - JSESSIONID=2272C52B0CEB0D90FBF59A9778FB29D5; Path=/; Secure; HttpOnly
92
+ - JSESSIONID=6702BECFC2EC8A75A92D1F1CF1C45C65; Path=/; Secure; HttpOnly
93
93
  Location:
94
- - "/standard/23281.html"
94
+ - "/standard/72849.html"
95
95
  Content-Length:
96
96
  - '0'
97
97
  Date:
98
- - Mon, 17 Jan 2022 09:56:51 GMT
98
+ - Sat, 22 Jan 2022 10:39:22 GMT
99
99
  Strict-Transport-Security:
100
100
  - max-age=31536000; includeSubDomains
101
101
  body:
102
102
  encoding: UTF-8
103
103
  string: ''
104
104
  http_version:
105
- recorded_at: Mon, 17 Jan 2022 09:56:51 GMT
105
+ recorded_at: Sat, 22 Jan 2022 10:39:22 GMT
106
106
  - request:
107
107
  method: get
108
- uri: https://www.iso.org/standard/23281.html
109
- body:
110
- encoding: US-ASCII
111
- string: ''
112
- headers:
113
- Accept-Encoding:
114
- - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
115
- Accept:
116
- - "*/*"
117
- User-Agent:
118
- - Ruby
119
- Host:
120
- - www.iso.org
121
- response:
122
- status:
123
- code: 200
124
- message: ''
125
- headers:
126
- Expires:
127
- - Wed, 09 May 1979 05:30:00 GMT
128
- Cache-Control:
129
- - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
130
- Pragma:
131
- - no-cache
132
- Set-Cookie:
133
- - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
134
- Secure
135
- - JSESSIONID=A9D72C25696DB052D409A92A78A931D0; Path=/; Secure; HttpOnly
136
- Vary:
137
- - accept-encoding
138
- Content-Type:
139
- - text/html;charset=UTF-8
140
- Transfer-Encoding:
141
- - chunked
142
- Date:
143
- - Mon, 17 Jan 2022 09:56:53 GMT
144
- Strict-Transport-Security:
145
- - max-age=31536000; includeSubDomains
146
- body:
147
- encoding: ASCII-8BIT
148
- string: !binary |-
149
- <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 123:2001 - Rubber latex — Sampling</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/23281.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1638177692575" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1638177692575"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20210607" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/02/32/23281.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 123:2001" />
    <meta property="og:title" content="ISO 123:2001" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Rubber latex — Sampling" />
    <meta property="og:description" content="Rubber latex — Sampling" />
    <meta name="description" content="Rubber latex — Sampling" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html" class="dropdown-toggle" role="button">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/23281.html">français</a></li><li><a href="/ru/standard/23281.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="23281 - ISO 123:2001 - Rubber latex — Sampling"></span>

  <span class="hidden" id="itemReference">ISO 123:2001</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">23281</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/83.html">83</a> >&nbsp;<a href="/en/ics/83.040.html">83.040</a> >&nbsp;<a href="/en/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 123:2001</h1>
  <h2 class="no-uppercase">Rubber latex — Sampling</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

    <section class="bg-lightgray section-sm">
      <div class="container">
        <div class="row">
          <div class="col-md-7">
            <h3 role="alert" class="no-margin">
              This standard was last reviewed and confirmed in&nbsp;2021.
              Therefore this version remains current.
            </h3>
          </div>
        </div>
      </div>
    </section>
  
<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:23281:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>This International Standard specifies procedures for sampling natural rubber latex concentrate and for sampling synthetic</p>
<p>rubber latices and artificial latices. It is also suitable for sampling rubber latex contained in drums, tank cars or</p>
<p>tanks. The procedures may also be used for sampling plastics dispersions.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/02/32/23281.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2001-05</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 3
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 8
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Raw materials (including latex) for use in the rubber industry</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex and raw rubber</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/en/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Sustainable Development Goals" />
      </p>
      <p>
        This standard contributes to the following  <a href="/sdgs.html">Sustainable Development Goals</a>:
      <p>
      <div class="clearfix">
        
          <a href="/sdg/SDG12.html" title="Responsible Consumption and Production">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Responsible Consumption and Production</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/sdg/SDG09.html" title="Industry, Innovation and Infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industry, Innovation and Infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2RAAW~a0fb0000000ebFrAAI~a0cb0000001QfUkAAK" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2RAAW~a0fb0000000ebPyAAI~a0cb0000001QfVHAA0" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2WAAW~a0fb0000000ebPoAAI~a0cb0000001QfWqAAK" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2WAAW~a0fb0000000ebPtAAI~a0cb0000001QfSLAA0" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/3926.html">ISO 123:1985</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 123:2001</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.93</strong> (Confirmed)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#20_00">
                              <span class="stage-code">20.00</span>
                              <span class="stage-date">1993-08-15</span>
                              <div class="stage-title">
                                New project registered in TC/SC work programme
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#20_20">
                              <span class="stage-code">20.20</span>
                              <span class="stage-date">1993-11-19</span>
                              <div class="stage-title">
                                Working draft (WD) study initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#20_99">
                              <span class="stage-code">20.99</span>
                              <span class="stage-date">1995-12-15</span>
                              <div class="stage-title">
                                WD approved for registration as CD
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">1996-07-26</span>
                              <div class="stage-title">
                                Committee draft (CD) registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">1996-07-26</span>
                              <div class="stage-title">
                                CD study/ballot initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">1996-10-28</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">1997-09-22</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">1997-10-30</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">1998-04-20</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2000-06-29</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2000-08-29</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2000-12-07</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2001-02-28</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2001-03-05</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2001-05-31</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2005-11-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2006-07-31</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2006-07-31</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2011-01-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2011-06-17</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2011-06-21</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2016-01-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2016-06-17</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2016-06-24</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2021-01-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2021-06-05</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2021-06-07</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard proposed by TC or SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/83.html">83</a></li>
    
      <li><a href="/en/ics/83.040.html">83.040</a></li>
    
      <li><a href="/en/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 123:2001</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
150
- http_version:
151
- recorded_at: Mon, 17 Jan 2022 09:56:54 GMT
152
- - request:
153
- method: get
154
- uri: https://www.iso.org/fr/standard/23281.html
155
- body:
156
- encoding: US-ASCII
157
- string: ''
158
- headers:
159
- Accept-Encoding:
160
- - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
161
- Accept:
162
- - "*/*"
163
- User-Agent:
164
- - Ruby
165
- Host:
166
- - www.iso.org
167
- response:
168
- status:
169
- code: 200
170
- message: ''
171
- headers:
172
- Expires:
173
- - Wed, 09 May 1979 05:30:00 GMT
174
- Cache-Control:
175
- - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
176
- Pragma:
177
- - no-cache
178
- Set-Cookie:
179
- - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
180
- Secure
181
- - JSESSIONID=0BBAFD5A094F8C5B33F02E4010C10D90; Path=/; Secure; HttpOnly
182
- Vary:
183
- - accept-encoding
184
- Content-Type:
185
- - text/html;charset=UTF-8
186
- Transfer-Encoding:
187
- - chunked
188
- Date:
189
- - Mon, 17 Jan 2022 09:56:56 GMT
190
- Strict-Transport-Security:
191
- - max-age=31536000; includeSubDomains
192
- body:
193
- encoding: ASCII-8BIT
194
- string: !binary |-
195
- <!DOCTYPE html>


<html lang="fr">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'fr'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 123:2001 - Latex de caoutchouc — Échantillonnage</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/fr/standard/23281.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"fr",uilang:"fr",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='fr_FR';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1638177692575" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1638177692575"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20210607" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/fr/sites/isoorg/contents/data/standard/02/32/23281.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 123:2001" />
    <meta property="og:title" content="ISO 123:2001" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Latex de caoutchouc — Échantillonnage" />
    <meta property="og:description" content="Latex de caoutchouc — Échantillonnage" />
    <meta name="description" content="Latex de caoutchouc — Échantillonnage" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Passer au contenu principal</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/standards.html" class="dropdown-toggle" role="button">Normes</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html" class="dropdown-toggle" role="button">Avantages</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-and-smes.html" class="dropdown-toggle" role="button">PME</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-consumers.html" class="dropdown-toggle" role="button">Consommateurs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-policy-makers.html" class="dropdown-toggle" role="button">L’ISO et les organismes de réglementation</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/standards-in-action.html" class="dropdown-toggle" role="button">Normes en action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html" class="dropdown-toggle" role="button">Les normes les plus connues</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformité</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/the-iso-survey.html" class="dropdown-toggle" role="button">L'Étude ISO</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html" class="dropdown-toggle" role="button">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/about-us.html" class="dropdown-toggle" role="button">À propos de l'ISO</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/what-we-do.html" class="dropdown-toggle" role="button">Nos activités</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/developing-standards.html"  class="dropdown-toggle" role="button">Elaboration des normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/research-and-education.html" class="dropdown-toggle" role="button">Recherche</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/capacity-building.html" class="dropdown-toggle" role="button">Renforcement des capacités</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/education-about-standards.html" class="dropdown-toggle" role="button">Enseignement sur les normes</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html" class="dropdown-toggle" role="button">Membres</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/announcements.html" class="dropdown-toggle" role="button">Communiqués</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/fr/strategy2030.html" class="dropdown-toggle" role="button">Stratégie 2030</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Facteurs de changement</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Nos objectifs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Mesurer le succès</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/news.html" class="dropdown-toggle" role="button">Actualités</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html" class="dropdown-toggle" role="button">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html" class="dropdown-toggle" role="button">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/developing-standards.html" class="dropdown-toggle" role="button">Participer</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html" class="dropdown-toggle" role="button">Qui élabore les normes</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/technical-committees.html" class="dropdown-toggle" role="button">Comités techniques</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Autres organismes</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organisations en coopération</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html" class="dropdown-toggle" role="button">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html" class="dropdown-toggle" role="button">Pourquoi s’engager ?</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/ClimateAction.html" class="dropdown-toggle" role="button">Kit d’action pour le climat</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/fr/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html" class="dropdown-toggle" role="button">Publications et produits</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/fr/#account/products"  target="_blank" class="dropdown-toggle" role="button">Mon compte</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/fr/home.html" title="Organisation internationale de normalisation" alt="Logo ISO"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/fr"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Recherche</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=fr" title="Panier d'achat" aria-label="Panier d'achat">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">FR <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/standard/23281.html">English</a></li><li><a href="/ru/standard/23281.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/news.html">Actualités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="23281 - ISO 123:2001 - Latex de caoutchouc — Échantillonnage"></span>

  <span class="hidden" id="itemReference">ISO 123:2001</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">23281</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="Organisation internationale de normalisation">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/fr/standards-catalogue/browse-by-ics.html"title="Explorez la collection de normes ISO dans son intégralité et trouvez celles qui s’appliquent à votre secteur.">ICS</a> >&nbsp;<a href="/fr/ics/83.html">83</a> >&nbsp;<a href="/fr/ics/83.040.html">83.040</a> >&nbsp;<a href="/fr/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 123:2001</h1>
  <h2 class="no-uppercase">Latex de caoutchouc — Échantillonnage</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Acheter cette norme
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

    <section class="bg-lightgray section-sm">
      <div class="container">
        <div class="row">
          <div class="col-md-7">
            <h3 role="alert" class="no-margin">
              Le dernier examen de cette norme date de&nbsp;2021.
              Cette édition reste donc d’actualité.
            </h3>
          </div>
        </div>
      </div>
    </section>
  
<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Résumé&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:23281:fr">Prévisualiser</a></h3>
          <div itemprop="description">
            <p><p>La présente Norme internationale spécifie des méthodes d'échantillonnage pour des concentrés de latex de caoutchouc</p>
<p>naturel et pour échantillonner des latex de caoutchouc synthétique et des latex artificiels. Elle s'applique également</p>
<p>à l'échantillonnage de latex de caoutchouc contenus dans des fûts, citernes routières ou de stockage. Le</p>
<p>mode opératoire peut aussi être utilisé pour l'échantillonnage de dispersions de plastiques.</p></p>
          </div>
          <br/>
        <h3>
  Informations générales
  <sup><a href="/fr/contents/data/standard/02/32/23281.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="S'abonner&nbsp;aux&nbsp;mises&nbsp;à&nbsp;jour">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>État actuel&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Publiée"></span>Publiée</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Date de publication&nbsp;: </strong><span itemprop="releaseDate">2001-05</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 3
      </div>
      <div class="col-sm-6">
        
          <strong>Nombre de pages&nbsp;:</strong> 8
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Comité technique</div> :
        <div class="entry-name entry-block">
          <a href="/fr/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Matières premières (y compris le latex) à l'usage de l'industrie des élastomères</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/fr/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex et caoutchouc brut</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/fr/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Objectifs de développement durable" />
      </p>
      <p>
        Cette norme contribue aux  <a href="/fr/sdgs.html">Objectifs de développement durable</a>&nbsp;suivants&nbsp;:
      <p>
      <div class="clearfix">
        
          <a href="/fr/sdg/SDG12.html" title="Consommation et production responsables">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Consommation et production responsables</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/fr/sdg/SDG09.html" title="Industrie, innovation et infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industrie, innovation et infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Acheter&nbsp;cette norme</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">fr</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Langue</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2RAAW~a0fb0000000ebFrAAI~a0cb0000001QfUkAAK" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2RAAW~a0fb0000000ebPyAAI~a0cb0000001QfVHAA0" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Papier
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2WAAW~a0fb0000000ebPoAAI~a0cb0000001QfWqAAK" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub00000028HiiAAE~a05b0000005WV2WAAW~a0fb0000000ebPtAAI~a0cb0000001QfSLAA0" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'fr', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Acheter
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Valider mon panier"></span>
            <span id="continueShopping" class="hidden" data-label="Ajouter au panier et continuer mes achats"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Cycle de vie</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Précédemment</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Annulée</div>
                    <h5><a href="/fr/standard/3926.html">ISO 123:1985</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Actuellement</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Publiée</div>
                    
              <h5>ISO 123:2001</h5>
                  <br/>Les normes ISO sont réexaminées tous les cinq ans<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stade: <strong>90.93</strong> (Confirmée)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Préliminaire</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposition</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Préparation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#20_00">
                              <span class="stage-code">20.00</span>
                              <span class="stage-date">1993-08-15</span>
                              <div class="stage-title">
                                Nouveau projet enregistré au programme de travail du TC/SC
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#20_20">
                              <span class="stage-code">20.20</span>
                              <span class="stage-date">1993-11-19</span>
                              <div class="stage-title">
                                Mise à l'étude du projet de travail (WD)
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#20_99">
                              <span class="stage-code">20.99</span>
                              <span class="stage-date">1995-12-15</span>
                              <div class="stage-title">
                                WD approuvé pour enregistrement comme CD
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Comité</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">1996-07-26</span>
                              <div class="stage-title">
                                Projet de comité (CD) enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">1996-07-26</span>
                              <div class="stage-title">
                                Mise à l'étude/au vote du CD
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">1996-10-28</span>
                              <div class="stage-title">
                                CD approuvé pour enregistrement comme DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquête</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">1997-09-22</span>
                              <div class="stage-title">
                                DIS enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">1997-10-30</span>
                              <div class="stage-title">
                                Mise au vote du DIS:  12 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">1998-04-20</span>
                              <div class="stage-title">
                                Clôture du vote
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2000-06-29</span>
                              <div class="stage-title">
                                Rapport complet diffusé: DIS approuvé pour enregistrement comme FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approbation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2000-08-29</span>
                              <div class="stage-title">
                                Texte final reçu ou FDIS enregistré pour approbation formelle
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2000-12-07</span>
                              <div class="stage-title">
                                Epreuve envoyée au secrétariat ou mise au vote du FDIS: 8 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2001-02-28</span>
                              <div class="stage-title">
                                Clôture du vote Epreuve retournée par le secrétariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2001-03-05</span>
                              <div class="stage-title">
                                Norme internationale en cours de publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2001-05-31</span>
                              <div class="stage-title">
                                Norme internationale publiée
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Examen</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2005-11-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2006-07-31</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2006-07-31</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2011-01-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2011-06-17</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2011-06-21</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2016-01-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2016-06-17</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2016-06-24</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2021-01-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2021-06-05</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2021-06-07</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Annulation de la Norme internationale proposée par le TC ou SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Annulation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Annulation de la Norme internationale
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Vous avez une question?</h4>

<p>Consulter notre&nbsp;<a href="/fr/frequently-asked-questions-faqs.html" title="Foire Aux Questions (FAQs)">FAQ</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Service &agrave; la client&egrave;le</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Horaires d&rsquo;ouverture:<br />
De lundi &agrave; vendredi - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Suivez l&#39;actualit&eacute; de l&#39;ISO</h4>

<p>Inscrivez-vous &agrave; notre Newsletter (en anglais) pour suivre nos actualit&eacute;s, points de vue et informations sur nos produits.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/fr/home.html" title="Page d'accueil"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/fr/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a>

        </li>
      
        <li>
          
              <a href="/fr/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/fr/ics/83.html">83</a></li>
    
      <li><a href="/fr/ics/83.040.html">83.040</a></li>
    
      <li><a href="/fr/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 123:2001</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Plan du site</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html">Avantages</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html">Les normes les plus connues</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/conformity-assessment.html">Certification & conformité</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/what-we-do.html">Nos activités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html">Membres</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030.html">Stratégie 2030</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/news.html">Actualités</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html">Qui élabore les normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html">Pourquoi s’engager ?</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/ClimateAction.html">Kit d’action pour le climat</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html">Publications et produits</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-name-and-logo.html">Nom et logo de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/privacy-and-copyright.html">Confidentialité et droit d'auteur</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/working-with-iso.html" >Emploi</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/frequently-asked-questions-faqs.html">FAQ</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/contact-iso.html">Contacter l'ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Le monde va loin quand il s'accorde</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">Nous nous engageons à ce que notre site Web soit accessible à tous. Pour toute question ou suggestion concernant l'accessibilité du site, <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contactez-nous</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© Tous droits réservés</a> <span id="copyright" class="collapse">Le matériel publié sur ISO.org est sujet aux mêmes conditions en matière de droits d’auteur que les publications de l’ISO et son emploi est conditionné par l’acceptation, par l’utilisateur, des conditions de l’ISO en matière de droits d’auteur régissant les publications de l’ISO. Toute utilisation du matériel concerné, y compris sa reproduction intégrale ou partielle vers un autre site Internet, requiert l’autorisation écrite de l’ISO. Toute demande à cet effet doit être adressée à <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Retour en haut de page"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression" /></div>
            <div class="poweredby-txt">Développé par</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
196
- http_version:
197
- recorded_at: Mon, 17 Jan 2022 09:56:56 GMT
198
- - request:
199
- method: post
200
- uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
201
- body:
202
- encoding: UTF-8
203
- string: '{"query":"ISO 124","hitsPerPage":100,"filters":"category:standard"}'
204
- headers:
205
- User-Agent:
206
- - Algolia for Ruby (2.1.1), Ruby (3.0.3)
207
- X-Algolia-Api-Key:
208
- - dd1b9e1ab383f4d4817d29cd5e96d3f0
209
- X-Algolia-Application-Id:
210
- - JCL49WV5AR
211
- Content-Type:
212
- - application/json; charset=utf-8
213
- Accept-Encoding:
214
- - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
215
- Accept:
216
- - "*/*"
217
- Connection:
218
- - keep-alive
219
- Keep-Alive:
220
- - '30'
221
- response:
222
- status:
223
- code: 200
224
- message: OK
225
- headers:
226
- Server:
227
- - nginx
228
- Date:
229
- - Mon, 17 Jan 2022 09:56:58 GMT
230
- Content-Type:
231
- - application/json; charset=UTF-8
232
- Transfer-Encoding:
233
- - chunked
234
- Connection:
235
- - keep-alive
236
- X-Alg-Pt:
237
- - '1'
238
- Accept-Encoding:
239
- - deflate, gzip
240
- Cache-Control:
241
- - no-store
242
- Access-Control-Allow-Origin:
243
- - "*"
244
- Timing-Allow-Origin:
245
- - "*"
246
- X-Content-Type-Options:
247
- - nosniff
248
- Strict-Transport-Security:
249
- - max-age=31536000; includeSubDomains; preload
250
- Content-Disposition:
251
- - inline; filename=a.txt
252
- body:
253
- encoding: ASCII-8BIT
254
- string: !binary |-
255
- {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/18/61884","uuid":"d27dc6f0-f9fc-487d-9c60-c61ec36278cc","title":"ISO 124:2014 Latex, rubber — Determination of total solids content","status":"Published","year":2019,"order":11,"text":"ISO 124:2014 specifies methods for the determination of the total solids content of natural rubber field and concentrated latices and synthetic rubber latex. These methods are not necessarily suitable for latex from natural sources other than the Hevea brasiliensis , for vulcanized latex, for compounded latex, or for artificial dispersions of rubber. ","objectID":"61884_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:2014 Latex, rubber — Determination of total solids content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>:2014 specifies methods for the determination of the total solids content of natural rubber field and concentrated latices and synthetic rubber latex. These methods are not necessarily suitable for latex from natural sources other than the Hevea brasiliensis , for vulcanized latex, for compounded latex, or for artificial dispersions of rubber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/92/59264","uuid":"d5a8d59d-9749-4d68-9d40-735df178d017","title":"ISO 124:2011 Latex, rubber — Determination of total solids content","status":"Withdrawn","year":2014,"order":100,"text":"ISO 124:2011 specifies methods for the determination of the total solids content of natural rubber latex concentrate and synthetic rubber latices. These methods are not necessarily suitable for latex from natural sources other than the Hevea brasiliensis , for vulcanized latex, for compounded latex or for artificial dispersions of rubber. ","objectID":"59264_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:2011 Latex, rubber — Determination of total solids content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>:2011 specifies methods for the determination of the total solids content of natural rubber latex concentrate and synthetic rubber latices. These methods are not necessarily suitable for latex from natural sources other than the Hevea brasiliensis , for vulcanized latex, for compounded latex or for artificial dispersions of rubber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/10/51088","uuid":"d102e36c-6d78-4b9d-8e4d-281be125a37d","title":"ISO 124:2008 Latex, rubber — Determination of total solids content","status":"Withdrawn","year":2011,"order":100,"text":"ISO 124:2008 specifies methods for the determination of the total solids content of natural rubber latex concentrate and synthetic rubber latices. These methods are not necessarily suitable for latex from natural sources other than the Hevea Brasiliensis , for vulcanized latex, for compounded latex or for artificial dispersions of rubber. ","objectID":"51088_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:2008 Latex, rubber — Determination of total solids content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>:2008 specifies methods for the determination of the total solids content of natural rubber latex concentrate and synthetic rubber latices. These methods are not necessarily suitable for latex from natural sources other than the Hevea Brasiliensis , for vulcanized latex, for compounded latex or for artificial dispersions of rubber. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/37/43711","uuid":"2c021bc8-8947-4a59-91c8-9e18d57353ec","title":"ISO 124:1997/Amd 2:2008 Latex, rubber — Determination of total solids content — Amendment 2: Determination at temperatures higher than 105 degrees C","status":"Withdrawn","year":2008,"order":100,"objectID":"43711_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:1997/Amd 2:2008 Latex, rubber — Determination of total solids content — Amendment 2: Determination at temperatures higher than 105 degrees C","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/28/42824","uuid":"ab71a1cf-23fe-4c42-b2cd-6c96247f567c","title":"ISO 124:1997/Amd 1:2006 Latex, rubber — Determination of total solids content — Amendment 1: Precision data","status":"Withdrawn","year":2008,"order":100,"objectID":"42824_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:1997/Amd 1:2006 Latex, rubber — Determination of total solids content — Amendment 1: Precision data","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/38/23842","uuid":"407ecc0f-deab-46bd-8318-44fa7ffb1fb0","title":"ISO 124:1997 Latex, rubber — Determination of total solids content","status":"Withdrawn","year":2008,"order":100,"objectID":"23842_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:1997 Latex, rubber — Determination of total solids content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3929","uuid":"9cf12561-d76a-494f-bfcf-2ef5ee70e93e","title":"ISO 124:1992 Rubber latices — Determination of total solids content","status":"Withdrawn","year":1997,"order":100,"objectID":"3929_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:1992 Rubber latices — Determination of total solids content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3928","uuid":"41b5bbf4-6ff2-40ab-b3f1-640665101732","title":"ISO 124:1985 Rubber latices — Determination of total solids content","status":"Withdrawn","year":1992,"order":100,"objectID":"3928_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:1985 Rubber latices — Determination of total solids content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/39/3927","uuid":"2da3e119-3b8f-4233-93ac-a81178ff40e2","title":"ISO 124:1974 Rubber latices — Determination of total solids content","status":"Withdrawn","year":1985,"order":100,"objectID":"3927_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>:1974 Rubber latices — Determination of total solids content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/71/77127","uuid":"6b3712a0-6c48-49b7-834b-d6ae78997d71","title":"ISO 1247-2:2021 Aluminium pigments for paints — Part 2: Vacuum metallized aluminium pigments","status":"Published","year":2021,"order":11,"text":"This document specifies the requirements and corresponding test methods for vacuum metallized aluminium pigments (VMP) suitable for use in paints and printing ink industries. ","objectID":"77127_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>7-2:2021 Aluminium pigments for paints — Part 2: Vacuum metallized aluminium pigments","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the requirements and corresponding test methods for vacuum metallized aluminium pigments (VMP) suitable for use in paints and printing ink industries. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/52/75242","uuid":"7876264b-5519-48a7-84b7-25c95f1d8cdd","title":"ISO 12404:2021 Soil and waste — Guidance on the selection and application of screening methods","status":"Published","year":2021,"order":11,"text":"This document provides guidance on the selection and application of screening methods for assessing soil quality and waste characterization, including distribution of target parameters in soil and soil ‑ like material. The aim of this document is to set up criteria as to when the different kind of screening methods can be applied for the analysis of a certain parameter in soil, including soil ‑ like material, and waste, and which steps are required to prove their suitability. This document does not recommend any particular screening method but confirms the principles of their selection and application. ","objectID":"75242_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>04:2021 Soil and waste — Guidance on the selection and application of screening methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document provides guidance on the selection and application of screening methods for assessing soil quality and waste characterization, including distribution of target parameters in soil and soil ‑ like material. The aim of this document is to set up criteria as to when the different kind of screening methods can be applied for the analysis of a certain parameter in soil, including soil ‑ like material, and waste, and which steps are required to prove their suitability. This document does not recommend any particular screening method but confirms the principles of their selection and application. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/51/75151","uuid":"560caa32-6f23-4ffe-8f31-56e3c9413165","title":"ISO 1247-1:2021 Aluminium pigments for paints — Part 1: General aluminium pigments","status":"Published","year":2021,"order":11,"text":"This document specifies the requirements and corresponding test methods for aluminium pigments suitable for use in paints including: a) general, decorative and protective paints, and b) special finishing paints. ","objectID":"75151_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>7-1:2021 Aluminium pigments for paints — Part 1: General aluminium pigments","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the requirements and corresponding test methods for aluminium pigments suitable for use in paints including: a) general, decorative and protective paints, and b) special finishing paints. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/49/64998","uuid":"b75fb9d3-3da3-46d8-84ab-7d4355d6f552","title":"ISO 12460-4:2016 Wood-based panels — Determination of formaldehyde release — Part 4: Desiccator method","status":"Published","year":2021,"order":11,"text":"ISO 12460-4:2016 specifies a desiccator method for the determination of the quantity of formaldehyde emitted from particleboard, fibreboard, plywood, oriented strand board (OSB) and wooden laminated flooring. ","objectID":"64998_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-4:2016 Wood-based panels — Determination of formaldehyde release — Part 4: Desiccator method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>60-4:2016 specifies a desiccator method for the determination of the quantity of formaldehyde emitted from particleboard, fibreboard, plywood, oriented strand board (OSB) and wooden laminated flooring. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/30/63066","uuid":"0e7a46e3-e5c4-4ab2-a5b7-c6b4b406f962","title":"ISO 12460-5:2015 Wood-based panels — Determination of formaldehyde release — Part 5: Extraction method (called the perforator method)","status":"Published","year":2021,"order":11,"text":"ISO 12460-5:2015 specifies an extraction method known as the \"perforator method\". It is used for the determination of the formaldehyde content of unlaminated and uncoated wood-based panels. ","objectID":"63066_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-5:2015 Wood-based panels — Determination of formaldehyde release — Part 5: Extraction method (called the perforator method)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>60-5:2015 specifies an extraction method known as the \"perforator method\". It is used for the determination of the formaldehyde content of unlaminated and uncoated wood-based panels. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51473","uuid":"501c5bc7-ce24-4e2f-8403-1a6afcc1464c","title":"ISO 12492:2012 Rubber, raw — Determination of water content by Karl Fischer method","status":"Published","year":2021,"order":11,"text":"ISO 12492:2012 specifies a test method for the determination of water content of raw rubber and compounded rubber using a coulometric Karl Fischer titration method. It applies to the range for the water content between 0,01 % and 1 %. As this is a very sensitive method, contact of sample with any moisture, even from the surrounding environment, must be eliminated as much as possible. ","objectID":"51473_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>92:2012 Rubber, raw — Determination of water content by Karl Fischer method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>92:2012 specifies a test method for the determination of water content of raw rubber and compounded rubber using a coulometric Karl Fischer titration method. It applies to the range for the water content between 0,01 % and 1 %. As this is a very sensitive method, contact of sample with any moisture, even from the surrounding environment, must be eliminated as much as possible. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51418","uuid":"dc3c9966-9839-4fa0-8b55-52bfffe154ba","title":"ISO 12406:2010 Surface chemical analysis — Secondary-ion mass spectrometry — Method for depth profiling of arsenic in silicon","status":"Published","year":2021,"order":11,"text":"ISO 12406:2010 specifies a secondary-ion mass spectrometric method using magnetic-sector or quadrupole mass spectrometers for depth profiling of arsenic in silicon, and using stylus profilometry or optical interferometry for depth calibration. This method is applicable to single-crystal, poly-crystal or amorphous silicon specimens with arsenic atomic concentrations between 1 x 10 16 atoms/cm 3 and 2,5 x 10 21 atoms/cm 3 , and to crater depths of 50 nm or deeper. ","objectID":"51418_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>06:2010 Surface chemical analysis — Secondary-ion mass spectrometry — Method for depth profiling of arsenic in silicon","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>06:2010 specifies a secondary-ion mass spectrometric method using magnetic-sector or quadrupole mass spectrometers for depth profiling of arsenic in silicon, and using stylus profilometry or optical interferometry for depth calibration. This method is applicable to single-crystal, poly-crystal or amorphous silicon specimens with arsenic atomic concentrations between 1 x 10 16 atoms/cm 3 and 2,5 x 10 21 atoms/cm 3 , and to crater depths of 50 nm or deeper. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/03/50309","uuid":"de68cbc2-03b9-439d-9637-65feb39778b0","title":"ISO 12439:2010 Mixing water for concrete","status":"Published","year":2021,"order":11,"text":"ISO 12439_2010 specifies the requirements for water that is suitable for making concrete in accordance with ISO 22965 (all parts) and describes methods for assessing its suitability. ","objectID":"50309_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>39:2010 Mixing water for concrete","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>39_2010 specifies the requirements for water that is suitable for making concrete in accordance with <em>ISO</em> 22965 (all parts) and describes methods for assessing its suitability. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/03/40333","uuid":"3223e8be-3729-4201-8c97-816b8a0187e5","title":"ISO 12465:2007 Plywood — Specifications","status":"Published","year":2021,"order":11,"text":"ISO 12465:2007 establishes requirements for the specification of plywood for general and structural use, in dry, tropical dry/humid and high-humidity/exterior conditions. It includes requirements for the quality of veneer, glue bond, lay-up (construction), dimensions and tolerances, conformance verification and marking. The values listed in ISO 12465:2007 relate to product properties, but they are not characteristic values to be used in design calculations. Additional information on supplementary properties for certain applications is also given. ","objectID":"40333_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>65:2007 Plywood — Specifications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>65:2007 establishes requirements for the specification of plywood for general and structural use, in dry, tropical dry/humid and high-humidity/exterior conditions. It includes requirements for the quality of veneer, glue bond, lay-up (construction), dimensions and tolerances, conformance verification and marking. The values listed in <em>ISO</em> <em>124</em>65:2007 relate to product properties, but they are not characteristic values to be used in design calculations. Additional information on supplementary properties for certain applications is also given. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/01/40124","uuid":"4c251d0b-cbe9-4ac3-831b-ac5530e9e1d4","title":"ISO 12466-2:2007 Plywood — Bonding quality — Part 2: Requirements","status":"Published","year":2021,"order":11,"text":"ISO 12466-2:2007 specifies requirements for determination of bonding quality class of plywood, blockboard, battenboard, and laminboard, bonded with thermosetting resins, according to their intended end uses. ","objectID":"40124_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>66-2:2007 Plywood — Bonding quality — Part 2: Requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>66-2:2007 specifies requirements for determination of bonding quality class of plywood, blockboard, battenboard, and laminboard, bonded with thermosetting resins, according to their intended end uses. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/25/2534","uuid":"79e2212f-dcf2-43f4-8041-4ddb94ed3b69","title":"ISO 12480-1:1997 Cranes — Safe use — Part 1: General","status":"Published","year":2021,"order":11,"objectID":"2534_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>80-1:1997 Cranes — Safe use — Part 1: General","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/53/25313","uuid":"89ca50fd-0105-4548-a879-e134bbea6749","title":"ISO 1242:1999 Essential oils — Determination of acid value","status":"Published","year":2021,"order":11,"objectID":"25313_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>2:1999 Essential oils — Determination of acid value","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/50/75055","uuid":"bba811a7-5ef9-445d-a02f-0e486b732acb","title":"ISO 12460-3:2020 Wood-based panels — Determination of formaldehyde release — Part 3: Gas analysis method","status":"Published","year":2020,"order":11,"text":"This document specifies a procedure for determination of accelerated formaldehyde release from uncoated and coated wood-based panels using the gas analysis method. The procedure is also suitable for the testing of other materials (e.g. edge bands, floor coverings, foams, foils, laminated wood products, veneered wood products, coated wood products). ","objectID":"75055_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-3:2020 Wood-based panels — Determination of formaldehyde release — Part 3: Gas analysis method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies a procedure for determination of accelerated formaldehyde release from uncoated and coated wood-based panels using the gas analysis method. The procedure is also suitable for the testing of other materials (e.g. edge bands, floor coverings, foams, foils, laminated wood products, veneered wood products, coated wood products). ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/26/72671","uuid":"847562f3-3251-4e05-9f76-3ca48cdcef6b","title":"ISO 12480-3:2020 Cranes — Safe use — Part 3: Tower cranes","status":"Published","year":2020,"order":11,"text":"This document establishes required practices for the safe use of tower cranes. Subjects covered include safe systems of work, management, planning, selection, erection and dismantling, special base, operation and maintenance of cranes and the selection of operators, slingers and signalers. It does not cover manually (non-powered) operated cranes, or cranes in which at least one of its motions is manually operated. ","objectID":"72671_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>80-3:2020 Cranes — Safe use — Part 3: Tower cranes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document establishes required practices for the safe use of tower cranes. Subjects covered include safe systems of work, management, planning, selection, erection and dismantling, special base, operation and maintenance of cranes and the selection of operators, slingers and signalers. It does not cover manually (non-powered) operated cranes, or cranes in which at least one of its motions is manually operated. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/03/60336","uuid":"1ddf988c-9354-4cf8-8492-71b07680128c","title":"ISO 12402-10:2020 Personal flotation devices — Part 10: Selection and application of personal flotation devices and other relevant devices","status":"Published","year":2020,"order":11,"text":"This document provides requirements and recommendations for the selection and application of both personal flotation devices (PFD) complying with the relevant Parts of the ISO 12402 series:2020, and immersion suits according to ISO 15027 (all parts):2012. It is intended to assist manufacturers, suppliers, users and regulators in the appropriate selection and application of those garments for the circumstances in which they will be used. ","objectID":"60336_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-10:2020 Personal flotation devices — Part 10: Selection and application of personal flotation devices and other relevant devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document provides requirements and recommendations for the selection and application of both personal flotation devices (PFD) complying with the relevant Parts of the <em>ISO</em> <em>124</em>02 series:2020, and immersion suits according to <em>ISO</em> 15027 (all parts):2012. It is intended to assist manufacturers, suppliers, users and regulators in the appropriate selection and application of those garments for the circumstances in which they will be used. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/03/60335","uuid":"acbdc904-475f-45a4-b266-59e3e3a7a241","title":"ISO 12402-8:2020 Personal flotation devices — Part 8: Accessories — Safety requirements and test methods","status":"Published","year":2020,"order":11,"text":"This document specifies the safety requirements and test methods for accessories used for personal flotation devices (PFDs). ","objectID":"60335_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-8:2020 Personal flotation devices — Part 8: Accessories — Safety requirements and test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the safety requirements and test methods for accessories used for personal flotation devices (PFDs). ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/03/60334","uuid":"fc800b30-0098-4afd-9c49-067acf4ae0f6","title":"ISO 12402-2:2020 Personal flotation devices — Part 2: Lifejackets, performance level 275 — Safety requirements","status":"Published","year":2020,"order":11,"text":"This document specifies the safety requirements for lifejackets, performance level 275. It is applicable to lifejackets for adults, children or infants, for offshore use under severe conditions, or when protective clothing is being used or additional loads are being carried. ","objectID":"60334_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-2:2020 Personal flotation devices — Part 2: Lifejackets, performance level 275 — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the safety requirements for lifejackets, performance level 275. It is applicable to lifejackets for adults, children or infants, for offshore use under severe conditions, or when protective clothing is being used or additional loads are being carried. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5863","uuid":"a5d165d5-22be-47d5-abbb-ea5b6c88304f","title":"ISO 1249:1974 Zinc chromate pigments — Basic zinc potassium chromate pigments and zinc tetrahydroxychromate pigments","status":"Published","year":2020,"order":11,"text":"Specifies the requirements and corresponding test methods. The pigments are suitable for use in paints and/or corrosion-inhibiting coatings. Three types of pigments are distinguished. In one typ only a lead content up 2 % maximum is alloqwed. Replaces ISO Recommendation R 1249-1970. ","objectID":"5863_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>9:1974 Zinc chromate pigments — Basic zinc potassium chromate pigments and zinc tetrahydroxychromate pigments","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"Specifies the requirements and corresponding test methods. The pigments are suitable for use in paints and/or corrosion-inhibiting coatings. Three types of pigments are distinguished. In one typ only a lead content up 2 % maximum is alloqwed. Replaces <em>ISO</em> Recommendation R <em>124</em>9-1970. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/76/57697","uuid":"6971c518-9356-4008-b96f-e14b26c42f47","title":"ISO 12417-1:2015 Cardiovascular implants and extracorporeal systems — Vascular device-drug combination products — Part 1: General requirements","status":"Published","year":2020,"order":11,"text":"ISO 12417-1:2015 specifies requirements for vascular device-drug combination products (VDDCPs) based upon current technical and medical knowledge. VDDCPs are medical devices with various clinical indications for use in the human vascular blood system. A VDDCP incorporates, as an integral part, substance(s) which, if used separately, can be considered to be a medicinal substance or product (drug substance, drug product) but the action of the medicinal substance is ancillary to that of the device and supports the primary mode of action (PMOA) of the device. With regard to safety, this part of ISO 12417 outlines requirements for intended performance, design attributes, materials, design evaluation, manufacturing, sterilization, packaging, and information supplied by the manufacturer. For implanted products, this International Standard should be considered as a supplement to ISO 14630, which specifies general requirements for the performance of non-active surgical implants. This International Standard should also be considered as a supplement to relevant device-specific standards, such as the ISO 25539‑series specifying requirements for endovascular devices. Requirements listed in this part of ISO 12417 also address VDDCPs that are not permanent implants. NOTE          Due to variations in the design of combination products covered by this part of ISO 12417 and due to the relatively recent development of some of these combination products, acceptable standardized in vitro test results and clinical study results are not always available. As further scientific and clinical data become available, appropriate revision of this part of ISO 12417 might be necessary. Delivery systems or parts of the delivery system are included in the scope of this part of ISO 12417, if they comprise an integral component of the vascular device and if they are drug-covered (e.g. drug-covered balloon catheters and drug-covered guidewires). Devices whose PMOA is to provide a conduit for delivery of a drug, are excluded from the scope of this part of ISO 12417 (e.g. infusion catheters), unless they contain a drug component that is intended to have an ancillary action to the device part (e.g. antimicrobial coated infusion catheter). Procedures and devices used prior to and following the introduction of the VDDCP (e.g. balloon angioplasty devices) are excluded from the scope of this part of ISO 12417 if they do not affect the drug-related aspects of the device. ISO 12417-1:2015 is not comprehensive with respect to the pharmacological evaluation of VDDCPs. Some information on the requirements of different national and regional authorities is given in Annex B. Absorbable components of VDDCPs (e.g. coatings) are addressed by this part of ISO 12417 in their connection with drug-related aspects of the device. Degradation and other time-dependent aspects of absorbable implants and coatings are not completely addressed by this part of ISO 12417. NOTE          See also ISO/TS 17137 and ASTM F3036-13. ISO 12417-1:2015 does not address issues associated with viable or non-viable biological materials such as tissues, cells, or proteins. ISO 12417-1:2015 does not address issues associated with active surgical implants (i.e. implants that require power not generated by the human body or gravity). ","objectID":"57697_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>17-1:2015 Cardiovascular implants and extracorporeal systems — Vascular device-drug combination products — Part 1: General requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>17-1:2015 specifies requirements for vascular device-drug combination products (VDDCPs) based upon current technical and medical knowledge. VDDCPs are medical devices with various clinical indications for use in the human vascular blood system. A VDDCP incorporates, as an integral part, substance(s) which, if used separately, can be considered to be a medicinal substance or product (drug substance, drug product) but the action of the medicinal substance is ancillary to that of the device and supports the primary mode of action (PMOA) of the device. With regard to safety, this part of <em>ISO</em> <em>124</em>17 outlines requirements for intended performance, design attributes, materials, design evaluation, manufacturing, sterilization, packaging, and information supplied by the manufacturer. For implanted products, this International Standard should be considered as a supplement to <em>ISO</em> 14630, which specifies general requirements for the performance of non-active surgical implants. This International Standard should also be considered as a supplement to relevant device-specific standards, such as the <em>ISO</em> 25539‑series specifying requirements for endovascular devices. Requirements listed in this part of <em>ISO</em> <em>124</em>17 also address VDDCPs that are not permanent implants. NOTE          Due to variations in the design of combination products covered by this part of <em>ISO</em> <em>124</em>17 and due to the relatively recent development of some of these combination products, acceptable standardized in vitro test results and clinical study results are not always available. As further scientific and clinical data become available, appropriate revision of this part of <em>ISO</em> <em>124</em>17 might be necessary. Delivery systems or parts of the delivery system are included in the scope of this part of <em>ISO</em> <em>124</em>17, if they comprise an integral component of the vascular device and if they are drug-covered (e.g. drug-covered balloon catheters and drug-covered guidewires). Devices whose PMOA is to provide a conduit for delivery of a drug, are excluded from the scope of this part of <em>ISO</em> <em>124</em>17 (e.g. infusion catheters), unless they contain a drug component that is intended to have an ancillary action to the device part (e.g. antimicrobial coated infusion catheter). Procedures and devices used prior to and following the introduction of the VDDCP (e.g. balloon angioplasty devices) are excluded from the scope of this part of <em>ISO</em> <em>124</em>17 if they do not affect the drug-related aspects of the device. <em>ISO</em> <em>124</em>17-1:2015 is not comprehensive with respect to the pharmacological evaluation of VDDCPs. Some information on the requirements of different national and regional authorities is given in Annex B. Absorbable components of VDDCPs (e.g. coatings) are addressed by this part of <em>ISO</em> <em>124</em>17 in their connection with drug-related aspects of the device. Degradation and other time-dependent aspects of absorbable implants and coatings are not completely addressed by this part of <em>ISO</em> <em>124</em>17. NOTE          See also <em>ISO</em>/TS 17137 and ASTM F3036-13. <em>ISO</em> <em>124</em>17-1:2015 does not address issues associated with viable or non-viable biological materials such as tissues, cells, or proteins. <em>ISO</em> <em>124</em>17-1:2015 does not address issues associated with active surgical implants (i.e. implants that require power not generated by the human body or gravity). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/74/57481","uuid":"f94c2221-36f4-42c6-aef7-cc0a4ca1ff12","title":"ISO 12482:2014 Cranes — Monitoring for crane design working period","status":"Published","year":2020,"order":11,"text":"ISO 12482:2014 specifies a method for monitoring, during long-term operation, the actual duty of the crane, and a means of comparing this to the original design duty which was specified through classification. The related design standard is ISO 4301‑1. Approaching the design life limit means an increased probability of hazards. Monitoring of crane use ? as described herein ? provides a tool for predicting the approach of the design limits and for focusing special inspections on the critical areas of a crane. ISO 12482:2014 is intended to be used for adjusting/modifying the inspections defined in ISO 9927‑1. It is applicable to cranes with a permanent construction throughout the life of the crane. It is not applicable to mobile or tower cranes, except permanently installed tower cranes. The method it specifies can be adapted to standards or rules other than ISO 4301‑1 which specify classifications. ","objectID":"57481_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>82:2014 Cranes — Monitoring for crane design working period","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>82:2014 specifies a method for monitoring, during long-term operation, the actual duty of the crane, and a means of comparing this to the original design duty which was specified through classification. The related design standard is <em>ISO</em> 4301‑1. Approaching the design life limit means an increased probability of hazards. Monitoring of crane use ? as described herein ? provides a tool for predicting the approach of the design limits and for focusing special inspections on the critical areas of a crane. <em>ISO</em> <em>124</em>82:2014 is intended to be used for adjusting/modifying the inspections defined in <em>ISO</em> 9927‑1. It is applicable to cranes with a permanent construction throughout the life of the crane. It is not applicable to mobile or tower cranes, except permanently installed tower cranes. The method it specifies can be adapted to standards or rules other than <em>ISO</em> 4301‑1 which specify classifications. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/66/56688","uuid":"99f853bb-7f8d-448c-82dd-67be0f247afe","title":"ISO 12402-9:2020 Personal flotation devices — Part 9: Evaluation","status":"Published","year":2020,"order":11,"text":"This document specifies the processes for evaluation of personal flotation devices for fulfilment of the requirements in ISO 12402‑2:2020 to ISO 12402‑6:2020, with which this document is intended to be used. The classification of PFDs used in the ISO 12402 series:2020 is given in Annex A for information. ","objectID":"56688_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-9:2020 Personal flotation devices — Part 9: Evaluation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the processes for evaluation of personal flotation devices for fulfilment of the requirements in <em>ISO</em> <em>124</em>02‑2:2020 to <em>ISO</em> <em>124</em>02‑6:2020, with which this document is intended to be used. The classification of PFDs used in the <em>ISO</em> <em>124</em>02 series:2020 is given in Annex A for information. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/66/56687","uuid":"60b0f7da-45ee-4344-9c0a-b4c97e60c7b6","title":"ISO 12402-7:2020 Personal flotation devices — Part 7: Materials and components — Safety requirements and test methods","status":"Published","year":2020,"order":11,"text":"This document specifies the minimum requirements for the construction and performance of materials and components of personal flotation devices, as well as the relevant test methods. ","objectID":"56687_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-7:2020 Personal flotation devices — Part 7: Materials and components — Safety requirements and test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the minimum requirements for the construction and performance of materials and components of personal flotation devices, as well as the relevant test methods. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/66/56686","uuid":"b31958fc-c283-441f-98bf-fad1fdd14134","title":"ISO 12402-6:2020 Personal flotation devices — Part 6: Special application lifejackets and buoyancy aids — Safety requirements and additional test methods","status":"Published","year":2020,"order":11,"text":"This document specifies the safety requirements and additional test methods for special application lifejackets and buoyancy aids (hereafter named PFD) for adults, children or infants. It is intended to be used in conjunction with ISO 12402‑2:2020, ISO 12402‑3:2020, ISO 12402‑4:2020 and ISO 12402‑5:2020, as applicable. ","objectID":"56686_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-6:2020 Personal flotation devices — Part 6: Special application lifejackets and buoyancy aids — Safety requirements and additional test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the safety requirements and additional test methods for special application lifejackets and buoyancy aids (hereafter named PFD) for adults, children or infants. It is intended to be used in conjunction with <em>ISO</em> <em>124</em>02‑2:2020, <em>ISO</em> <em>124</em>02‑3:2020, <em>ISO</em> <em>124</em>02‑4:2020 and <em>ISO</em> <em>124</em>02‑5:2020, as applicable. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/66/56685","uuid":"b258cf09-1318-4102-91e2-47c2489f7349","title":"ISO 12402-5:2020 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements","status":"Published","year":2020,"order":11,"text":"This document specifies the safety requirements for buoyancy aids, performance level 50. It is applicable to buoyancy aids for adults and children with a body mass greater than 25 kg only, used in sheltered waters. Buoyancy aids require active participation by the user where help and rescue are close at hand. One-piece and two-piece inherently buoyant floatation suit PFDs are deemed to qualify as special application devices according to ISO 12402-6:2020. ","objectID":"56685_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-5:2020 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the safety requirements for buoyancy aids, performance level 50. It is applicable to buoyancy aids for adults and children with a body mass greater than 25 kg only, used in sheltered waters. Buoyancy aids require active participation by the user where help and rescue are close at hand. One-piece and two-piece inherently buoyant floatation suit PFDs are deemed to qualify as special application devices according to <em>ISO</em> <em>124</em>02-6:2020. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/66/56684","uuid":"2c8b214c-8477-4b44-9b77-ae9e91978d7b","title":"ISO 12402-4:2020 Personal flotation devices — Part 4: Lifejackets, performance level 100 — Safety requirements","status":"Published","year":2020,"order":11,"text":"This document specifies the safety requirements for lifejackets, performance level 100. It is applicable to lifejackets used by adults, children and infants, for use in sheltered or calm water, or when the users are fully clothed. ","objectID":"56684_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-4:2020 Personal flotation devices — Part 4: Lifejackets, performance level 100 — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the safety requirements for lifejackets, performance level 100. It is applicable to lifejackets used by adults, children and infants, for use in sheltered or calm water, or when the users are fully clothed. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/66/56683","uuid":"92a1ff4d-8448-49ab-ad79-57eb6929fa16","title":"ISO 12402-3:2020 Personal flotation devices — Part 3: Lifejackets, performance level 150 — Safety requirements","status":"Published","year":2020,"order":11,"text":"This document specifies the safety requirements for lifejackets, performance level 150. It is applicable to lifejackets used by adults, children and infants, for general, offshore or rough water use, or when the users are fully clothed. ","objectID":"56683_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-3:2020 Personal flotation devices — Part 3: Lifejackets, performance level 150 — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies the safety requirements for lifejackets, performance level 150. It is applicable to lifejackets used by adults, children and infants, for general, offshore or rough water use, or when the users are fully clothed. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51434","uuid":"441cf8dd-68ac-4110-932e-aa300839e85e","title":"ISO 12474:2010 Hexagon socket head cap screws with metric fine pitch thread","status":"Published","year":2020,"order":11,"text":"ISO 12474:2010 specifies the characteristics of hexagon socket head cap screws with metric fine pitch thread with nominal thread diameters from 8 mm up to 36 mm and product grade A. ","objectID":"51434_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>74:2010 Hexagon socket head cap screws with metric fine pitch thread","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>74:2010 specifies the characteristics of hexagon socket head cap screws with metric fine pitch thread with nominal thread diameters from 8 mm up to 36 mm and product grade A. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/62/46213","uuid":"04167444-8f80-4eb4-82c1-eeea20a0cb5e","title":"ISO 12401:2009 Small craft — Deck safety harness and safety line — Safety requirements and test methods","status":"Published","year":2020,"order":11,"text":"ISO 12401:2009 specifies the requirements for performance, sizing, marking and test methods for deck safety harnesses and safety lines on recreational craft. It is applicable to harnesses and lines in the following sizes of body mass (multisizing is permitted): size 1: > 50 kg ; size 2: > 20 kg ≤ 50 kg; size 3: ≤ 20 kg; which are intended to be worn by all persons when in the exposed cockpit or on the working deck of a craft afloat. It is not applicable to dinghy 'trapeze' harnesses, windsurfing harnesses, seat harnesses for fast motor boats, and harnesses intended to protect against falls from a height. ","objectID":"46213_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>01:2009 Small craft — Deck safety harness and safety line — Safety requirements and test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>01:2009 specifies the requirements for performance, sizing, marking and test methods for deck safety harnesses and safety lines on recreational craft. It is applicable to harnesses and lines in the following sizes of body mass (multisizing is permitted): size 1: > 50 kg ; size 2: > 20 kg ≤ 50 kg; size 3: ≤ 20 kg; which are intended to be worn by all persons when in the exposed cockpit or on the working deck of a craft afloat. It is not applicable to dinghy 'trapeze' harnesses, windsurfing harnesses, seat harnesses for fast motor boats, and harnesses intended to protect against falls from a height. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/87/38752","uuid":"c5fd6c66-ef3c-4fcb-93e8-431de734aabb","title":"ISO 1248:2006 Iron oxide pigments — Specifications and methods of test","status":"Published","year":2020,"order":11,"text":"ISO 1248:2006 specifies the requirements and the corresponding methods of test for all manufactured and natural iron oxide pigments, in dry form, suitable for general use. These pigments are identified by Colour Index Nos. red 101 and 102, yellow 42 and 43, brown 6 and 7, and black 11, and includes rapid-dispersion pigments. ISO 1248:2006 does not cover micaceous iron oxide pigments, transparent iron oxide pigments, granular grey iron oxide or magnetic iron oxide pigments other than those of Colour Index Pigment black 11. ","objectID":"38752_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>8:2006 Iron oxide pigments — Specifications and methods of test","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>8:2006 specifies the requirements and the corresponding methods of test for all manufactured and natural iron oxide pigments, in dry form, suitable for general use. These pigments are identified by Colour Index Nos. red 101 and 102, yellow 42 and 43, brown 6 and 7, and black 11, and includes rapid-dispersion pigments. <em>ISO</em> <em>124</em>8:2006 does not cover micaceous iron oxide pigments, transparent iron oxide pigments, granular grey iron oxide or magnetic iron oxide pigments other than those of Colour Index Pigment black 11. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/76/37626","uuid":"86267701-3dac-4d92-b40b-4cb3b98601a1","title":"ISO 12472:2003 Fire resistance of timber door assemblies - Method of determining the efficacy of intumescent seals","status":"Published","year":2020,"order":11,"text":"ISO 12472:2002 specifies a test method for determining the effective sealing capability of intumescent materials or systems in the context of sealing door-to-frame clearances in timber door assemblies. The method is suitable for evaluating the efficacy of exposed intumescent sealing systems used in conjunction with timber fire resisting doors of up to 1 h fire resistance. It is not suitable for comparing concealed intumescent seals. The results can be applied to proven, single-acting, single-leaf, latched, timber door assemblies of sizes up to that given in the field of direct application. ","objectID":"37626_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>72:2003 Fire resistance of timber door assemblies - Method of determining the efficacy of intumescent seals","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>72:2002 specifies a test method for determining the effective sealing capability of intumescent materials or systems in the context of sealing door-to-frame clearances in timber door assemblies. The method is suitable for evaluating the efficacy of exposed intumescent sealing systems used in conjunction with timber fire resisting doors of up to 1 h fire resistance. It is not suitable for comparing concealed intumescent seals. The results can be applied to proven, single-acting, single-leaf, latched, timber door assemblies of sizes up to that given in the field of direct application. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/45/34548","uuid":"890e4054-010c-425f-ba18-9f5d446991ce","title":"ISO 12488-4:2004 Cranes — Tolerances for wheels and travel and traversing tracks — Part 4: Jib cranes","status":"Published","year":2020,"order":11,"text":"ISO 12488-4:2004 specifies tolerances of cranes and tracks and applies to jib cranes as defined in ISO 4306-1. Tracks for jib cranes negotiating curves are not covered by ISO12488-4:2004. ","objectID":"34548_0","_highlightResult":{"title":{"value":"<em>ISO 124</em>88-4:2004 Cranes — Tolerances for wheels and travel and traversing tracks — Part 4: Jib cranes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO 124</em>88-4:2004 specifies tolerances of cranes and tracks and applies to jib cranes as defined in <em>ISO</em> 4306-1. Tracks for jib cranes negotiating curves are not covered by <em>ISO124</em>88-4:2004. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/25/2564","uuid":"cee8fa17-287e-4982-a834-382a47536cb9","title":"ISO 12460-1:2007 Wood-based panels — Determination of formaldehyde release — Part 1: Formaldehyde emission by the 1-cubic-metre chamber method","status":"Published","year":2020,"order":11,"text":"ISO 12460-1:2007 specifies a 1 m 3 chamber method for the determination of the formaldehyde emission from wood-based panels under defined conditions, relating to typical conditions in real-life. ","objectID":"2564_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-1:2007 Wood-based panels — Determination of formaldehyde release — Part 1: Formaldehyde emission by the 1-cubic-metre chamber method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>60-1:2007 specifies a 1 m 3 chamber method for the determination of the formaldehyde emission from wood-based panels under defined conditions, relating to typical conditions in real-life. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/16/1629","uuid":"4410bc42-ff41-4a5b-a110-34eebaac9cf6","title":"ISO 12499:1999 Industrial fans — Mechanical safety of fans — Guarding","status":"Published","year":2020,"order":11,"objectID":"1629_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>99:1999 Industrial fans — Mechanical safety of fans — Guarding","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/27/72785","uuid":"a6a40c84-0a7e-45c3-857a-5f706e6784be","title":"ISO 12493:2017 Rubber, vulcanized — Determination of stress in tension upon heating","status":"Published","year":2019,"order":11,"text":"ISO 12493:2017 specifies a method for measuring the stress in tension which is developed in vulcanized rubber when it is heated (thermal stress). The thermal stress is measured for various pre-strain and temperature conditions as a function of time. ","objectID":"72785_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>93:2017 Rubber, vulcanized — Determination of stress in tension upon heating","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>93:2017 specifies a method for measuring the stress in tension which is developed in vulcanized rubber when it is heated (thermal stress). The thermal stress is measured for various pre-strain and temperature conditions as a function of time. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/98/59885","uuid":"9061177c-0f36-4fee-9536-62046eb0daf1","title":"ISO 12468-1:2013 External exposure of roofs to fire — Part 1: Test method","status":"Published","year":2019,"order":11,"text":"ISO 12468-1:2013 specifies a test method to determine the resistance of roofs to external exposure to fire. This method evaluates the behaviour of the roof when exposed to three types of burning brands combined with wind and with or without heat radiation, concerning the fire spread across the external surface of the roof, the fire spread within the roof, the fire penetration, and the production of flaming droplets or debris falling through the roof, from the underside of the roof, or from the exposed surface. ","objectID":"59885_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>68-1:2013 External exposure of roofs to fire — Part 1: Test method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>68-1:2013 specifies a test method to determine the resistance of roofs to external exposure to fire. This method evaluates the behaviour of the roof when exposed to three types of burning brands combined with wind and with or without heat radiation, concerning the fire spread across the external surface of the roof, the fire spread within the roof, the fire penetration, and the production of flaming droplets or debris falling through the roof, from the underside of the roof, or from the exposed surface. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/26/2644","uuid":"5f805c8f-e26f-46d1-88f7-b16b22c95267","title":"ISO 12491:1997 Statistical methods for quality control of building materials and components","status":"Published","year":2019,"order":11,"objectID":"2644_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>91:1997 Statistical methods for quality control of building materials and components","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/24/2498","uuid":"a5b19607-54da-4f31-8908-63739fb3c702","title":"ISO 12478-1:1997 Cranes — Maintenance manual — Part 1: General","status":"Published","year":2019,"order":11,"objectID":"2498_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>78-1:1997 Cranes — Maintenance manual — Part 1: General","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/14/71407","uuid":"ed4a9114-3f56-4933-b8fc-52fc7065ec93","title":"ISO 12405-4:2018 Electrically propelled road vehicles —Test specification for lithium-ion traction battery packs and systems — Part 4: Performance testing","status":"Published","year":2018,"order":11,"text":"This document specifies test procedures for the basic characteristics of performance, reliability and electrical functionality for the battery packs and systems for either high-power or high-energy application. Unless otherwise stated, the test applies to both applications. NOTE 1    Typical applications for high-power battery packs and systems are hybrid electric vehicles (HEVs) and some type of fuel cell vehicles (FCVs). NOTE 2    Typical applications for high-energy battery packs and systems are battery electric vehicles (BEVs), plug-in hybrid electric vehicles (PHEVs) and some type of fuel cell vehicles (FCVs). NOTE 3    Testing on cell level is specified in IEC 62660 series. ","objectID":"71407_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>05-4:2018 Electrically propelled road vehicles —Test specification for lithium-ion traction battery packs and systems — Part 4: Performance testing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies test procedures for the basic characteristics of performance, reliability and electrical functionality for the battery packs and systems for either high-power or high-energy application. Unless otherwise stated, the test applies to both applications. NOTE 1    Typical applications for high-power battery packs and systems are hybrid electric vehicles (HEVs) and some type of fuel cell vehicles (FCVs). NOTE 2    Typical applications for high-energy battery packs and systems are battery electric vehicles (BEVs), plug-in hybrid electric vehicles (PHEVs) and some type of fuel cell vehicles (FCVs). NOTE 3    Testing on cell level is specified in IEC 62660 series. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/40/64064","uuid":"e3847d3f-d574-4a6e-a52b-ef2fbb7377e2","title":"ISO 12460-2:2018 Wood-based panels — Determination of formaldehyde release — Part 2: Small-scale chamber method","status":"Published","year":2018,"order":11,"text":"This document specifies a test method to measure the formaldehyde concentrations in air from wood products under defined test conditions of temperature and relative humidity. Results obtained from this small-scale chamber test method are often used for quality assurance and can be comparable to, or can provide useful correlations to, results obtained from testing larger product samples in larger chamber test methods for wood products, such as the 1 m3 chamber method specified in ISO 12460-1. NOTE 1    This document is based on the general principles and methods of ASTM D 6007. NOTE 2    ISO 12460-1 for the 1 m3 chamber is the reference method for the determination of formaldehyde release. For factory production control the derived test methods according to this document, ISO 12460-3, ISO 12460-4 and ISO 12460-5 are used. ","objectID":"64064_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-2:2018 Wood-based panels — Determination of formaldehyde release — Part 2: Small-scale chamber method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This document specifies a test method to measure the formaldehyde concentrations in air from wood products under defined test conditions of temperature and relative humidity. Results obtained from this small-scale chamber test method are often used for quality assurance and can be comparable to, or can provide useful correlations to, results obtained from testing larger product samples in larger chamber test methods for wood products, such as the 1 m3 chamber method specified in <em>ISO</em> <em>124</em>60-1. NOTE 1    This document is based on the general principles and methods of ASTM D 6007. NOTE 2    <em>ISO</em> <em>124</em>60-1 for the 1 m3 chamber is the reference method for the determination of formaldehyde release. For factory production control the derived test methods according to this document, <em>ISO</em> <em>124</em>60-3, <em>ISO</em> <em>124</em>60-4 and <em>ISO</em> <em>124</em>60-5 are used. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/73/57300","uuid":"b548a79b-acaf-4802-bff4-c7aaed6e9598","title":"ISO 12488-1:2012 Cranes — Tolerances for wheels and travel and traversing tracks — Part 1: General","status":"Published","year":2018,"order":11,"objectID":"57300_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>88-1:2012 Cranes — Tolerances for wheels and travel and traversing tracks — Part 1: General","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51422","uuid":"802302e4-2c6d-4bb0-ae97-eda2eac6cc49","title":"ISO 12418-2:2012 Plastics — Post-consumer poly(ethylene terephthalate) (PET) bottle recyclates — Part 2: Preparation of test specimens and determination of properties","status":"Published","year":2018,"order":11,"text":"ISO 12418-2:2012 specifies the test methods to be used in determining the properties of post-consumer poly(ethylene terephthalate) (PET) bottle recyclates. ","objectID":"51422_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>18-2:2012 Plastics — Post-consumer poly(ethylene terephthalate) (PET) bottle recyclates — Part 2: Preparation of test specimens and determination of properties","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>18-2:2012 specifies the test methods to be used in determining the properties of post-consumer poly(ethylene terephthalate) (PET) bottle recyclates. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51421","uuid":"d0d77743-298a-4d1c-b925-68bbab044022","title":"ISO 12418-1:2012 Plastics — Post-consumer poly(ethylene terephthalate) (PET) bottle recyclates — Part 1: Designation system and basis for specifications","status":"Published","year":2018,"order":11,"text":"ISO 12418‑1:2012 establishes a designation system for post-consumer poly(ethylene terephthalate) (PET) bottle recyclates, which may be used as the basis for specifications. The types of PET bottle recyclate are differentiated from each other by a classification system based on appropriate levels of the following designatory properties: intrinsic viscosity (IV); levels of contamination due to the label and other visible contaminants, PVC and polyolefins (including adhesive); water content; bulk density. Information regarding the intended application or method of processing will also assist in classification. ISO 12418‑1 is applicable to all PET bottle recyclates. It applies to materials ready for normal use in the form of powder, flakes or pellets. It is not intended to imply that materials having the same designation will give the same performance. ISO 12418‑1 does not provide engineering data or data on processing conditions which might be required to specify a material for a particular application and/or method of processing. If such additional details are required, they shall be determined in accordance with the test methods specified in ISO 12418‑2. In order to specify a thermoplastic material for a particular application or to ensure reproducible processing, additional requirements may be given in an additional data block (data block 5). ","objectID":"51421_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>18-1:2012 Plastics — Post-consumer poly(ethylene terephthalate) (PET) bottle recyclates — Part 1: Designation system and basis for specifications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>18‑1:2012 establishes a designation system for post-consumer poly(ethylene terephthalate) (PET) bottle recyclates, which may be used as the basis for specifications. The types of PET bottle recyclate are differentiated from each other by a classification system based on appropriate levels of the following designatory properties: intrinsic viscosity (IV); levels of contamination due to the label and other visible contaminants, PVC and polyolefins (including adhesive); water content; bulk density. Information regarding the intended application or method of processing will also assist in classification. <em>ISO</em> <em>124</em>18‑1 is applicable to all PET bottle recyclates. It applies to materials ready for normal use in the form of powder, flakes or pellets. It is not intended to imply that materials having the same designation will give the same performance. <em>ISO</em> <em>124</em>18‑1 does not provide engineering data or data on processing conditions which might be required to specify a material for a particular application and/or method of processing. If such additional details are required, they shall be determined in accordance with the test methods specified in <em>ISO</em> <em>124</em>18‑2. In order to specify a thermoplastic material for a particular application or to ensure reproducible processing, additional requirements may be given in an additional data block (data block 5). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/01/40123","uuid":"6c628551-f07f-4876-983d-6ce4dde956c1","title":"ISO 12466-1:2007 Plywood — Bonding quality — Part 1: Test methods","status":"Published","year":2018,"order":11,"text":"ISO 12466-1:2007 specifies methods for determining the bonding quality of plywood, blockboard, battenboard, and laminboard, bonded with thermosetting resin, by shear testing. ","objectID":"40123_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>66-1:2007 Plywood — Bonding quality — Part 1: Test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>66-1:2007 specifies methods for determining the bonding quality of plywood, blockboard, battenboard, and laminboard, bonded with thermosetting resin, by shear testing. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/24/72443","uuid":"c0873048-5dfa-427e-a24e-252304aa0e93","title":"ISO 12494:2017 Atmospheric icing of structures","status":"Published","year":2017,"order":11,"text":"ISO 12494:2017 describes the general principles of determining ice load on structures of the types listed in this clause. In cases where a certain structure is not directly covered by this or another standard or recommendation, designers can use the intentions of this document. However, it is the user's responsibility to carefully consider the applicability of this document to the structure in question. The practical use of all data in this document is based upon certain knowledge of the site of the structure. Information about the degree of \"normal\" icing amounts (= ice classes) for the site in question is used. For many areas, however, no information is available. Even in such cases, this document can be useful because local meteorologists or other experienced persons should be able to, on the safe side, estimate a proper ice class. Using such an estimate in the structural design will result in a much safer structure than designing without any considerations for problems due to ice. CAUTION   It is extremely important to design for some ice instead of no ice, and then the question of whether the amount of ice was correct is of less importance. In particular, the action of wind can be increased considerably due to both increased exposed area and increased drag coefficient. ISO 12494:2017 is intended for use in determining ice mass and wind load on the iced structure for the following types of structure: -      masts; -      towers; -      antennas and antenna structures; -      cables, stays, guy ropes, etc.; -      rope ways (cable railways); -      structures for ski-lifts; -      buildings or parts of them exposed to potential icing; -      towers for special types of construction such as transmission lines, wind turbines, etc. Atmospheric icing on electrical overhead lines is covered by IEC (International Electrotechnical Commission) standards. This document is intended to be used in conjunction with ISO 2394. NOTE          Some typical types of structure are mentioned, but other types can also be considered by designers by thinking in terms of which type of structure is sensitive to unforeseen ice, and act thereafter. Also, in many cases, only parts of structures are to be designed for ice loads because they are more vulnerable to unforeseen ice than is the whole structure. Even if electrical overhead lines are covered by IEC standards, designers can use this document for the mast structures to overhead lines (which are not covered by IEC standards) if they so wish. ","objectID":"72443_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>94:2017 Atmospheric icing of structures","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>94:2017 describes the general principles of determining ice load on structures of the types listed in this clause. In cases where a certain structure is not directly covered by this or another standard or recommendation, designers can use the intentions of this document. However, it is the user's responsibility to carefully consider the applicability of this document to the structure in question. The practical use of all data in this document is based upon certain knowledge of the site of the structure. Information about the degree of \"normal\" icing amounts (= ice classes) for the site in question is used. For many areas, however, no information is available. Even in such cases, this document can be useful because local meteorologists or other experienced persons should be able to, on the safe side, estimate a proper ice class. Using such an estimate in the structural design will result in a much safer structure than designing without any considerations for problems due to ice. CAUTION   It is extremely important to design for some ice instead of no ice, and then the question of whether the amount of ice was correct is of less importance. In particular, the action of wind can be increased considerably due to both increased exposed area and increased drag coefficient. <em>ISO</em> <em>124</em>94:2017 is intended for use in determining ice mass and wind load on the iced structure for the following types of structure: -      masts; -      towers; -      antennas and antenna structures; -      cables, stays, guy ropes, etc.; -      rope ways (cable railways); -      structures for ski-lifts; -      buildings or parts of them exposed to potential icing; -      towers for special types of construction such as transmission lines, wind turbines, etc. Atmospheric icing on electrical overhead lines is covered by IEC (International Electrotechnical Commission) standards. This document is intended to be used in conjunction with <em>ISO</em> 2394. NOTE          Some typical types of structure are mentioned, but other types can also be considered by designers by thinking in terms of which type of structure is sensitive to unforeseen ice, and act thereafter. Also, in many cases, only parts of structures are to be designed for ice loads because they are more vulnerable to unforeseen ice than is the whole structure. Even if electrical overhead lines are covered by IEC standards, designers can use this document for the mast structures to overhead lines (which are not covered by IEC standards) if they so wish. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/77/67729","uuid":"4f55db29-1114-40f7-b42f-926d65f884ed","title":"ISO 12473:2017 General principles of cathodic protection in seawater","status":"Published","year":2017,"order":11,"text":"ISO 12473 covers the general principles of cathodic protection when applied in seawater, brackish waters and marine mud. It is intended to be an introduction, to provide a link between the theoretical aspects and the practical applications, and to constitute a support to the other standards devoted to cathodic protection of steel structures in seawater. ISO 12473 specifies the criteria required for cathodic protection. It provides recommendations and information on reference electrodes, design considerations and prevention of the secondary effects of cathodic protection. The practical applications of cathodic protection in seawater are covered by the following standards: -      EN 12495, Cathodic protection for fixed steel offshore structures ; -      ISO 13174, Cathodic protection of harbour installations ( ISO 13174 ) ; -      EN 12496, Galvanic anodes for cathodic protection in seawater and saline mud ; -      EN 13173, Cathodic protection for steel offshore floating structures ; -      EN 16222, Cathodic protection of ship hulls ; -      EN 12474, Cathodic protection of submarine pipelines ; -      ISO 15589‑2, Petroleum, petrochemical and natural gas industries ? Cathodic protection of pipeline transportation systems ? Part 2: Offshore pipelines . For cathodic protection of steel reinforced concrete whether exposed to seawater or to the atmosphere, ISO 12696 applies. ","objectID":"67729_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>73:2017 General principles of cathodic protection in seawater","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>73 covers the general principles of cathodic protection when applied in seawater, brackish waters and marine mud. It is intended to be an introduction, to provide a link between the theoretical aspects and the practical applications, and to constitute a support to the other standards devoted to cathodic protection of steel structures in seawater. <em>ISO</em> <em>124</em>73 specifies the criteria required for cathodic protection. It provides recommendations and information on reference electrodes, design considerations and prevention of the secondary effects of cathodic protection. The practical applications of cathodic protection in seawater are covered by the following standards: -      EN <em>124</em>95, Cathodic protection for fixed steel offshore structures ; -      <em>ISO</em> 13174, Cathodic protection of harbour installations ( <em>ISO</em> 13174 ) ; -      EN <em>124</em>96, Galvanic anodes for cathodic protection in seawater and saline mud ; -      EN 13173, Cathodic protection for steel offshore floating structures ; -      EN 16222, Cathodic protection of ship hulls ; -      EN <em>124</em>74, Cathodic protection of submarine pipelines ; -      <em>ISO</em> 15589‑2, Petroleum, petrochemical and natural gas industries ? Cathodic protection of pipeline transportation systems ? Part 2: Offshore pipelines . For cathodic protection of steel reinforced concrete whether exposed to seawater or to the atmosphere, <em>ISO</em> 12696 applies. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5857","uuid":"63a72cd0-eff0-4f8e-9671-f5b57fd6e614","title":"ISO 1241:1996 Essential oils — Determination of ester values, before and after acetylation, and evaluation of the contents of free and total alcohols","status":"Published","year":2017,"order":11,"text":"Describes a method to evaluate the contents of free alcohols and total alcohols in essential oils by determination of ester values before and after acetylation by acetic anhydride in the presence of sodium acetate. Replaces the first edition. ","objectID":"5857_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>1:1996 Essential oils — Determination of ester values, before and after acetylation, and evaluation of the contents of free and total alcohols","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"Describes a method to evaluate the contents of free alcohols and total alcohols in essential oils by determination of ester values before and after acetylation by acetic anhydride in the presence of sodium acetate. Replaces the first edition. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51460","uuid":"5878723e-bdfb-455b-a049-8170b01deced","title":"ISO 12490:2011 Petroleum and natural gas industries — Mechanical integrity and sizing of actuators and mounting kits for pipeline valves","status":"Published","year":2017,"order":11,"text":"ISO 12490:2011 defines the requirements for mechanical integrity and sizing of actuators used on valves manufactured under ISO 14313 and API Specification 6D. ISO 12490:2011 is applicable to all types of electric, pneumatic and hydraulic actuators, inclusive of mounting kit, installed on pipeline valves. ISO 12490:2011 is not applicable to actuators installed on control valves, valves being used for regulation, valves in sub-sea service, handheld powered devices, stand-alone manually operated gearboxes, instrument tubing and associated fittings and actuator control equipment. ","objectID":"51460_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>90:2011 Petroleum and natural gas industries — Mechanical integrity and sizing of actuators and mounting kits for pipeline valves","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>90:2011 defines the requirements for mechanical integrity and sizing of actuators used on valves manufactured under <em>ISO</em> 14313 and API Specification 6D. <em>ISO</em> <em>124</em>90:2011 is applicable to all types of electric, pneumatic and hydraulic actuators, inclusive of mounting kit, installed on pipeline valves. <em>ISO</em> <em>124</em>90:2011 is not applicable to actuators installed on control valves, valves being used for regulation, valves in sub-sea service, handheld powered devices, stand-alone manually operated gearboxes, instrument tubing and associated fittings and actuator control equipment. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/29/42902","uuid":"7761ff86-7555-47d6-b968-f69b7c948c1c","title":"ISO 12480-4:2007 Cranes — Safe use — Part 4: Jib cranes","status":"Published","year":2017,"order":11,"text":"ISO 12480-4:2007 establishes required practices for the safe use of jib cranes as defined in ISO 4306-1. It is intended to be used in conjunction with ISO 12480-1. ","objectID":"42902_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>80-4:2007 Cranes — Safe use — Part 4: Jib cranes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>80-4:2007 establishes required practices for the safe use of jib cranes as defined in <em>ISO</em> 4306-1. It is intended to be used in conjunction with <em>ISO</em> <em>124</em>80-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/10/61018","uuid":"0e2f58d5-13e7-4f78-a12f-3f2b58ef5ebf","title":"ISO 12466-1:2007/Amd 1:2013 Plywood — Bonding quality — Part 1: Test methods — Amendment 1","status":"Published","year":2013,"order":11,"objectID":"61018_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>66-1:2007/Amd 1:2013 Plywood — Bonding quality — Part 1: Test methods — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/22/52283","uuid":"4b53a1d5-6ab0-47a4-965b-503240cf77ae","title":"ISO 1248:2006/Cor 2:2008 Iron oxide pigments — Specifications and methods of test — Technical Corrigendum 2","status":"Published","year":2008,"order":11,"objectID":"52283_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>8:2006/Cor 2:2008 Iron oxide pigments — Specifications and methods of test — Technical Corrigendum 2","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/03/50330","uuid":"f6fd211d-83a4-44c1-b021-e9f80bf9b362","title":"ISO 1248:2006/Cor 1:2007 Iron oxide pigments — Specifications and methods of test — Technical Corrigendum 1","status":"Published","year":2007,"order":11,"objectID":"50330_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>8:2006/Cor 1:2007 Iron oxide pigments — Specifications and methods of test — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/13/21392","uuid":"42abde56-49f0-4374-a34b-12a339fe04b9","title":"ISO 1249:1974/Cor 1:1992 Zinc chromate pigments — Basic zinc potassium chromate pigments and zinc tetrahydroxychromate pigments — Technical Corrigendum 1","status":"Published","year":1992,"order":11,"text":"Amends in the fourth column of the table (type 2 pigments) the heading as follows: Zinc tetrahydroxychromate pigments Type 2. ","objectID":"21392_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>9:1974/Cor 1:1992 Zinc chromate pigments — Basic zinc potassium chromate pigments and zinc tetrahydroxychromate pigments — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"Amends in the fourth column of the table (type 2 pigments) the heading as follows: Zinc tetrahydroxychromate pigments Type 2. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5860","uuid":"681f0fd0-b863-4b06-9aed-3374b384b3e2","title":"ISO 1247:1974/Amd 1:1982 Aluminium pigments for paints — Amendment 1","status":"Withdrawn","year":2021,"order":100,"text":"Relates to the deletion of a reference (ISO/TR 798) and substitution by the reference ISO 1784. Cancels and replaces also references in the table. Amends the last two sentences in subclause 15.3.3. ","objectID":"5860_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>7:1974/Amd 1:1982 Aluminium pigments for paints — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"Relates to the deletion of a reference (<em>ISO</em>/TR 798) and substitution by the reference <em>ISO</em> 1784. Cancels and replaces also references in the table. Amends the last two sentences in subclause 15.3.3. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/58/5859","uuid":"5960012b-c33a-4aef-9f36-5b58c2a8daa1","title":"ISO 1247:1974 Aluminium pigments for paints","status":"Withdrawn","year":2021,"order":100,"text":"Specifies the requirements and corresponding test methods for pigments composed of finely divided aluminium metal. The specification covers four types of aluminium pigments. Two Types of pigments are further classified by their water-covering capacity. The pigments are suitable for use in general purpose, decorative and protective paints and speciality finishing paints. ISO 1247 replaces ISO Recommendation R 1247-1971. ","objectID":"5859_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>7:1974 Aluminium pigments for paints","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"Specifies the requirements and corresponding test methods for pigments composed of finely divided aluminium metal. The specification covers four types of aluminium pigments. Two Types of pigments are further classified by their water-covering capacity. The pigments are suitable for use in general purpose, decorative and protective paints and speciality finishing paints. <em>ISO</em> <em>124</em>7 replaces <em>ISO</em> Recommendation R <em>124</em>7-1971. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51407","uuid":"f0220c81-110a-4587-9c87-4e384b1d6972","title":"ISO 12404:2011 Soil quality — Guidance on the selection and application of screening methods","status":"Withdrawn","year":2021,"order":100,"text":"This International Standard provides guidance on the selection and application of screening methods for assessing soil quality. Guidance is given to choose an appropriate screening method for a specific parameter and defines the conditions under which they can be used. This International Standard does not recommend any particular screening method, but confirms the principles of their selection and application. ","objectID":"51407_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>04:2011 Soil quality — Guidance on the selection and application of screening methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"This International Standard provides guidance on the selection and application of screening methods for assessing soil quality. Guidance is given to choose an appropriate screening method for a specific parameter and defines the conditions under which they can be used. This International Standard does not recommend any particular screening method, but confirms the principles of their selection and application. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/03/70316","uuid":"06d35ac2-0a75-45b1-8452-e173f11c65c6","title":"ISO 12480-3:2016 Cranes — Safe use — Part 3: Tower cranes","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12480-3:2016 establishes required practices for the safe use of tower cranes. It is intended to be used in conjunction with ISO 12480-1. Subjects covered include safe systems of work, management, planning, selection, erection and dismantling, special base, operation and maintenance of cranes and the selection of operators, slingers and signallers. It does not cover manually (non-powered) operated cranes, or cranes in which at least one of its motions is manually operated. ","objectID":"70316_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>80-3:2016 Cranes — Safe use — Part 3: Tower cranes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>80-3:2016 establishes required practices for the safe use of tower cranes. It is intended to be used in conjunction with <em>ISO</em> <em>124</em>80-1. Subjects covered include safe systems of work, management, planning, selection, erection and dismantling, special base, operation and maintenance of cranes and the selection of operators, slingers and signallers. It does not cover manually (non-powered) operated cranes, or cranes in which at least one of its motions is manually operated. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/30/63065","uuid":"b1503382-1f03-48e8-9550-5f9fb05802aa","title":"ISO 12460-3:2015 Wood-based panels — Determination of formaldehyde release — Part 3: Gas analysis method","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12460-3:2015 specifies a procedure for determination of accelerated formaldehyde release from uncoated and coated wood-based panels using the gas analysis method. The procedure is also suitable for the testing of other materials (e.g. edge bands, floor coverings, foams, foils, laminated wood products, veneered wood products, coated wood products). ","objectID":"63065_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-3:2015 Wood-based panels — Determination of formaldehyde release — Part 3: Gas analysis method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>60-3:2015 specifies a procedure for determination of accelerated formaldehyde release from uncoated and coated wood-based panels using the gas analysis method. The procedure is also suitable for the testing of other materials (e.g. edge bands, floor coverings, foams, foils, laminated wood products, veneered wood products, coated wood products). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/12/51221","uuid":"59a7dc49-e4b1-4e19-95b6-8022715ef0ec","title":"ISO 12402-9:2006/Amd 1:2011 Personal flotation devices — Part 9: Test methods — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51221_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-9:2006/Amd 1:2011 Personal flotation devices — Part 9: Test methods — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/12/51220","uuid":"d9f2cd44-d680-458d-84a0-f7993e7e23e9","title":"ISO 12402-8:2006/Amd 1:2011 Personal flotation devices — Part 8: Accessories — Safety requirements and test methods — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51220_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-8:2006/Amd 1:2011 Personal flotation devices — Part 8: Accessories — Safety requirements and test methods — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/12/51219","uuid":"0e3fecfb-593f-4b5b-ab16-3ab2adaaf2cb","title":"ISO 12402-7:2006/Amd 1:2011 Personal flotation devices — Part 7: Materials and components — Safety requirements and test methods — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51219_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-7:2006/Amd 1:2011 Personal flotation devices — Part 7: Materials and components — Safety requirements and test methods — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/12/51218","uuid":"a306f75c-4fba-49b5-8e9b-f4f0be6a4108","title":"ISO 12402-6:2006/Amd 1:2010 Personal flotation devices — Part 6: Special purpose lifejackets and buoyancy aids — Safety requirements and additional test methods — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51218_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-6:2006/Amd 1:2010 Personal flotation devices — Part 6: Special purpose lifejackets and buoyancy aids — Safety requirements and additional test methods — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/12/51217","uuid":"5e4f813a-c0cc-4311-a3dd-18f80dd0e872","title":"ISO 12402-5:2006/Amd 1:2010 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51217_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-5:2006/Amd 1:2010 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/12/51216","uuid":"c8760a53-72b4-40ff-8b75-b07387038176","title":"ISO 12402-4:2006/Amd 1:2010 Personal flotation devices — Part 4: Lifejackets, performance level 100 — Safety requirements — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51216_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-4:2006/Amd 1:2010 Personal flotation devices — Part 4: Lifejackets, performance level 100 — Safety requirements — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/12/51215","uuid":"67940216-dd18-4eb8-833b-da1c2cb029f3","title":"ISO 12402-3:2006/Amd 1:2010 Personal flotation devices — Part 3: Lifejackets, performance level 150 — Safety requirements — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51215_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-3:2006/Amd 1:2010 Personal flotation devices — Part 3: Lifejackets, performance level 150 — Safety requirements — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/10/51023","uuid":"897fe012-e42b-438b-939e-59c9a9a8b5f9","title":"ISO 12402-2:2006/Amd 1:2010 Personal flotation devices — Part 2: Lifejackets, performance level 275 — Safety requirements — Amendment 1","status":"Withdrawn","year":2020,"order":100,"objectID":"51023_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-2:2006/Amd 1:2010 Personal flotation devices — Part 2: Lifejackets, performance level 275 — Safety requirements — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/53/45338","uuid":"698610d1-0621-44b0-9403-ea526c7528a4","title":"ISO 12402-5:2006/Cor 1:2006 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements — Technical Corrigendum 1","status":"Withdrawn","year":2020,"order":100,"objectID":"45338_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-5:2006/Cor 1:2006 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements — Technical Corrigendum 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/19/41987","uuid":"a3d34b9d-5645-4c6b-82c4-615ffc71f64a","title":"ISO 12402-9:2006 Personal flotation devices — Part 9: Test methods","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-9:2006 specifies the test methods for personal flotation devices. ","objectID":"41987_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-9:2006 Personal flotation devices — Part 9: Test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-9:2006 specifies the test methods for personal flotation devices. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41383","uuid":"eaa78643-6090-4075-90af-52a92a631f41","title":"ISO 12402-8:2006 Personal flotation devices — Part 8: Accessories — Safety requirements and test methods","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-8:2006 specifies the safety requirements and test methods for accessories used for personal flotation devices (PFDs), with regard to the technical provisions of the International Convention for the Safety of Life at Sea (SOLAS). ","objectID":"41383_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-8:2006 Personal flotation devices — Part 8: Accessories — Safety requirements and test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-8:2006 specifies the safety requirements and test methods for accessories used for personal flotation devices (PFDs), with regard to the technical provisions of the International Convention for the Safety of Life at Sea (SOLAS). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41382","uuid":"b98565cd-b951-4f1b-b2cd-29f91246db43","title":"ISO 12402-5:2006 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-5:2006 specifies the safety requirements for buoyancy aids with a buoyancy of not less than 50 N used in sheltered waters with help and rescue close at hand under such circumstances where more bulky or buoyant devices can impair the user's activity. It applies to buoyancy aids used by adults or children. ISO 12402-5:2006 is not applicable to one-piece suits. ","objectID":"41382_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-5:2006 Personal flotation devices — Part 5: Buoyancy aids (level 50) — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-5:2006 specifies the safety requirements for buoyancy aids with a buoyancy of not less than 50 N used in sheltered waters with help and rescue close at hand under such circumstances where more bulky or buoyant devices can impair the user's activity. It applies to buoyancy aids used by adults or children. <em>ISO</em> <em>124</em>02-5:2006 is not applicable to one-piece suits. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41381","uuid":"a82e3af3-954e-41d5-b6d6-0780ff9f7a81","title":"ISO 12402-4:2006 Personal flotation devices — Part 4: Lifejackets, performance level 100 — Safety requirements","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-4:2006 specifies the safety requirements for lifejackets, performance level 100. It applies to lifejackets used by adults or children. ","objectID":"41381_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-4:2006 Personal flotation devices — Part 4: Lifejackets, performance level 100 — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-4:2006 specifies the safety requirements for lifejackets, performance level 100. It applies to lifejackets used by adults or children. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41380","uuid":"81a3e2b8-9057-43a6-bc43-faf2266a03f7","title":"ISO 12402-3:2006 Personal flotation devices — Part 3: Lifejackets, performance level 150 — Safety requirements","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-3:2006 specifies the safety requirements for lifejackets, performance level 150. It applies to lifejackets used by adults or children. ","objectID":"41380_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-3:2006 Personal flotation devices — Part 3: Lifejackets, performance level 150 — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-3:2006 specifies the safety requirements for lifejackets, performance level 150. It applies to lifejackets used by adults or children. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41379","uuid":"1d3e0f92-42ba-4923-a120-9aaa7ff3016e","title":"ISO 12402-2:2006 Personal flotation devices — Part 2: Lifejackets, performance level 275 — Safety requirements","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-2:2006 specifies the safety requirements for lifejackets, performance level 275. It applies to lifejackets for adults and children for offshore use under extreme conditions. ","objectID":"41379_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-2:2006 Personal flotation devices — Part 2: Lifejackets, performance level 275 — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-2:2006 specifies the safety requirements for lifejackets, performance level 275. It applies to lifejackets for adults and children for offshore use under extreme conditions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/07/40776","uuid":"76e1decc-8789-4820-b36b-ba0c0c4e6643","title":"ISO 12402-6:2006 Personal flotation devices — Part 6: Special purpose lifejackets and buoyancy aids — Safety requirements and additional test methods","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-6:2006 specifies the safety requirements and additional test methods for special purpose lifejackets and buoyancy aids (referred to as special purpose devices within ISO 12402-6:2006) in combination with the requirements specified in ISO 12402-2 to ISO 12402-5. It applies to special purpose devices for adults generally and for chidren younger than six years partially. ","objectID":"40776_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-6:2006 Personal flotation devices — Part 6: Special purpose lifejackets and buoyancy aids — Safety requirements and additional test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-6:2006 specifies the safety requirements and additional test methods for special purpose lifejackets and buoyancy aids (referred to as special purpose devices within <em>ISO</em> <em>124</em>02-6:2006) in combination with the requirements specified in <em>ISO</em> <em>124</em>02-2 to <em>ISO</em> <em>124</em>02-5. It applies to special purpose devices for adults generally and for chidren younger than six years partially. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/07/40773","uuid":"dc87d47a-2145-42ec-ba86-1709d61b3a6f","title":"ISO 12402-10:2006 Personal flotation devices — Part 10: Selection and application of personal flotation devices and other relevant devices","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-10:2006 gives guidance for the selection and application of personal flotation devices complying with the other relevant parts of ISO 12402 and immersion suits according to ISO 15027-1 to ISO 15027-3. ","objectID":"40773_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-10:2006 Personal flotation devices — Part 10: Selection and application of personal flotation devices and other relevant devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-10:2006 gives guidance for the selection and application of personal flotation devices complying with the other relevant parts of <em>ISO</em> <em>124</em>02 and immersion suits according to <em>ISO</em> 15027-1 to <em>ISO</em> 15027-3. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/07/40716","uuid":"785a94dd-58ed-4b62-bbde-2e25fb913e83","title":"ISO 12402-7:2006 Personal flotation devices — Part 7: Materials and components — Safety requirements and test methods","status":"Withdrawn","year":2020,"order":100,"text":"ISO 12402-7:2006 specifies the minimum requirements for construction and performance of materials and components of personal flotation devices as well as relevant test methods. ","objectID":"40716_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-7:2006 Personal flotation devices — Part 7: Materials and components — Safety requirements and test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-7:2006 specifies the minimum requirements for construction and performance of materials and components of personal flotation devices as well as relevant test methods. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/13/61317","uuid":"45f61132-fdd1-4fb8-b311-1e38a45f66f1","title":"ISO 12468-2:2013 External exposure of roofs to fire — Part 2: Classification of roofs","status":"Withdrawn","year":2019,"order":100,"text":"ISO 12468-2:2013 establishes the classification of roofs tested in accordance with ISO 12468‑1. Performance criteria are established with respect to the following: fire penetration or openings; external fire spread; falling of flaming droplets or debris. ","objectID":"61317_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>68-2:2013 External exposure of roofs to fire — Part 2: Classification of roofs","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>68-2:2013 establishes the classification of roofs tested in accordance with <em>ISO</em> <em>124</em>68‑1. Performance criteria are established with respect to the following: fire penetration or openings; external fire spread; falling of flaming droplets or debris. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/92/59224","uuid":"75326afc-a6e1-4a79-9a15-41fd5b942171","title":"ISO 12405-3:2014 Electrically propelled road vehicles — Test specification for lithium-ion traction battery packs and systems — Part 3: Safety performance requirements","status":"Withdrawn","year":2019,"order":100,"text":"ISO 12405-3:2014 specifies test procedures and provides acceptable safety requirements for voltage class B lithium-ion battery packs and systems, to be used as traction batteries in electrically propelled road vehicles. Traction battery packs and systems used for two-wheel or three-wheel vehicles are not covered by ISO 12405-3:2014. ISO 12405-3:2014 is related to the testing of safety performance of battery packs and systems for their intended use in a vehicle. ISO 12405-3:2014 is not intended to be applied for the evaluation of the safety of battery packs and systems during transport, storage, vehicle production, repair, and maintenance services. ","objectID":"59224_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>05-3:2014 Electrically propelled road vehicles — Test specification for lithium-ion traction battery packs and systems — Part 3: Safety performance requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>05-3:2014 specifies test procedures and provides acceptable safety requirements for voltage class B lithium-ion battery packs and systems, to be used as traction batteries in electrically propelled road vehicles. Traction battery packs and systems used for two-wheel or three-wheel vehicles are not covered by <em>ISO</em> <em>124</em>05-3:2014. <em>ISO</em> <em>124</em>05-3:2014 is related to the testing of safety performance of battery packs and systems for their intended use in a vehicle. <em>ISO</em> <em>124</em>05-3:2014 is not intended to be applied for the evaluation of the safety of battery packs and systems during transport, storage, vehicle production, repair, and maintenance services. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/58/55854","uuid":"51d2cada-5896-42d8-9334-190f67b7da1a","title":"ISO 12405-2:2012 Electrically propelled road vehicles — Test specification for lithium-ion traction battery packs and systems — Part 2: High-energy applications","status":"Withdrawn","year":2018,"order":100,"objectID":"55854_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>05-2:2012 Electrically propelled road vehicles — Test specification for lithium-ion traction battery packs and systems — Part 2: High-energy applications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51414","uuid":"5d84aa85-1487-4627-bb75-746039494e0c","title":"ISO 12405-1:2011 Electrically propelled road vehicles — Test specification for lithium-ion traction battery packs and systems — Part 1: High-power applications","status":"Withdrawn","year":2018,"order":100,"text":"ISO 12405-1:2011 specifies test procedures for lithium-ion battery packs and systems for use in electrically propelled road vehicles. The specified test procedures enable the determination of the essential characteristics of performance, reliability and abuse of lithium-ion battery packs and systems. They assist the user of ISO 12405-1:2011 to compare the test results achieved for different battery packs or systems. Therefore, ISO 12405-1:2011 specifies standard test procedures for basic characteristics of performance, reliability and abuse of lithium-ion battery packs and systems. It enables the setting up of a dedicated test plan for an individual battery pack or system subject to agreement between the customer and supplier. If required, the relevant test procedures and/or test conditions of lithium-ion battery packs and systems can be selected from the standard tests provided in ISO 12405-1:2011 to configure a dedicated test plan. ISO 12405-1:2011 specifies tests for high-power battery packs and systems. ","objectID":"51414_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>05-1:2011 Electrically propelled road vehicles — Test specification for lithium-ion traction battery packs and systems — Part 1: High-power applications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>05-1:2011 specifies test procedures for lithium-ion battery packs and systems for use in electrically propelled road vehicles. The specified test procedures enable the determination of the essential characteristics of performance, reliability and abuse of lithium-ion battery packs and systems. They assist the user of <em>ISO</em> <em>124</em>05-1:2011 to compare the test results achieved for different battery packs or systems. Therefore, <em>ISO</em> <em>124</em>05-1:2011 specifies standard test procedures for basic characteristics of performance, reliability and abuse of lithium-ion battery packs and systems. It enables the setting up of a dedicated test plan for an individual battery pack or system subject to agreement between the customer and supplier. If required, the relevant test procedures and/or test conditions of lithium-ion battery packs and systems can be selected from the standard tests provided in <em>ISO</em> <em>124</em>05-1:2011 to configure a dedicated test plan. <em>ISO</em> <em>124</em>05-1:2011 specifies tests for high-power battery packs and systems. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/26/2664","uuid":"f0ecd1a2-0583-4067-a00d-b097fe5c3ccb","title":"ISO 12485:1998 Tower cranes — Stability requirements","status":"Withdrawn","year":2018,"order":100,"objectID":"2664_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>85:1998 Tower cranes — Stability requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/14/51474","uuid":"412bac70-8168-4f2d-bba2-5f96248980e9","title":"ISO 12493:2011 Rubber, vulcanized — Determination of stress in tension upon heating","status":"Withdrawn","year":2017,"order":100,"text":"ISO 12493:2011 specifies a method for measuring the stress in tension which is developed in vulcanized rubber when it is heated (thermal stress). The thermal stress is measured for various pre-strain and temperature conditions as a function of time. ","objectID":"51474_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>93:2011 Rubber, vulcanized — Determination of stress in tension upon heating","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>93:2011 specifies a method for measuring the stress in tension which is developed in vulcanized rubber when it is heated (thermal stress). The thermal stress is measured for various pre-strain and temperature conditions as a function of time. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/98/39861","uuid":"3a4f9c07-9295-45bd-9699-13e4b8dc2f24","title":"ISO 12473:2006 General principles of cathodic protection in sea water","status":"Withdrawn","year":2017,"order":100,"text":"ISO 12473:2006 covers the general principles of cathodic protection including the criteria for protection, environmental and design considerations and secondary effects of cathodic protection, and is intended as an introduction to other European Standards in the general series \"Cathodic Protection of Steel Structures in Sea Water\". ","objectID":"39861_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>73:2006 General principles of cathodic protection in sea water","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>73:2006 covers the general principles of cathodic protection including the criteria for protection, environmental and design considerations and secondary effects of cathodic protection, and is intended as an introduction to other European Standards in the general series \"Cathodic Protection of Steel Structures in Sea Water\". ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/28/32823","uuid":"858e7f75-c1a2-4c82-b793-e20cbdec72c5","title":"ISO 12494:2001 Atmospheric icing of structures","status":"Withdrawn","year":2017,"order":100,"objectID":"32823_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>94:2001 Atmospheric icing of structures","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/78/57878","uuid":"7e4b2ee7-a264-4073-8940-dfb021b11dfd","title":"ISO 12460-4:2008/Amd 1:2011 Wood-based panels — Determination of formaldehyde release — Part 4: Desiccator method — Amendment 1","status":"Withdrawn","year":2016,"order":100,"objectID":"57878_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-4:2008/Amd 1:2011 Wood-based panels — Determination of formaldehyde release — Part 4: Desiccator method — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/22/42256","uuid":"247ea035-468e-4c32-91ca-866eb805e2de","title":"ISO 12460-4:2008 Wood-based panels — Determination of formaldehyde release — Part 4: Desiccator method","status":"Withdrawn","year":2016,"order":100,"text":"ISO 12460-4:2008 specifies a desiccator method for the determination of the quantity of formaldehyde emitted from particleboard, fibreboard, plywood, oriented strand board (OSB), and wooden laminated flooring. ","objectID":"42256_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-4:2008 Wood-based panels — Determination of formaldehyde release — Part 4: Desiccator method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>60-4:2008 specifies a desiccator method for the determination of the quantity of formaldehyde emitted from particleboard, fibreboard, plywood, oriented strand board (OSB), and wooden laminated flooring. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/40/34029","uuid":"cd403964-bde5-4712-8b8b-82352d275856","title":"ISO 12480-3:2005 Cranes — Safe use — Part 3: Tower cranes","status":"Withdrawn","year":2016,"order":100,"text":"ISO 12480-3:2005 establishes required practices for the safe use of tower cranes. It is intended to be used in conjunction with ISO 12480-1. Subjects covered include safe systems of work, management, planning, selection, erection and dismantling, special base, operation and maintenance of cranes and the selection of drivers, slingers and signallers. It does not cover manually (non-powered) operated cranes, or cranes in which at least one of its motions is manually operated. ","objectID":"34029_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>80-3:2005 Cranes — Safe use — Part 3: Tower cranes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>80-3:2005 establishes required practices for the safe use of tower cranes. It is intended to be used in conjunction with <em>ISO</em> <em>124</em>80-1. Subjects covered include safe systems of work, management, planning, selection, erection and dismantling, special base, operation and maintenance of cranes and the selection of drivers, slingers and signallers. It does not cover manually (non-powered) operated cranes, or cranes in which at least one of its motions is manually operated. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/13/51349","uuid":"b1c1336d-49ca-4db0-adb0-6a82c5320fef","title":"ISO 12460-5:2011 Wood-based panels — Determination of formaldehyde release — Part 5: Extraction method (called the perforator method)","status":"Withdrawn","year":2015,"order":100,"text":"ISO 12460-5:2011 specifies an extraction method, known as the \"perforator method\", for the determination of the formaldehyde content of unlaminated and uncoated wood-based panels. ","objectID":"51349_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-5:2011 Wood-based panels — Determination of formaldehyde release — Part 5: Extraction method (called the perforator method)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>60-5:2011 specifies an extraction method, known as the \"perforator method\", for the determination of the formaldehyde content of unlaminated and uncoated wood-based panels. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/22/42255","uuid":"44227a93-547a-45c9-b982-86f9e89b272d","title":"ISO 12460-3:2008 Wood-based panels — Determination of formaldehyde release — Part 3: Gas analysis method","status":"Withdrawn","year":2015,"order":100,"text":"ISO 12460-3:2008 specifies a procedure for determination of accelerated formaldehyde release from wood-based panels using the gas analysis method. ","objectID":"42255_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>60-3:2008 Wood-based panels — Determination of formaldehyde release — Part 3: Gas analysis method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>60-3:2008 specifies a procedure for determination of accelerated formaldehyde release from wood-based panels using the gas analysis method. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41378","uuid":"3b085b3c-a173-4eff-b467-705fa10140ea","title":"ISO 12402-1:2005 Personal flotation devices — Part 1: Lifejackets for seagoing ships — Safety requirements","status":"Withdrawn","year":2015,"order":100,"text":"ISO 12402-1:2005 specifies the safety requirements for lifejackets intended for use on seagoing ships with regard to the technical provisions of the International Convention for the Safety of Life at Sea. ","objectID":"41378_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>02-1:2005 Personal flotation devices — Part 1: Lifejackets for seagoing ships — Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>02-1:2005 specifies the safety requirements for lifejackets intended for use on seagoing ships with regard to the technical provisions of the International Convention for the Safety of Life at Sea. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/25/2550","uuid":"f673fa64-d0a4-4b91-85cd-d133541397f6","title":"ISO 12482-1:1995 Cranes — Condition monitoring — Part 1: General","status":"Withdrawn","year":2014,"order":100,"text":"Purpose of this part is to ensure that the design constraints of the intended use of a crane are clearly identified and to define actions to be taken when the crane has been used over a period of time and has approached these constraints, to ensure a new safe working period. A description is given of the special assessment required to monitor the condition of a crane. ","objectID":"2550_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>82-1:1995 Cranes — Condition monitoring — Part 1: General","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"Purpose of this part is to ensure that the design constraints of the intended use of a crane are clearly identified and to define actions to be taken when the crane has been used over a period of time and has approached these constraints, to ensure a new safe working period. A description is given of the special assessment required to monitor the condition of a crane. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/50/35094","uuid":"e3a1d009-70ee-40eb-b400-b6c2e7050fb8","title":"ISO 12468-2:2005 External fire exposure to roofs — Part 2: Classification of roofs","status":"Withdrawn","year":2013,"order":100,"text":"ISO 12468-2:2005 establishes the classification of roofs tested in accordance with ISO 12468-1. Performance criteria are established with respect to the following: fire penetration or openings; external fire spread; falling of flaming droplets or debris. ","objectID":"35094_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>124</em>68-2:2005 External fire exposure to roofs — Part 2: Classification of roofs","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]},"text":{"value":"<em>ISO</em> <em>124</em>68-2:2005 establishes the classification of roofs tested in accordance with <em>ISO</em> <em>124</em>68-1. Performance criteria are established with respect to the following: fire penetration or openings; external fire spread; falling of flaming droplets or debris. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","124"]}}}],"nbHits":176,"page":0,"nbPages":2,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 124","params":"query=ISO+124&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":2}
256
- http_version:
257
- recorded_at: Mon, 17 Jan 2022 09:56:58 GMT
258
- - request:
259
- method: get
260
- uri: https://www.iso.org/contents/data/standard/06/18/61884.html
261
- body:
262
- encoding: US-ASCII
263
- string: ''
264
- headers:
265
- Accept-Encoding:
266
- - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
267
- Accept:
268
- - "*/*"
269
- User-Agent:
270
- - Ruby
271
- Host:
272
- - www.iso.org
273
- response:
274
- status:
275
- code: 301
276
- message: ''
277
- headers:
278
- Expires:
279
- - Wed, 09 May 1979 05:30:00 GMT
280
- Cache-Control:
281
- - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
282
- Pragma:
283
- - no-cache
284
- Set-Cookie:
285
- - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
286
- Secure
287
- - JSESSIONID=E3265866F4451742BA1B1AD5D42745B5; Path=/; Secure; HttpOnly
288
- Location:
289
- - "/standard/61884.html"
290
- Content-Length:
291
- - '0'
292
- Date:
293
- - Mon, 17 Jan 2022 09:56:59 GMT
294
- Strict-Transport-Security:
295
- - max-age=31536000; includeSubDomains
296
- body:
297
- encoding: UTF-8
298
- string: ''
299
- http_version:
300
- recorded_at: Mon, 17 Jan 2022 09:56:59 GMT
301
- - request:
302
- method: get
303
- uri: https://www.iso.org/standard/61884.html
108
+ uri: https://www.iso.org/standard/72849.html
304
109
  body:
305
110
  encoding: US-ASCII
306
111
  string: ''
@@ -327,7 +132,7 @@ http_interactions:
327
132
  Set-Cookie:
328
133
  - BIGipServerpool_prod_iso_www-jahia=713576842.36895.0000; path=/; Httponly;
329
134
  Secure
330
- - JSESSIONID=49204AA5801E2660B11B3FDA728E0259; Path=/; Secure; HttpOnly
135
+ - JSESSIONID=3FA50ADFF3FC204ECC8E95F95B8BCB5A; Path=/; Secure; HttpOnly
331
136
  Vary:
332
137
  - accept-encoding
333
138
  Content-Type:
@@ -335,18 +140,18 @@ http_interactions:
335
140
  Transfer-Encoding:
336
141
  - chunked
337
142
  Date:
338
- - Mon, 17 Jan 2022 09:57:01 GMT
143
+ - Sat, 22 Jan 2022 10:39:25 GMT
339
144
  Strict-Transport-Security:
340
145
  - max-age=31536000; includeSubDomains
341
146
  body:
342
147
  encoding: ASCII-8BIT
343
148
  string: !binary |-
344
- <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 124:2014 - Latex, rubber — Determination of total solids content</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/61884.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1638177692575" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1638177692575"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20190610" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/06/18/61884.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 124:2014" />
    <meta property="og:title" content="ISO 124:2014" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Latex, rubber — Determination of total solids content" />
    <meta property="og:description" content="Latex, rubber — Determination of total solids content" />
    <meta name="description" content="Latex, rubber — Determination of total solids content" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html" class="dropdown-toggle" role="button">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/61884.html">français</a></li><li><a href="/ru/standard/61884.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="61884 - ISO 124:2014 - Latex, rubber — Determination of total solids content"></span>

  <span class="hidden" id="itemReference">ISO 124:2014</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">61884</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/83.html">83</a> >&nbsp;<a href="/en/ics/83.040.html">83.040</a> >&nbsp;<a href="/en/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 124:2014</h1>
  <h2 class="no-uppercase">Latex, rubber — Determination of total solids content</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

    <section class="bg-lightgray section-sm">
      <div class="container">
        <div class="row">
          <div class="col-md-7">
            <h3 role="alert" class="no-margin">
              This standard was last reviewed and confirmed in&nbsp;2019.
              Therefore this version remains current.
            </h3>
          </div>
        </div>
      </div>
    </section>
  
<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:61884:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>ISO 124:2014 specifies methods for the determination of the total solids content of natural rubber field and concentrated latices and synthetic rubber latex. These methods are not necessarily suitable for latex from natural sources other than the <i>Hevea brasiliensis</i>, for vulcanized latex, for compounded latex, or for artificial dispersions of rubber.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/06/18/61884.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2014-03</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 7
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 8
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Raw materials (including latex) for use in the rubber industry</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex and raw rubber</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/en/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Sustainable Development Goals" />
      </p>
      <p>
        This standard contributes to the following  <a href="/sdgs.html">Sustainable Development Goals</a>:
      <p>
      <div class="clearfix">
        
          <a href="/sdg/SDG12.html" title="Responsible Consumption and Production">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Responsible Consumption and Production</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/sdg/SDG09.html" title="Industry, Innovation and Infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industry, Innovation and Infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF + ePub
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2RAAW~a0fb0000000eEaeAAE~a0cb0000001QFEMAA4" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2RAAW~a0fb0000000eEZDAA2~a0cb0000001QFGMAA4" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2WAAW~a0fb0000000eEh3AAE~a0cb0000001QF6tAAG" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2WAAW~a0fb0000000eEh8AAE~a0cb0000001QFDAAA4" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/59264.html">ISO 124:2011</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 124:2014</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.93</strong> (Confirmed)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2012-07-17</span>
                              <div class="stage-title">
                                New project approved
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2012-07-17</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2013-02-05</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2013-04-05</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2013-07-07</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2013-12-24</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2014-01-21</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2014-01-22</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2014-01-29</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2014-01-29</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2014-03-12</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2019-01-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2019-06-05</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2019-06-10</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                      </a>

                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/83.html">83</a></li>
    
      <li><a href="/en/ics/83.040.html">83.040</a></li>
    
      <li><a href="/en/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 124:2014</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
149
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 125:2020 - Natural rubber latex concentrate — Determination of alkalinity</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/72849.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1642771880426" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1642771880426"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20200219" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/07/28/72849.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 125:2020" />
    <meta property="og:title" content="ISO 125:2020" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Natural rubber latex concentrate — Determination of alkalinity" />
    <meta property="og:description" content="Natural rubber latex concentrate — Determination of alkalinity" />
    <meta name="description" content="Natural rubber latex concentrate — Determination of alkalinity" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html" class="dropdown-toggle" role="button">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/72849.html">français</a></li><li><a href="/ru/standard/72849.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="72849 - ISO 125:2020 - Natural rubber latex concentrate — Determination of alkalinity"></span>

  <span class="hidden" id="itemReference">ISO 125:2020</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">72849</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/83.html">83</a> >&nbsp;<a href="/en/ics/83.040.html">83.040</a> >&nbsp;<a href="/en/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 125:2020</h1>
  <h2 class="no-uppercase">Natural rubber latex concentrate — Determination of alkalinity</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:72849:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>This document specifies a method for the determination of the alkalinity of natural rubber latex concentrate.</p>
<p>The method is not necessarily suitable for latices from natural sources other than <i>Hevea brasiliensis</i> or for synthetic rubber latices, compounded latex, vulcanized latex or artificial dispersions of rubber.</p>
<p>NOTE    A method for the determination of the alkalinity of polychloroprene latex is specified in ISO 13773.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/07/28/72849.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2020-02</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 7
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 7
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Raw materials (including latex) for use in the rubber industry</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex and raw rubber</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/en/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Sustainable Development Goals" />
      </p>
      <p>
        This standard contributes to the following  <a href="/sdgs.html">Sustainable Development Goals</a>:
      <p>
      <div class="clearfix">
        
          <a href="/sdg/SDG12.html" title="Responsible Consumption and Production">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Responsible Consumption and Production</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/sdg/SDG09.html" title="Industry, Innovation and Infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industry, Innovation and Infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF + ePub
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dWmQAI~a0c0X00000OsDjTQAV" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dXVQAY~a0c0X00000OsDkCQAV" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFl7AAE~a0c0X00000OqPNqQAN" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFnMAAU~a0c0X00000OqPObQAN" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/59265.html">ISO 125:2011</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 125:2020</h5>
                  
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>60.60</strong><span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2016-12-06</span>
                              <div class="stage-title">
                                New project approved
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">2017-03-06</span>
                              <div class="stage-title">
                                Committee draft (CD) registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">2017-03-07</span>
                              <div class="stage-title">
                                CD study/ballot initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_60">
                              <span class="stage-code">30.60</span>
                              <span class="stage-date">2017-06-08</span>
                              <div class="stage-title">
                                Close of voting/ comment period
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2018-12-03</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2018-12-04</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2019-02-05</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2019-05-01</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2019-12-10</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2020-02-19</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard to be revised
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard proposed by TC or SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/83.html">83</a></li>
    
      <li><a href="/en/ics/83.040.html">83.040</a></li>
    
      <li><a href="/en/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 125:2020</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
345
150
  http_version:
346
- recorded_at: Mon, 17 Jan 2022 09:57:02 GMT
151
+ recorded_at: Sat, 22 Jan 2022 10:39:25 GMT
347
152
  - request:
348
153
  method: get
349
- uri: https://www.iso.org/fr/standard/61884.html
154
+ uri: https://www.iso.org/fr/standard/72849.html
350
155
  body:
351
156
  encoding: US-ASCII
352
157
  string: ''
@@ -371,9 +176,9 @@ http_interactions:
371
176
  Pragma:
372
177
  - no-cache
373
178
  Set-Cookie:
374
- - BIGipServerpool_prod_iso_www-jahia=713576842.36895.0000; path=/; Httponly;
179
+ - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
375
180
  Secure
376
- - JSESSIONID=F30714748D4718B05AA4B743E698FADE; Path=/; Secure; HttpOnly
181
+ - JSESSIONID=E7757EDB443E334D4328ECEDBA3122AB; Path=/; Secure; HttpOnly
377
182
  Vary:
378
183
  - accept-encoding
379
184
  Content-Type:
@@ -381,13 +186,13 @@ http_interactions:
381
186
  Transfer-Encoding:
382
187
  - chunked
383
188
  Date:
384
- - Mon, 17 Jan 2022 09:57:04 GMT
189
+ - Sat, 22 Jan 2022 10:39:27 GMT
385
190
  Strict-Transport-Security:
386
191
  - max-age=31536000; includeSubDomains
387
192
  body:
388
193
  encoding: ASCII-8BIT
389
194
  string: !binary |-
390
- <!DOCTYPE html>


<html lang="fr">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'fr'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 124:2014 - Latex de caoutchouc — Détermination des matières solides totales</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/fr/standard/61884.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"fr",uilang:"fr",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='fr_FR';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1638177692575" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1638177692575"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20190610" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/fr/sites/isoorg/contents/data/standard/06/18/61884.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 124:2014" />
    <meta property="og:title" content="ISO 124:2014" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Latex de caoutchouc — Détermination des matières solides totales" />
    <meta property="og:description" content="Latex de caoutchouc — Détermination des matières solides totales" />
    <meta name="description" content="Latex de caoutchouc — Détermination des matières solides totales" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Passer au contenu principal</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/standards.html" class="dropdown-toggle" role="button">Normes</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html" class="dropdown-toggle" role="button">Avantages</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-and-smes.html" class="dropdown-toggle" role="button">PME</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-consumers.html" class="dropdown-toggle" role="button">Consommateurs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-policy-makers.html" class="dropdown-toggle" role="button">L’ISO et les organismes de réglementation</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/standards-in-action.html" class="dropdown-toggle" role="button">Normes en action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html" class="dropdown-toggle" role="button">Les normes les plus connues</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformité</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/the-iso-survey.html" class="dropdown-toggle" role="button">L'Étude ISO</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html" class="dropdown-toggle" role="button">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/about-us.html" class="dropdown-toggle" role="button">À propos de l'ISO</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/what-we-do.html" class="dropdown-toggle" role="button">Nos activités</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/developing-standards.html"  class="dropdown-toggle" role="button">Elaboration des normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/research-and-education.html" class="dropdown-toggle" role="button">Recherche</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/capacity-building.html" class="dropdown-toggle" role="button">Renforcement des capacités</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/education-about-standards.html" class="dropdown-toggle" role="button">Enseignement sur les normes</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html" class="dropdown-toggle" role="button">Membres</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/announcements.html" class="dropdown-toggle" role="button">Communiqués</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/fr/strategy2030.html" class="dropdown-toggle" role="button">Stratégie 2030</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Facteurs de changement</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Nos objectifs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Mesurer le succès</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/news.html" class="dropdown-toggle" role="button">Actualités</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html" class="dropdown-toggle" role="button">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html" class="dropdown-toggle" role="button">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/developing-standards.html" class="dropdown-toggle" role="button">Participer</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html" class="dropdown-toggle" role="button">Qui élabore les normes</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/technical-committees.html" class="dropdown-toggle" role="button">Comités techniques</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Autres organismes</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organisations en coopération</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html" class="dropdown-toggle" role="button">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html" class="dropdown-toggle" role="button">Pourquoi s’engager ?</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/ClimateAction.html" class="dropdown-toggle" role="button">Kit d’action pour le climat</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/fr/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html" class="dropdown-toggle" role="button">Publications et produits</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/fr/#account/products"  target="_blank" class="dropdown-toggle" role="button">Mon compte</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/fr/home.html" title="Organisation internationale de normalisation" alt="Logo ISO"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/fr"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Recherche</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=fr" title="Panier d'achat" aria-label="Panier d'achat">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">FR <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/standard/61884.html">English</a></li><li><a href="/ru/standard/61884.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/news.html">Actualités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="61884 - ISO 124:2014 - Latex de caoutchouc — Détermination des matières solides totales"></span>

  <span class="hidden" id="itemReference">ISO 124:2014</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">61884</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="Organisation internationale de normalisation">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/fr/standards-catalogue/browse-by-ics.html"title="Explorez la collection de normes ISO dans son intégralité et trouvez celles qui s’appliquent à votre secteur.">ICS</a> >&nbsp;<a href="/fr/ics/83.html">83</a> >&nbsp;<a href="/fr/ics/83.040.html">83.040</a> >&nbsp;<a href="/fr/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 124:2014</h1>
  <h2 class="no-uppercase">Latex de caoutchouc — Détermination des matières solides totales</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Acheter cette norme
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

    <section class="bg-lightgray section-sm">
      <div class="container">
        <div class="row">
          <div class="col-md-7">
            <h3 role="alert" class="no-margin">
              Le dernier examen de cette norme date de&nbsp;2019.
              Cette édition reste donc d’actualité.
            </h3>
          </div>
        </div>
      </div>
    </section>
  
<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Résumé&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:61884:fr">Prévisualiser</a></h3>
          <div itemprop="description">
            <p><p>L'ISO 124:2014 spécifie des méthodes pour la détermination des matières solides totales dans le latex de plantation, le latex de concentré de caoutchouc naturel et le latex de caoutchouc synthétique. Ces méthodes ne conviennent pas nécessairement au latex d'origine naturelle autre que celui de l'<i>Hevea brasiliensis</i>, au latex vulcanisé, aux mélanges de latex, ou aux dispersions artificielles de caoutchouc.</p></p>
          </div>
          <br/>
        <h3>
  Informations générales
  <sup><a href="/fr/contents/data/standard/06/18/61884.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="S'abonner&nbsp;aux&nbsp;mises&nbsp;à&nbsp;jour">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>État actuel&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Publiée"></span>Publiée</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Date de publication&nbsp;: </strong><span itemprop="releaseDate">2014-03</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 7
      </div>
      <div class="col-sm-6">
        
          <strong>Nombre de pages&nbsp;:</strong> 8
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Comité technique</div> :
        <div class="entry-name entry-block">
          <a href="/fr/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Matières premières (y compris le latex) à l'usage de l'industrie des élastomères</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/fr/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex et caoutchouc brut</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/fr/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Objectifs de développement durable" />
      </p>
      <p>
        Cette norme contribue aux  <a href="/fr/sdgs.html">Objectifs de développement durable</a>&nbsp;suivants&nbsp;:
      <p>
      <div class="clearfix">
        
          <a href="/fr/sdg/SDG12.html" title="Consommation et production responsables">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Consommation et production responsables</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/fr/sdg/SDG09.html" title="Industrie, innovation et infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industrie, innovation et infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Acheter&nbsp;cette norme</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">fr</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Langue</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF + ePub
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2RAAW~a0fb0000000eEaeAAE~a0cb0000001QFEMAA4" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2RAAW~a0fb0000000eEZDAA2~a0cb0000001QFGMAA4" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Papier
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2WAAW~a0fb0000000eEh3AAE~a0cb0000001QF6tAAG" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub000000284W4AAI~a05b0000005WV2WAAW~a0fb0000000eEh8AAE~a0cb0000001QFDAAA4" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'fr', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Acheter
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Valider mon panier"></span>
            <span id="continueShopping" class="hidden" data-label="Ajouter au panier et continuer mes achats"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Cycle de vie</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Précédemment</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Annulée</div>
                    <h5><a href="/fr/standard/59264.html">ISO 124:2011</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Actuellement</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Publiée</div>
                    
              <h5>ISO 124:2014</h5>
                  <br/>Les normes ISO sont réexaminées tous les cinq ans<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stade: <strong>90.93</strong> (Confirmée)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Préliminaire</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposition</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2012-07-17</span>
                              <div class="stage-title">
                                Nouveau projet approuvé
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Préparation</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Comité</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2012-07-17</span>
                              <div class="stage-title">
                                CD approuvé pour enregistrement comme DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquête</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2013-02-05</span>
                              <div class="stage-title">
                                DIS enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2013-04-05</span>
                              <div class="stage-title">
                                Mise au vote du DIS:  12 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2013-07-07</span>
                              <div class="stage-title">
                                Clôture du vote
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2013-12-24</span>
                              <div class="stage-title">
                                Rapport complet diffusé: DIS approuvé pour enregistrement comme FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approbation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2014-01-21</span>
                              <div class="stage-title">
                                Texte final reçu ou FDIS enregistré pour approbation formelle
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2014-01-22</span>
                              <div class="stage-title">
                                Epreuve envoyée au secrétariat ou mise au vote du FDIS: 8 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2014-01-29</span>
                              <div class="stage-title">
                                Clôture du vote Epreuve retournée par le secrétariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2014-01-29</span>
                              <div class="stage-title">
                                Norme internationale en cours de publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2014-03-12</span>
                              <div class="stage-title">
                                Norme internationale publiée
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Examen</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2019-01-15</span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2019-06-05</span>
                              <div class="stage-title">
                                Clôture de l'examen
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2019-06-10</span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Annulation</div>
                        
                      </a>

                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Vous avez une question?</h4>

<p>Consulter notre&nbsp;<a href="/fr/frequently-asked-questions-faqs.html" title="Foire Aux Questions (FAQs)">FAQ</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Service &agrave; la client&egrave;le</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Horaires d&rsquo;ouverture:<br />
De lundi &agrave; vendredi - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Suivez l&#39;actualit&eacute; de l&#39;ISO</h4>

<p>Inscrivez-vous &agrave; notre Newsletter (en anglais) pour suivre nos actualit&eacute;s, points de vue et informations sur nos produits.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/fr/home.html" title="Page d'accueil"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/fr/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a>

        </li>
      
        <li>
          
              <a href="/fr/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/fr/ics/83.html">83</a></li>
    
      <li><a href="/fr/ics/83.040.html">83.040</a></li>
    
      <li><a href="/fr/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 124:2014</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Plan du site</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html">Avantages</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html">Les normes les plus connues</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/conformity-assessment.html">Certification & conformité</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/what-we-do.html">Nos activités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html">Membres</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030.html">Stratégie 2030</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/news.html">Actualités</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html">Qui élabore les normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html">Pourquoi s’engager ?</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/ClimateAction.html">Kit d’action pour le climat</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html">Publications et produits</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-name-and-logo.html">Nom et logo de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/privacy-and-copyright.html">Confidentialité et droit d'auteur</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/working-with-iso.html" >Emploi</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/frequently-asked-questions-faqs.html">FAQ</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/contact-iso.html">Contacter l'ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Le monde va loin quand il s'accorde</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">Nous nous engageons à ce que notre site Web soit accessible à tous. Pour toute question ou suggestion concernant l'accessibilité du site, <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contactez-nous</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© Tous droits réservés</a> <span id="copyright" class="collapse">Le matériel publié sur ISO.org est sujet aux mêmes conditions en matière de droits d’auteur que les publications de l’ISO et son emploi est conditionné par l’acceptation, par l’utilisateur, des conditions de l’ISO en matière de droits d’auteur régissant les publications de l’ISO. Toute utilisation du matériel concerné, y compris sa reproduction intégrale ou partielle vers un autre site Internet, requiert l’autorisation écrite de l’ISO. Toute demande à cet effet doit être adressée à <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Retour en haut de page"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression" /></div>
            <div class="poweredby-txt">Développé par</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
195
+ <!DOCTYPE html>


<html lang="fr">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'fr'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 125:2020 - Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/fr/standard/72849.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"fr",uilang:"fr",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='fr_FR';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1642771880426" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1642771880426"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20200219" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/fr/sites/isoorg/contents/data/standard/07/28/72849.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 125:2020" />
    <meta property="og:title" content="ISO 125:2020" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité" />
    <meta property="og:description" content="Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité" />
    <meta name="description" content="Latex concentré de caoutchouc naturel — Détermination de l&#039;alcalinité" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Passer au contenu principal</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/standards.html" class="dropdown-toggle" role="button">Normes</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html" class="dropdown-toggle" role="button">Avantages</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-and-smes.html" class="dropdown-toggle" role="button">PME</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-consumers.html" class="dropdown-toggle" role="button">Consommateurs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/iso-and-policy-makers.html" class="dropdown-toggle" role="button">L’ISO et les organismes de réglementation</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/standards-in-action.html" class="dropdown-toggle" role="button">Normes en action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html" class="dropdown-toggle" role="button">Les normes les plus connues</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformité</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/the-iso-survey.html" class="dropdown-toggle" role="button">L'Étude ISO</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html" class="dropdown-toggle" role="button">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/about-us.html" class="dropdown-toggle" role="button">À propos de l'ISO</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/what-we-do.html" class="dropdown-toggle" role="button">Nos activités</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/developing-standards.html"  class="dropdown-toggle" role="button">Elaboration des normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/research-and-education.html" class="dropdown-toggle" role="button">Recherche</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/capacity-building.html" class="dropdown-toggle" role="button">Renforcement des capacités</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/education-about-standards.html" class="dropdown-toggle" role="button">Enseignement sur les normes</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html" class="dropdown-toggle" role="button">Membres</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/announcements.html" class="dropdown-toggle" role="button">Communiqués</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/fr/strategy2030.html" class="dropdown-toggle" role="button">Stratégie 2030</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Facteurs de changement</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Nos objectifs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Mesurer le succès</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/news.html" class="dropdown-toggle" role="button">Actualités</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html" class="dropdown-toggle" role="button">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html" class="dropdown-toggle" role="button">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/fr/developing-standards.html" class="dropdown-toggle" role="button">Participer</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html" class="dropdown-toggle" role="button">Qui élabore les normes</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/technical-committees.html" class="dropdown-toggle" role="button">Comités techniques</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Autres organismes</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organisations en coopération</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html" class="dropdown-toggle" role="button">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html" class="dropdown-toggle" role="button">Pourquoi s’engager ?</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/ClimateAction.html" class="dropdown-toggle" role="button">Kit d’action pour le climat</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html" class="dropdown-toggle" role="button">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/fr/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html" class="dropdown-toggle" role="button">Publications et produits</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/fr/#account/products"  target="_blank" class="dropdown-toggle" role="button">Mon compte</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/fr/home.html" title="Organisation internationale de normalisation" alt="Logo ISO"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/fr"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Recherche</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=fr" title="Panier d'achat" aria-label="Panier d'achat">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">FR <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/standard/72849.html">English</a></li><li><a href="/ru/standard/72849.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/news.html">Actualités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="72849 - ISO 125:2020 - Latex concentré de caoutchouc naturel — Détermination de l'alcalinité"></span>

  <span class="hidden" id="itemReference">ISO 125:2020</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">72849</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="Organisation internationale de normalisation">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/fr/standards-catalogue/browse-by-ics.html"title="Explorez la collection de normes ISO dans son intégralité et trouvez celles qui s’appliquent à votre secteur.">ICS</a> >&nbsp;<a href="/fr/ics/83.html">83</a> >&nbsp;<a href="/fr/ics/83.040.html">83.040</a> >&nbsp;<a href="/fr/ics/83.040.10.html">83.040.10</a></div>
  

  <h1>ISO 125:2020</h1>
  <h2 class="no-uppercase">Latex concentré de caoutchouc naturel — Détermination de l'alcalinité</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Acheter cette norme
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Résumé&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:72849:fr">Prévisualiser</a></h3>
          <div itemprop="description">
            <p><p>Le présent document spécifie une méthode de détermination de l'alcalinité du latex concentré de caoutchouc naturel.</p>
<p>La méthode ne convient pas nécessairement aux latex d'origine naturelle autres que l'<i>Hevea brasiliensis</i> ou aux latex de caoutchouc de synthèse, aux latex formulés, aux latex vulcanisés ou aux dispersions artificielles de caoutchouc.</p>
<p>NOTE       Une méthode de détermination de l'alcalinité du latex de polychloroprène est spécifiée dans l'ISO 13773.</p></p>
          </div>
          <br/>
        <h3>
  Informations générales
  <sup><a href="/fr/contents/data/standard/07/28/72849.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="S'abonner&nbsp;aux&nbsp;mises&nbsp;à&nbsp;jour">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>État actuel&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Publiée"></span>Publiée</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Date de publication&nbsp;: </strong><span itemprop="releaseDate">2020-02</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 7
      </div>
      <div class="col-sm-6">
        
          <strong>Nombre de pages&nbsp;:</strong> 7
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Comité technique</div> :
        <div class="entry-name entry-block">
          <a href="/fr/committee/48716.html">ISO/TC 45/SC 3</a>
        </div>
        <div class="entry-title">Matières premières (y compris le latex) à l'usage de l'industrie des élastomères</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/fr/ics/83.040.10.html">
                83.040.10
            </a>
          </div>
          <div class="entry-title">Latex et caoutchouc brut</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/fr/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Objectifs de développement durable" />
      </p>
      <p>
        Cette norme contribue aux  <a href="/fr/sdgs.html">Objectifs de développement durable</a>&nbsp;suivants&nbsp;:
      <p>
      <div class="clearfix">
        
          <a href="/fr/sdg/SDG12.html" title="Consommation et production responsables">
            <div class="sdg sdg-sm sdg-12">
              <div class="sdg-icon"></div>
              <div class="sdg-label">12</div>
              <div class="sdg-text">Consommation et production responsables</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
          <a href="/fr/sdg/SDG09.html" title="Industrie, innovation et infrastructure">
            <div class="sdg sdg-sm sdg-09">
              <div class="sdg-icon"></div>
              <div class="sdg-label">9</div>
              <div class="sdg-text">Industrie, innovation et infrastructure</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Acheter&nbsp;cette norme</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">fr</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Langue</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF + ePub
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dWmQAI~a0c0X00000OsDjTQAV" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2RAAW~a0f0X00000e1dXVQAY~a0c0X00000OsDkCQAV" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">58</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Papier
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFl7AAE~a0c0X00000OqPNqQAN" lang="en">
                      Anglais
                    </option>
                  
                    <option value="01ub000000285NhAAI~a05b0000005WV2WAAW~a0fb0000000eFnMAAU~a0c0X00000OqPObQAN" lang="fr" selected>
                      Français
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">58</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'fr', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Acheter
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Valider mon panier"></span>
            <span id="continueShopping" class="hidden" data-label="Ajouter au panier et continuer mes achats"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Cycle de vie</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Précédemment</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Annulée</div>
                    <h5><a href="/fr/standard/59265.html">ISO 125:2011</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Actuellement</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Publiée</div>
                    
              <h5>ISO 125:2020</h5>
                  
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stade: <strong>60.60</strong><span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Préliminaire</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposition</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2016-12-06</span>
                              <div class="stage-title">
                                Nouveau projet approuvé
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Préparation</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Comité</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">2017-03-06</span>
                              <div class="stage-title">
                                Projet de comité (CD) enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">2017-03-07</span>
                              <div class="stage-title">
                                Mise à l'étude/au vote du CD
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_60">
                              <span class="stage-code">30.60</span>
                              <span class="stage-date">2017-06-08</span>
                              <div class="stage-title">
                                Clôture du vote/ de la période des observations
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2018-12-03</span>
                              <div class="stage-title">
                                CD approuvé pour enregistrement comme DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquête</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2018-12-04</span>
                              <div class="stage-title">
                                DIS enregistré
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2019-02-05</span>
                              <div class="stage-title">
                                Mise au vote du DIS:  12 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2019-05-01</span>
                              <div class="stage-title">
                                Clôture du vote
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Rapport complet diffusé: DIS approuvé pour enregistrement comme FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approbation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2019-11-06</span>
                              <div class="stage-title">
                                Texte final reçu ou FDIS enregistré pour approbation formelle
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2019-12-10</span>
                              <div class="stage-title">
                                Epreuve envoyée au secrétariat ou mise au vote du FDIS: 8 semaines
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                Clôture du vote Epreuve retournée par le secrétariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2020-01-07</span>
                              <div class="stage-title">
                                Norme internationale en cours de publication
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/fr/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2020-02-19</span>
                              <div class="stage-title">
                                Norme internationale publiée
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Examen</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/fr/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Norme internationale en cours d'examen systématique
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Norme internationale à réviser
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Norme internationale confirmée
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/fr/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Annulation de la Norme internationale proposée par le TC ou SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Annulation</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/fr/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Annulation de la Norme internationale
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Vous avez une question?</h4>

<p>Consulter notre&nbsp;<a href="/fr/frequently-asked-questions-faqs.html" title="Foire Aux Questions (FAQs)">FAQ</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Service &agrave; la client&egrave;le</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Horaires d&rsquo;ouverture:<br />
De lundi &agrave; vendredi - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Suivez l&#39;actualit&eacute; de l&#39;ISO</h4>

<p>Inscrivez-vous &agrave; notre Newsletter (en anglais) pour suivre nos actualit&eacute;s, points de vue et informations sur nos produits.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/fr/home.html" title="Page d'accueil"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/fr/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a>

        </li>
      
        <li>
          
              <a href="/fr/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/fr/ics/83.html">83</a></li>
    
      <li><a href="/fr/ics/83.040.html">83.040</a></li>
    
      <li><a href="/fr/ics/83.040.10.html">83.040.10</a></li>
    <li>ISO 125:2020</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Plan du site</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/fr/standards.html">Normes</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/benefits-of-standards.html">Avantages</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/popular-standards.html">Les normes les plus connues</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/conformity-assessment.html">Certification & conformité</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/sdgs.html">ODD</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/about-us.html">À propos de l'ISO</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/what-we-do.html">Nos activités</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/members.html">Membres</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/strategy2030.html">Stratégie 2030</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/news.html">Actualités</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/fr/events.html">Manifestations</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/media-kit.html">Dossier médias</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/fr/developing-standards.html">Participer</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/who-develops-standards.html">Qui élabore les normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/deliverables-all.html">Livrables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/get-involved.html">Pourquoi s’engager ?</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/ClimateAction.html">Kit d’action pour le climat</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/resources.html">Ressources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/fr/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/fr/standards-catalogue/browse-by-ics.html" >Catalogue de normes</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/publication-list.html">Publications et produits</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/fr/iso-name-and-logo.html">Nom et logo de l'ISO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/privacy-and-copyright.html">Confidentialité et droit d'auteur</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/working-with-iso.html" >Emploi</a></li><li role="none" class="noChildren"><a role="menuitem" href="/fr/frequently-asked-questions-faqs.html">FAQ</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/fr/contact-iso.html">Contacter l'ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Le monde va loin quand il s'accorde</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">Nous nous engageons à ce que notre site Web soit accessible à tous. Pour toute question ou suggestion concernant l'accessibilité du site, <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contactez-nous</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© Tous droits réservés</a> <span id="copyright" class="collapse">Le matériel publié sur ISO.org est sujet aux mêmes conditions en matière de droits d’auteur que les publications de l’ISO et son emploi est conditionné par l’acceptation, par l’utilisateur, des conditions de l’ISO en matière de droits d’auteur régissant les publications de l’ISO. Toute utilisation du matériel concerné, y compris sa reproduction intégrale ou partielle vers un autre site Internet, requiert l’autorisation écrite de l’ISO. Toute demande à cet effet doit être adressée à <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Retour en haut de page"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="Logo ISO pour impression" /></div>
            <div class="poweredby-txt">Développé par</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
391
196
  http_version:
392
- recorded_at: Mon, 17 Jan 2022 09:57:04 GMT
197
+ recorded_at: Sat, 22 Jan 2022 10:39:28 GMT
393
198
  recorded_with: VCR 5.0.0