PK U*MdMv v lib_i2c/CHANGELOG.rstI2C library change log
======================
5.0.0
-----
* CHANGE: i2c_master_single_port no longer supported on XS1.
* CHANGE: Removed the start_read_request() and start_write_request() functions
from the i2c_slave_callback_if.
* CHANGE: Removed the start_master_read() and start_master_write() functions
from the i2c_slave_callback_if.
* RESOLVED: Fixed timing of i2c master (both single port and multi-port).
* RESOLVED: Fixed bug with the master not coping with clock stretching on
start bits.
4.0.2
-----
* RESOLVED: Make use of Wavedrom in documentation generation offline (fixes
automated build due to a known Wavevedrom issue where it would generate zero
size PNG)
4.0.1
-----
* RESOLVED: Suppressed warning "argument 1 of 'i2c_master_async_aux' slices
interface preventing analysis of its parallel usage".
4.0.0
-----
* CHANGE: Register read/write functions are now all MSB first
* RESOLVED: i2c slave working properly (versions pre 4.0.0 not suitable for
i2c slave)
* RESOLVED: Fixed byte ordering of write_reg16_addr8()
* RESOLVED: Fixed master transmitting on multi-bit port
3.1.6
-----
* CHANGE: Change title to remove special characters
3.1.5
-----
* CHANGE: Update app notes
3.1.4
-----
* CHANGE: Remove invalid app notes
3.1.3
-----
* CHANGE: Update to source code license and copyright
3.1.2
-----
* RESOLVED: Fix incorrect reading of r/w bit in slave component
3.1.1
-----
* CHANGE: Minor user guide updates
3.1.0
-----
* ADDED: Add support for reading on i2c_master_single-port for xCORE-200
series.
* CHANGE: Document reg_read functions more clearly with respect to stop bit
behavior.
3.0.0
-----
* CHANGE: Consolidated version, major rework from previous I2C components.
* Changes to dependencies:
- lib_logging: Added dependency 2.0.0
- lib_xassert: Added dependency 2.0.0
PK U*MM^C* C* lib_i2c/LICENSE.txtSoftware Release License Agreement
Copyright (c) 2011-2018, XMOS, All rights reserved.
BY ACCESSING, USING, INSTALLING OR DOWNLOADING THE XMOS SOFTWARE, YOU AGREE TO BE BOUND BY THE FOLLOWING TERMS. IF YOU DO NOT AGREE TO THESE, DO NOT ATTEMPT TO DOWNLOAD, ACCESS OR USE THE XMOS Software.
Parties:
(1) XMOS Limited, incorporated and registered in England and Wales with company number 5494985 whose registered office is 107 Cheapside, London, EC2V 6DN (XMOS).
(2) An individual or legal entity exercising permissions granted by this License (Customer).
If you are entering into this Agreement on behalf of another legal entity such as a company, partnership, university, college etc. (for example, as an employee, student or consultant), you warrant that you have authority to bind that entity.
1. Definitions
"License" means this Software License and any schedules or annexes to it.
"License Fee" means the fee for the XMOS Software as detailed in any schedules or annexes to this Software License
"Licensee Modifications" means all developments and modifications of the XMOS Software developed independently by the Customer.
"XMOS Modifications" means all developments and modifications of the XMOS Software developed or co-developed by XMOS.
"XMOS Hardware" means any XMOS hardware devices supplied by XMOS from time to time and/or the particular XMOS devices detailed in any schedules or annexes to this Software License.
"XMOS Software" comprises the XMOS owned circuit designs, schematics, source code, object code, reference designs, (including related programmer comments and documentation, if any), error corrections, improvements, modifications (including XMOS Modifications) and updates.
The headings in this License do not affect its interpretation. Save where the context otherwise requires, references to clauses and schedules are to clauses and schedules of this License.
Unless the context otherwise requires:
- references to XMOS and the Customer include their permitted successors and assigns;
- references to statutory provisions include those statutory provisions as amended or re-enacted; and
- references to any gender include all genders.
Words in the singular include the plural and in the plural include the singular.
2. License
XMOS grants the Customer a non-exclusive license to use, develop, modify and distribute the XMOS Software with, or for the purpose of being used with, XMOS Hardware.
Open Source Software (OSS) must be used and dealt with in accordance with any license terms under which OSS is distributed.
3. Consideration
In consideration of the mutual obligations contained in this License, the parties agree to its terms.
4. Term
Subject to clause 12 below, this License shall be perpetual.
5. Restrictions on Use
The Customer will adhere to all applicable import and export laws and regulations of the country in which it resides and of the United States and United Kingdom, without limitation. The Customer agrees that it is its responsibility to obtain copies of and to familiarise itself fully with these laws and regulations to avoid violation.
6. Modifications
The Customer will own all intellectual property rights in the Licensee Modifications but will undertake to provide XMOS with any fixes made to correct any bugs found in the XMOS Software on a non-exclusive, perpetual and royalty free license basis.
XMOS will own all intellectual property rights in the XMOS Modifications.
The Customer may only use the Licensee Modifications and XMOS Modifications on, or in relation to, XMOS Hardware.
7. Support
Support of the XMOS Software may be provided by XMOS pursuant to a separate support agreement.
8. Warranty and Disclaimer
The XMOS Software is provided "AS IS" without a warranty of any kind. XMOS and its licensors' entire liability and Customer's exclusive remedy under this warranty to be determined in XMOS's sole and absolute discretion, will be either (a) the corrections of defects in media or replacement of the media, or (b) the refund of the license fee paid (if any).
Whilst XMOS gives the Customer the ability to load their own software and applications onto XMOS devices, the security of such software and applications when on the XMOS devices is the Customer's own responsibility and any breach of security shall not be deemed a defect or failure of the hardware. XMOS shall have no liability whatsoever in relation to any costs, damages or other losses Customer may incur as a result of any breaches of security in relation to your software or applications.
XMOS AND ITS LICENSORS DISCLAIM ALL OTHER WARRANTIES, EXPRESS OR IMPLIED, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY/ SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT EXCEPT TO THE EXTENT THAT THESE DISCLAIMERS ARE HELD TO BE LEGALLY INVALID UNDER APPLICABLE LAW.
9. High Risk Activities
The XMOS Software is not designed or intended for use in conjunction with on-line control equipment in hazardous environments requiring fail-safe performance, including without limitation the operation of nuclear facilities, aircraft navigation or communication systems, air traffic control, life support machines, or weapons systems (collectively "High Risk Activities") in which the failure of the XMOS Software could lead directly to death, personal injury, or severe physical or environmental damage. XMOS and its licensors specifically disclaim any express or implied warranties relating to use of the XMOS Software in connection with High Risk Activities.
10. Liability
TO THE EXTENT NOT PROHIBITED BY APPLICABLE LAW, NEITHER XMOS NOR ITS LICENSORS SHALL BE LIABLE FOR ANY LOST REVENUE, BUSINESS, PROFIT, CONTRACTS OR DATA, ADMINISTRATIVE OR OVERHEAD EXPENSES, OR FOR SPECIAL, INDIRECT, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES HOWEVER CAUSED AND REGARDLESS OF THEORY OF LIABILITY ARISING OUT OF THIS LICENSE, EVEN IF XMOS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. In no event shall XMOS's liability to the Customer whether in contract, tort (including negligence), or otherwise exceed the License Fee.
Customer agrees to indemnify, hold harmless, and defend XMOS and its licensors from and against any claims or lawsuits, including attorneys' fees and any other liabilities, demands, proceedings, damages, losses, costs, expenses fines and charges which are made or brought against or incurred by XMOS as a result of your use or distribution of the Licensee Modifications or your use or distribution of XMOS Software, or any development of it, other than in accordance with the terms of this License.
11. Ownership
The copyrights and all other intellectual and industrial property rights for the protection of information with respect to the XMOS Software (including the methods and techniques on which they are based) are retained by XMOS and/or its licensors. Nothing in this Agreement serves to transfer such rights. Customer may not sell, mortgage, underlet, sublease, sublicense, lend or transfer possession of the XMOS Software in any way whatsoever to any third party who is not bound by this Agreement.
12. Termination
Either party may terminate this License at any time on written notice to the other if the other:
- is in material or persistent breach of any of the terms of this License and either that breach is incapable of remedy, or the other party fails to remedy that breach within 30 days after receiving written notice requiring it to remedy that breach; or
- is unable to pay its debts (within the meaning of section 123 of the Insolvency Act 1986), or becomes insolvent, or is subject to an order or a resolution for its liquidation, administration, winding-up or dissolution (otherwise than for the purposes of a solvent amalgamation or reconstruction), or has an administrative or other receiver, manager, trustee, liquidator, administrator or similar officer appointed over all or any substantial part of its assets, or enters into or proposes any composition or arrangement with its creditors generally, or is subject to any analogous event or proceeding in any applicable jurisdiction.
Termination by either party in accordance with the rights contained in clause 12 shall be without prejudice to any other rights or remedies of that party accrued prior to termination.
On termination for any reason:
- all rights granted to the Customer under this License shall cease;
- the Customer shall cease all activities authorised by this License;
- the Customer shall immediately pay any sums due to XMOS under this License; and
- the Customer shall immediately destroy or return to the XMOS (at the XMOS's option) all copies of the XMOS Software then in its possession, custody or control and, in the case of destruction, certify to XMOS that it has done so.
Clauses 5, 8, 9, 10 and 11 shall survive any effective termination of this Agreement.
13. Third party rights
No term of this License is intended to confer a benefit on, or to be enforceable by, any person who is not a party to this license.
14. Confidentiality and publicity
Each party shall, during the term of this License and thereafter, keep confidential all, and shall not use for its own purposes nor without the prior written consent of the other disclose to any third party any, information of a confidential nature (including, without limitation, trade secrets and information of commercial value) which may become known to such party from the other party and which relates to the other party, unless such information is public knowledge or already known to such party at the time of disclosure, or subsequently becomes public knowledge other than by breach of this license, or subsequently comes lawfully into the possession of such party from a third party.
The terms of this license are confidential and may not be disclosed by the Customer without the prior written consent of XMOS.
The provisions of clause 14 shall remain in full force and effect notwithstanding termination of this license for any reason.
15. Entire agreement
This License and the documents annexed as appendices to this License or otherwise referred to herein contain the whole agreement between the parties relating to the subject matter hereof and supersede all prior agreements, arrangements and understandings between the parties relating to that subject matter.
16. Assignment
The Customer shall not assign this License or any of the rights granted under it without XMOS's prior written consent.
17. Governing law and jurisdiction
This License shall be governed by and construed in accordance with English law and each party hereby submits to the non-exclusive jurisdiction of the English courts.
This License has been entered into on the date stated at the beginning of it.
Schedule
XMOS I2C Library software
PK U*Mguk
lib_i2c/README.rst.. |I2C| replace:: I\ :sup:`2`\ C
I2C Library
===========
Summary
-------
A software defined, industry-standard, |I2C| library
that allows you to control an |I2C| bus via xCORE ports.
|I2C| is a two-wire hardware serial
interface, first developed by Philips. The components in the libary
are controlled via C using the XMOS multicore extensions (xC) and
can either act as |I2C| master or slave.
The libary is compatible with multiple slave devices existing on the same
bus. The |I2C| master component can be used by multiple tasks within
the xCORE device (each addressing the same or different slave devices).
The library can also be used to implement multiple |I2C| physical interfaces
on a single xCORE device simultaneously.
Features
........
* |I2C| master and |I2C| slave modes.
* Supports speed up to 400 Kb/s (|I2C| Fast-mode).
* Clock stretching support.
* Synchronous and asynchronous APIs for efficient usage of processing cores.
Typical Resource Usage
......................
.. resusage::
* - configuration: Master
- globals: port p_scl = XS1_PORT_1A; port p_sda = XS1_PORT_1B;
- locals: interface i2c_master_if i[1];
- fn: i2c_master(i, 1, p_scl, p_sda, 100);
- pins: 2
- ports: 2 (1-bit)
* - configuration: Master (single port)
- globals: port p = XS1_PORT_4A;
- locals: interface i2c_master_if i[1];
- fn: i2c_master_single_port(i, 1, p, 100, 0, 0, 0);
- pins: 2
- ports: 1 (multi-bit)
- target: XCORE-200-EXPLORER
* - configuration: Master (asynchronous)
- globals: port p_scl = XS1_PORT_1A; port p_sda = XS1_PORT_1B;
- locals: interface i2c_master_async_if i[1];
- fn: i2c_master_async(i, 1, p_scl, p_sda, 100, 20);
- pins: 2
- ports: 2 (1-bit)
* - configuration: Master (asynchronous, combinable)
- globals: port p_scl = XS1_PORT_1A; port p_sda = XS1_PORT_1B;
- locals: interface i2c_master_async_if i[1];
- fn: i2c_master_async_comb(i, 1, p_scl, p_sda, 100, 20);
- pins: 2
- ports: 2 (1-bit)
* - configuration: Slave
- globals: port p_scl = XS1_PORT_1A; port p_sda = XS1_PORT_1B;
- locals: interface i2c_slave_callback_if i;
- fn: i2c_slave(i, p_scl, p_sda, 0);
- pins: 2
- ports: 2 (1-bit)
Software version and dependencies
.................................
.. libdeps::
Related application notes
.........................
The following application notes use this library:
* AN00156: How to use the I2C master library
* AN00157: How to use the I2C slave library
* AN00181: xCORE-200 explorer accelerometer demo
PK U*Mɱ lib_i2c/lib_i2c/.project
lib_i2ccom.xmos.cdt.core.LegacyProjectCheckerBuildercom.xmos.cdt.core.ProjectCheckerBuildercom.xmos.cdt.core.BuildMarkersBuildercom.xmos.cdt.core.ProjectInfoSyncBuildercom.xmos.cdt.core.IncludePathBuildercom.xmos.cdt.core.ModulePathBuilderorg.eclipse.cdt.managedbuilder.core.genmakebuilderclean,full,incremental,?children??name?=outputEntries\|?children?=?name?=entry\\\\|\\|\||?name?org.eclipse.cdt.make.core.append_environmenttrueorg.eclipse.cdt.make.core.buildArgumentsCONFIG=Debugorg.eclipse.cdt.make.core.buildCommandxmakeorg.eclipse.cdt.make.core.cleanBuildTargetcleanorg.eclipse.cdt.make.core.contentsorg.eclipse.cdt.make.core.activeConfigSettingsorg.eclipse.cdt.make.core.enableAutoBuildfalseorg.eclipse.cdt.make.core.enableCleanBuildtrueorg.eclipse.cdt.make.core.enableFullBuildtrueorg.eclipse.cdt.make.core.stopOnErrortrueorg.eclipse.cdt.make.core.useDefaultBuildCmdfalseorg.eclipse.cdt.managedbuilder.core.ScannerConfigBuilderfull,incremental,org.eclipse.cdt.core.cnatureorg.eclipse.cdt.managedbuilder.core.managedBuildNatureorg.eclipse.cdt.managedbuilder.core.ScannerConfigNaturecom.xmos.cdt.core.XdeProjectNature
PK U*M.C* C* lib_i2c/lib_i2c/LICENSE.txtSoftware Release License Agreement
Copyright (c) 2014-2018, XMOS, All rights reserved.
BY ACCESSING, USING, INSTALLING OR DOWNLOADING THE XMOS SOFTWARE, YOU AGREE TO BE BOUND BY THE FOLLOWING TERMS. IF YOU DO NOT AGREE TO THESE, DO NOT ATTEMPT TO DOWNLOAD, ACCESS OR USE THE XMOS Software.
Parties:
(1) XMOS Limited, incorporated and registered in England and Wales with company number 5494985 whose registered office is 107 Cheapside, London, EC2V 6DN (XMOS).
(2) An individual or legal entity exercising permissions granted by this License (Customer).
If you are entering into this Agreement on behalf of another legal entity such as a company, partnership, university, college etc. (for example, as an employee, student or consultant), you warrant that you have authority to bind that entity.
1. Definitions
"License" means this Software License and any schedules or annexes to it.
"License Fee" means the fee for the XMOS Software as detailed in any schedules or annexes to this Software License
"Licensee Modifications" means all developments and modifications of the XMOS Software developed independently by the Customer.
"XMOS Modifications" means all developments and modifications of the XMOS Software developed or co-developed by XMOS.
"XMOS Hardware" means any XMOS hardware devices supplied by XMOS from time to time and/or the particular XMOS devices detailed in any schedules or annexes to this Software License.
"XMOS Software" comprises the XMOS owned circuit designs, schematics, source code, object code, reference designs, (including related programmer comments and documentation, if any), error corrections, improvements, modifications (including XMOS Modifications) and updates.
The headings in this License do not affect its interpretation. Save where the context otherwise requires, references to clauses and schedules are to clauses and schedules of this License.
Unless the context otherwise requires:
- references to XMOS and the Customer include their permitted successors and assigns;
- references to statutory provisions include those statutory provisions as amended or re-enacted; and
- references to any gender include all genders.
Words in the singular include the plural and in the plural include the singular.
2. License
XMOS grants the Customer a non-exclusive license to use, develop, modify and distribute the XMOS Software with, or for the purpose of being used with, XMOS Hardware.
Open Source Software (OSS) must be used and dealt with in accordance with any license terms under which OSS is distributed.
3. Consideration
In consideration of the mutual obligations contained in this License, the parties agree to its terms.
4. Term
Subject to clause 12 below, this License shall be perpetual.
5. Restrictions on Use
The Customer will adhere to all applicable import and export laws and regulations of the country in which it resides and of the United States and United Kingdom, without limitation. The Customer agrees that it is its responsibility to obtain copies of and to familiarise itself fully with these laws and regulations to avoid violation.
6. Modifications
The Customer will own all intellectual property rights in the Licensee Modifications but will undertake to provide XMOS with any fixes made to correct any bugs found in the XMOS Software on a non-exclusive, perpetual and royalty free license basis.
XMOS will own all intellectual property rights in the XMOS Modifications.
The Customer may only use the Licensee Modifications and XMOS Modifications on, or in relation to, XMOS Hardware.
7. Support
Support of the XMOS Software may be provided by XMOS pursuant to a separate support agreement.
8. Warranty and Disclaimer
The XMOS Software is provided "AS IS" without a warranty of any kind. XMOS and its licensors' entire liability and Customer's exclusive remedy under this warranty to be determined in XMOS's sole and absolute discretion, will be either (a) the corrections of defects in media or replacement of the media, or (b) the refund of the license fee paid (if any).
Whilst XMOS gives the Customer the ability to load their own software and applications onto XMOS devices, the security of such software and applications when on the XMOS devices is the Customer's own responsibility and any breach of security shall not be deemed a defect or failure of the hardware. XMOS shall have no liability whatsoever in relation to any costs, damages or other losses Customer may incur as a result of any breaches of security in relation to your software or applications.
XMOS AND ITS LICENSORS DISCLAIM ALL OTHER WARRANTIES, EXPRESS OR IMPLIED, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY/ SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT EXCEPT TO THE EXTENT THAT THESE DISCLAIMERS ARE HELD TO BE LEGALLY INVALID UNDER APPLICABLE LAW.
9. High Risk Activities
The XMOS Software is not designed or intended for use in conjunction with on-line control equipment in hazardous environments requiring fail-safe performance, including without limitation the operation of nuclear facilities, aircraft navigation or communication systems, air traffic control, life support machines, or weapons systems (collectively "High Risk Activities") in which the failure of the XMOS Software could lead directly to death, personal injury, or severe physical or environmental damage. XMOS and its licensors specifically disclaim any express or implied warranties relating to use of the XMOS Software in connection with High Risk Activities.
10. Liability
TO THE EXTENT NOT PROHIBITED BY APPLICABLE LAW, NEITHER XMOS NOR ITS LICENSORS SHALL BE LIABLE FOR ANY LOST REVENUE, BUSINESS, PROFIT, CONTRACTS OR DATA, ADMINISTRATIVE OR OVERHEAD EXPENSES, OR FOR SPECIAL, INDIRECT, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES HOWEVER CAUSED AND REGARDLESS OF THEORY OF LIABILITY ARISING OUT OF THIS LICENSE, EVEN IF XMOS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. In no event shall XMOS's liability to the Customer whether in contract, tort (including negligence), or otherwise exceed the License Fee.
Customer agrees to indemnify, hold harmless, and defend XMOS and its licensors from and against any claims or lawsuits, including attorneys' fees and any other liabilities, demands, proceedings, damages, losses, costs, expenses fines and charges which are made or brought against or incurred by XMOS as a result of your use or distribution of the Licensee Modifications or your use or distribution of XMOS Software, or any development of it, other than in accordance with the terms of this License.
11. Ownership
The copyrights and all other intellectual and industrial property rights for the protection of information with respect to the XMOS Software (including the methods and techniques on which they are based) are retained by XMOS and/or its licensors. Nothing in this Agreement serves to transfer such rights. Customer may not sell, mortgage, underlet, sublease, sublicense, lend or transfer possession of the XMOS Software in any way whatsoever to any third party who is not bound by this Agreement.
12. Termination
Either party may terminate this License at any time on written notice to the other if the other:
- is in material or persistent breach of any of the terms of this License and either that breach is incapable of remedy, or the other party fails to remedy that breach within 30 days after receiving written notice requiring it to remedy that breach; or
- is unable to pay its debts (within the meaning of section 123 of the Insolvency Act 1986), or becomes insolvent, or is subject to an order or a resolution for its liquidation, administration, winding-up or dissolution (otherwise than for the purposes of a solvent amalgamation or reconstruction), or has an administrative or other receiver, manager, trustee, liquidator, administrator or similar officer appointed over all or any substantial part of its assets, or enters into or proposes any composition or arrangement with its creditors generally, or is subject to any analogous event or proceeding in any applicable jurisdiction.
Termination by either party in accordance with the rights contained in clause 12 shall be without prejudice to any other rights or remedies of that party accrued prior to termination.
On termination for any reason:
- all rights granted to the Customer under this License shall cease;
- the Customer shall cease all activities authorised by this License;
- the Customer shall immediately pay any sums due to XMOS under this License; and
- the Customer shall immediately destroy or return to the XMOS (at the XMOS's option) all copies of the XMOS Software then in its possession, custody or control and, in the case of destruction, certify to XMOS that it has done so.
Clauses 5, 8, 9, 10 and 11 shall survive any effective termination of this Agreement.
13. Third party rights
No term of this License is intended to confer a benefit on, or to be enforceable by, any person who is not a party to this license.
14. Confidentiality and publicity
Each party shall, during the term of this License and thereafter, keep confidential all, and shall not use for its own purposes nor without the prior written consent of the other disclose to any third party any, information of a confidential nature (including, without limitation, trade secrets and information of commercial value) which may become known to such party from the other party and which relates to the other party, unless such information is public knowledge or already known to such party at the time of disclosure, or subsequently becomes public knowledge other than by breach of this license, or subsequently comes lawfully into the possession of such party from a third party.
The terms of this license are confidential and may not be disclosed by the Customer without the prior written consent of XMOS.
The provisions of clause 14 shall remain in full force and effect notwithstanding termination of this license for any reason.
15. Entire agreement
This License and the documents annexed as appendices to this License or otherwise referred to herein contain the whole agreement between the parties relating to the subject matter hereof and supersede all prior agreements, arrangements and understandings between the parties relating to that subject matter.
16. Assignment
The Customer shall not assign this License or any of the rights granted under it without XMOS's prior written consent.
17. Governing law and jurisdiction
This License shall be governed by and construed in accordance with English law and each party hereby submits to the non-exclusive jurisdiction of the English courts.
This License has been entered into on the date stated at the beginning of it.
Schedule
XMOS I2C Library software
PK U*MG+u u ! lib_i2c/lib_i2c/module_build_infoMODULE_XCC_FLAGS = $(XCC_FLAGS) -Os
VERSION = 5.0.0
DEPENDENT_MODULES = lib_xassert(>=3.0.0) lib_logging(>=2.1.0)
PK U*Mv lib_i2c/lib_i2c/wscriptdef use_module(bld):
sources = bld.path.ant_glob('src/**/*.xc')
bld.env.MODULE_XCC_FLAGS = bld.env.XCC_FLAGS + ['-Os']
bld.module(
source=sources,
includes=['api'],
depends_on=['lib_xassert(>=3.0.0)', 'lib_logging(>=2.1.0)'],
version='4.0.2')
PK U*M]# # lib_i2c/lib_i2c/.cproject
PK U*M
~ lib_i2c/lib_i2c/.makefileall:
@echo "** Module only - only builds as part of application **"
clean:
@echo "** Module only - only builds as part of application **"
PK U*MtZW%v v lib_i2c/lib_i2c/.xproject
lib_i2c5.0.0PK U*MTg g lib_i2c/lib_i2c/api/i2c.h// Copyright (c) 2014-2018, XMOS Ltd, All rights reserved
#ifndef _i2c_h_
#define _i2c_h_
#include
#include
/** This type is used in I2C functions to report back on whether the
* slave performed an ACK or NACK on the last piece of data sent
* to it.
*/
typedef enum {
I2C_NACK, ///< the slave has NACKed the last byte
I2C_ACK, ///< the slave has ACKed the last byte
} i2c_res_t;
#ifdef __XC__
#define BIT_TIME(KBITS_PER_SEC) ((XS1_TIMER_MHZ * 1000) / KBITS_PER_SEC)
#define BIT_MASK(BIT_POS) (1 << BIT_POS)
/** This interface is used to communication with an I2C master component.
* It provides facilities for reading and writing to the bus.
*
*/
typedef interface i2c_master_if {
/** Write data to an I2C bus.
*
* \param device_addr the address of the slave device to write to.
* \param buf the buffer containing data to write.
* \param n the number of bytes to write.
* \param num_bytes_sent the function will set this value to the
* number of bytes actually sent. On success, this
* will be equal to ``n`` but it will be less if the
* slave sends an early NACK on the bus and the
* transaction fails.
* \param send_stop_bit if this is non-zero then a stop bit
* will be sent on the bus after the transaction.
* This is usually required for normal operation. If
* this parameter is zero then no stop bit will
* be omitted. In this case, no other task can use
* the component until a stop bit has been sent.
*
* \returns ``I2C_ACK`` if the write was acknowledged by the slave
* device, otherwise ``I2C_NACK``.
*/
[[guarded]]
i2c_res_t write(uint8_t device_addr, uint8_t buf[n], size_t n,
size_t &num_bytes_sent, int send_stop_bit);
/** Read data from an I2C bus.
*
* \param device_addr the address of the slave device to read from
* \param buf the buffer to fill with data
* \param n the number of bytes to read
* \param send_stop_bit if this is non-zero then a stop bit
* will be sent on the bus after the transaction.
* This is usually required for normal operation. If
* this parameter is zero then no stop bit will
* be omitted. In this case, no other task can use
* the component until a stop bit has been sent.
*
* \returns ``I2C_ACK`` if the read was acknowledged by the slave
* device, otherwise ``I2C_NACK``.
*/
[[guarded]]
i2c_res_t read(uint8_t device_addr, uint8_t buf[n], size_t n,
int send_stop_bit);
/** Send a stop bit.
*
* This function will cause a stop bit to be sent on the bus. It should
* be used to complete/abort a transaction if the ``send_stop_bit`` argument
* was not set when calling the read() or write() functions.
*/
void send_stop_bit(void);
/** Shutdown the I2C component.
*
* This function will cause the I2C task to shutdown and return.
*/
void shutdown();
} i2c_master_if;
/** This type is used by the supplementary I2C register read/write functions to
* report back on whether the operation was a success or not.
*/
typedef enum {
I2C_REGOP_SUCCESS, ///< the operation was successful
I2C_REGOP_DEVICE_NACK, ///< the operation was NACKed when sending the device address, so either the device is missing or busy
I2C_REGOP_INCOMPLETE ///< the operation was NACKed halfway through by the slave
} i2c_regop_res_t;
extends client interface i2c_master_if : {
/** Read an 8-bit register on a slave device.
*
* This function reads an 8-bit addressed, 8-bit register from the i2c
* bus. The function reads data by
* transmitting the register addr and then reading the data from the slave
* device.
*
* Note that no stop bit is transmitted between the write and the read.
* The operation is performed as one transaction using a repeated start.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to read from
* \param reg the address of the register to read
* \param result indicates whether the read completed successfully. Will
* be set to ``I2C_REGOP_DEVICE_NACK`` if the slave NACKed,
* and ``I2C_REGOP_SUCCESS`` on successful completion of the
* read.
*
* \returns the value of the register
*/
inline uint8_t read_reg(client interface i2c_master_if i,
uint8_t device_addr, uint8_t reg,
i2c_regop_res_t &result) {
uint8_t a_reg[1] = {reg};
uint8_t data[1] = {0};
size_t n;
i2c_res_t res;
res = i.write(device_addr, a_reg, 1, n, 0);
if (n != 1) {
result = I2C_REGOP_DEVICE_NACK;
i.send_stop_bit();
return 0;
}
res = i.read(device_addr, data, 1, 1);
if (res == I2C_ACK) {
result = I2C_REGOP_SUCCESS;
} else {
result = I2C_REGOP_DEVICE_NACK;
}
return data[0];
}
/** Write an 8-bit register on a slave device.
*
* This function writes an 8-bit addressed, 8-bit register from the i2c
* bus. The function writes data by
* transmitting the register addr and then
* transmitting the data to the slave device.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to write to
* \param reg the address of the register to write
* \param data the 8-bit value to write
*/
inline i2c_regop_res_t write_reg(client interface i2c_master_if i,
uint8_t device_addr, uint8_t reg, uint8_t data)
{
uint8_t a_data[2] = {reg, data};
size_t n;
i.write(device_addr, a_data, 2, n, 1);
if (n == 0) {
return I2C_REGOP_DEVICE_NACK;
}
if (n < 2) {
return I2C_REGOP_INCOMPLETE;
}
return I2C_REGOP_SUCCESS;
}
/** Read an 8-bit register on a slave device from a 16-bit register address.
*
* This function reads a 16-bit addressed, 8-bit register from the i2c
* bus. The function reads data by
* transmitting the register addr and then reading the data from the slave
* device.
*
* Note that no stop bit is transmitted between the write and the read.
* The operation is performed as one transaction using a repeated start.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to read from
* \param reg the 16-bit address of the register to read
* (most significant byte first)
* \param result indicates whether the read completed successfully. Will
* be set to ``I2C_REGOP_DEVICE_NACK`` if the slave NACKed,
* and ``I2C_REGOP_SUCCESS`` on successful completion of the
* read.
*
* \returns the value of the register
*/
inline uint8_t read_reg8_addr16(client interface i2c_master_if i,
uint8_t device_addr, uint16_t reg,
i2c_regop_res_t &result)
{
uint8_t a_reg[2] = {reg >> 8, reg};
uint8_t data[1];
size_t n;
i2c_res_t res;
i.write(device_addr, a_reg, 2, n, 0);
if (n != 2) {
result = I2C_REGOP_DEVICE_NACK;
i.send_stop_bit();
return 0;
}
res = i.read(device_addr, data, 1, 1);
if (res == I2C_NACK) {
result = I2C_REGOP_DEVICE_NACK;
} else {
result = I2C_REGOP_SUCCESS;
}
return data[0];
}
/** Write an 8-bit register on a slave device from a 16-bit register address.
*
* This function writes a 16-bit addressed, 8-bit register from the i2c
* bus. The function writes data by
* transmitting the register addr and then
* transmitting the data to the slave device.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to write to
* \param reg the 16-bit address of the register to write
* (most significant byte first)
* \param data the 8-bit value to write
*/
inline i2c_regop_res_t write_reg8_addr16(client interface i2c_master_if i,
uint8_t device_addr, uint16_t reg,
uint8_t data) {
uint8_t a_data[3] = {reg >> 8, reg, data};
size_t n;
i.write(device_addr, a_data, 3, n, 1);
if (n == 0) {
return I2C_REGOP_DEVICE_NACK;
}
if (n < 3) {
return I2C_REGOP_INCOMPLETE;
}
return I2C_REGOP_SUCCESS;
}
/** Read an 16-bit register on a slave device from a 16-bit register address.
*
* This function reads a 16-bit addressed, 16-bit register from the i2c
* bus. The function reads data by transmitting the register addr and then
* reading the data from the slave device. It is assumed the data is returned
* most significant byte first on the bus.
*
* Note that no stop bit is transmitted between the write and the read.
* The operation is performed as one transaction using a repeated start.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to read from
* \param reg the address of the register to read (most
* significant byte first)
* \param result indicates whether the read completed successfully. Will
* be set to ``I2C_REGOP_DEVICE_NACK`` if the slave NACKed,
* and ``I2C_REGOP_SUCCESS`` on successful completion of the
* read.
*
* \returns the 16-bit value of the register
*/
inline uint16_t read_reg16(client interface i2c_master_if i,
uint8_t device_addr, uint16_t reg,
i2c_regop_res_t &result)
{
uint8_t a_reg[2] = {reg >> 8, reg};
uint8_t data[2];
size_t n;
i2c_res_t res;
i.write(device_addr, a_reg, 2, n, 0);
if (n != 2) {
result = I2C_REGOP_DEVICE_NACK;
i.send_stop_bit();
return 0;
}
res = i.read(device_addr, data, 2, 1);
if (res == I2C_NACK) {
result = I2C_REGOP_DEVICE_NACK;
} else {
result = I2C_REGOP_SUCCESS;
}
return ((uint16_t) data[0] << 8) | data[1];
}
/** Write an 16-bit register on a slave device from a 16-bit register address.
*
* This function writes a 16-bit addressed, 16-bit register from the i2c
* bus. The function writes data by transmitting the register addr and then
* transmitting the data to the slave device.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to write to
* \param reg the 16-bit address of the register to write
* (most significant byte first)
* \param data the 16-bit value to write (most significant
* byte first)
*
* \returns ``I2C_REGOP_DEVICE_NACK`` if the address is NACKed,
* ``I2C_REGOP_INCOMPLETE`` if not all data was ACKed and
* ``I2C_REGOP_SUCCESS`` on successful completion of the
* write with every byte being ACKed.
*/
inline i2c_regop_res_t write_reg16(client interface i2c_master_if i,
uint8_t device_addr, uint16_t reg,
uint16_t data) {
uint8_t a_data[4] = {reg >> 8, reg, data >> 8, data};
size_t n;
i.write(device_addr, a_data, 4, n, 1);
if (n == 0) {
return I2C_REGOP_DEVICE_NACK;
}
if (n < 4) {
return I2C_REGOP_INCOMPLETE;
}
return I2C_REGOP_SUCCESS;
}
/** Read an 16-bit register on a slave device from a 8-bit register address.
*
* This function reads a 8-bit addressed, 16-bit register from the i2c
* bus. The function reads data by transmitting the register addr and
* then reading the data from the slave device. It is assumed that the data
* is return most significant byte first on the bus.
*
* Note that no stop bit is transmitted between the write and the read.
* The operation is performed as one transaction using a repeated start.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to read from
* \param reg the address of the register to read
* \param result indicates whether the read completed successfully. Will
* be set to ``I2C_REGOP_DEVICE_NACK`` if the slave NACKed,
* and ``I2C_REGOP_SUCCESS`` on successful completion of the
* read.
*
* \returns the 16-bit value of the register
*/
inline uint16_t read_reg16_addr8(client interface i2c_master_if i,
uint8_t device_addr, uint8_t reg,
i2c_regop_res_t &result)
{
uint8_t a_reg[1] = {reg};
uint8_t data[2];
size_t n;
i2c_res_t res;
i.write(device_addr, a_reg, 1, n, 0);
if (n != 1) {
result = I2C_REGOP_DEVICE_NACK;
i.send_stop_bit();
return 0;
}
res = i.read(device_addr, data, 2, 1);
if (res == I2C_NACK) {
result = I2C_REGOP_DEVICE_NACK;
} else {
result = I2C_REGOP_SUCCESS;
}
return ((uint16_t) data[0] << 8) | data[1];
}
/** Write an 16-bit register on a slave device from a 8-bit register address.
*
* This function writes a 8-bit addressed, 16-bit register from the i2c
* bus. The function writes data by transmitting the register addr and then
* transmitting the data to the slave device.
*
* \param i the interface to the I2C master
* \param device_addr the address of the slave device to write to
* \param reg the address of the register to write
* \param data the 16-bit value to write (most significant byte first)
*
* \returns ``I2C_REGOP_DEVICE_NACK`` if the address is NACKed,
* ``I2C_REGOP_INCOMPLETE`` if not all data was ACKed and
* ``I2C_REGOP_SUCCESS`` on successful completion of the
* write with every byte being ACKed.
*/
inline i2c_regop_res_t write_reg16_addr8(client interface i2c_master_if i,
uint8_t device_addr, uint8_t reg,
uint16_t data) {
uint8_t a_data[3] = {reg, data >> 8, data};
size_t n;
i.write(device_addr, a_data, 3, n, 1);
if (n == 0) {
return I2C_REGOP_DEVICE_NACK;
}
if (n < 3) {
return I2C_REGOP_INCOMPLETE;
}
return I2C_REGOP_SUCCESS;
}
}
/** Implements I2C on the i2c_master_if interface using two ports.
*
* \param i an array of server interface connections for clients
* to connect to
* \param n the number of clients connected
* \param p_scl the SCL port of the I2C bus
* \param p_sda the SDA port of the I2C bus
* \param kbits_per_second the speed of the I2C bus
**/
[[distributable]] void i2c_master(server interface i2c_master_if i[n],
size_t n,
port p_scl, port p_sda,
static const unsigned kbits_per_second);
#if defined(__XS2A__) || defined(__DOXYGEN__)
/** Implements I2C on a single multi-bit port.
*
* This function implements an I2C master bus using a single port. It is only
* supported on xCORE-200 devices.
*
* \param c an array of server interface connections for clients
* to connect to
* \param n the number of clients connected
* \param p_i2c the multi-bit port containing both SCL and SDA.
* the bit positions of SDA and SCL are configured using the
* ``sda_bit_position`` and ``scl_bit_position`` arguments.
* \param kbits_per_second the speed of the I2C bus
* \param sda_bit_position the bit of the SDA line on the port
* \param scl_bit_position the bit of the SCL line on the port
* \param other_bits_mask a value that is ORed into the port value driven
* to ``p_i2c``. The SDA and SCL bit values for this
* variable must be set to 0. Note that ``p_i2c`` is
* configured with set_port_drive_low() and
* therefore external pullup resistors are required
* to produce a value 1 on a bit.
*/
[[distributable]]
void i2c_master_single_port(server interface i2c_master_if c[n], static const size_t n,
port p_i2c, static const unsigned kbits_per_second,
static const unsigned scl_bit_position,
static const unsigned sda_bit_position,
static const unsigned other_bits_mask);
#endif
/** This interface is used to communicate with an I2C master component
* asynchronously.
* It provides facilities for reading and writing to the bus.
*
*/
typedef interface i2c_master_async_if {
/** Initialize a write to an I2C bus.
*
* \param device_addr the address of the slave device to write to
* \param buf the buffer containing data to write
* \param n the number of bytes to write
* \param send_stop_bit if this is non-zero then a stop bit
* will be sent on the bus after the transaction.
* This is usually required for normal operation. If
* this parameter is zero then no stop bit will
* be omitted. In this case, no other task can use
* the component until a stop bit has been sent.
*/
[[guarded]]
void write(uint8_t device_addr, uint8_t buf[n], size_t n,
int send_stop_bit);
/** Initialize a read to an I2C bus.
*
* \param device_addr the address of the slave device to read from.
* \param n the number of bytes to read.
* \param send_stop_bit if this is non-zero then a stop bit
* will be sent on the bus after the transaction.
* This is usually required for normal operation. If
* this parameter is zero then no stop bit will
* be omitted. In this case, no other task can use
* the component until a stop bit has been sent.
*/
[[guarded]]
void read(uint8_t device_addr, size_t n, int send_stop_bit);
/** Completed operation notification.
*
* This notification will fire when a read or write is completed.
*/
[[notification]]
slave void operation_complete(void);
/** Get write result.
*
* This function should be called after a write has completed.
*
* \param num_bytes_sent the function will set this value to the
* number of bytes actually sent. On success, this
* will be equal to ``n`` but it will be less if the
* slave sends an early NACK on the bus and the
* transaction fails.
*
* \returns ``I2C_ACK`` if the write was acknowledged by the slave
* device, otherwise ``I2C_NACK``.
*/
[[clears_notification]]
i2c_res_t get_write_result(size_t &num_bytes_sent);
/** Get read result.
*
* This function should be called after a read has completed.
*
* \param buf the buffer to fill with data.
* \param n the number of bytes to read, this should be the same
* as the number of bytes specified in read(),
* otherwise the behavior is undefined.
*
* \returns ``I2C_ACK`` if the write was acknowledged by the slave
* device, otherwise ``I2C_NACK``.
*/
[[clears_notification]]
i2c_res_t get_read_data(uint8_t buf[n], size_t n);
/** Send a stop bit.
*
* This function will cause a stop bit to be sent on the bus. It should
* be used to complete/abort a transaction if the ``send_stop_bit`` argument
* was not set when calling the read() or write() functions.
*/
void send_stop_bit(void);
/** Shutdown the I2C component.
*
* This function will cause the I2C task to shutdown and return.
*/
void shutdown();
} i2c_master_async_if;
/** I2C master component (asynchronous API).
*
* This function implements I2C and allows clients to asynchronously
* perform operations on the bus.
*
* \param i the interfaces to connect the component to its clients
* \param n the number of clients connected to the component
* \param p_scl the SCL port of the I2C bus
* \param p_sda the SDA port of the I2C bus
* \param kbits_per_second the speed of the I2C bus
* \param max_transaction_size the size of the local buffer in bytes. Any
* transactions exceeding this size will cause a
* run-time exception.
*
*/
void i2c_master_async(server interface i2c_master_async_if i[n],
size_t n,
port p_scl, port p_sda,
static const unsigned kbits_per_second,
static const size_t max_transaction_size);
/** I2C master component (asynchronous API, combinable).
*
* This function implements I2C and allows clients to asynchronously
* perform operations on the bus.
* Note that this component can be run on the same logical core as other
* tasks (i.e. it is [[combinable]]). However, care must be taken that the
* other tasks do not take too long in their select cases otherwise this
* component may miss I2C transactions.
*
* \param i the interfaces to connect the component to its clients
* \param n the number of clients connected to the component
* \param p_scl the SCL port of the I2C bus
* \param p_sda the SDA port of the I2C bus
* \param kbits_per_second the speed of the I2C bus
* \param max_transaction_size the size of the local buffer in bytes. Any
* transactions exceeding this size will cause a
* run-time exception.
*/
[[combinable]]
void i2c_master_async_comb(server interface i2c_master_async_if i[n],
size_t n,
port p_scl, port p_sda,
static const unsigned kbits_per_second,
static const size_t max_transaction_size);
typedef enum i2c_slave_ack_t {
I2C_SLAVE_ACK,
I2C_SLAVE_NACK,
} i2c_slave_ack_t;
/** This interface is used to communicate with an I2C slave component.
* It provides facilities for reading and writing to the bus. The I2C slave
* component acts a *client* to this interface. So the application must
* respond to these calls (i.e. the members of the interface are callbacks
* to the application).
*
*/
typedef interface i2c_slave_callback_if {
/** Master has requested a read.
*
* This callback function is called by the component
* if the bus master requests a read from this slave device.
*
* At this point the slave can choose to accept the request (and
* drive an ACK signal back to the master) or not (and drive a NACK
* signal).
*
* \returns the callback must return either ``I2C_SLAVE_ACK`` or
* ``I2C_SLAVE_NACK``.
*/
[[guarded]]
i2c_slave_ack_t ack_read_request(void);
/** Master has requested a write.
*
* This callback function is called by the component
* if the bus master requests a write from this slave device.
*
* At this point the slave can choose to accept the request (and
* drive an ACK signal back to the master) or not (and drive a NACK
* signal).
*
* \returns the callback must return either ``I2C_SLAVE_ACK`` or
* ``I2C_SLAVE_NACK``.
*/
[[guarded]]
i2c_slave_ack_t ack_write_request(void);
/** Master requires data.
*
* This callback function will be called when the I2C master requires data
* from the slave.
*
* \return the data to pass to the master.
*/
[[guarded]]
uint8_t master_requires_data();
/** Master has sent some data.
*
* This callback function will be called when the I2C master has transferred
* a byte of data to the slave.
*/
[[guarded]]
i2c_slave_ack_t master_sent_data(uint8_t data);
/** Stop bit.
*
* This callback function will be called by the component when a stop bit
* is sent by the master.
*/
void stop_bit(void);
/** Shutdown the I2C component.
*
* This function will cause the I2C slave task to shutdown and return.
*/
[[notification]] slave void shutdown();
} i2c_slave_callback_if;
/** I2C slave task.
*
* This function instantiates an i2c_slave component.
*
* \param i the client end of the i2c_slave_callback_if interface. The component
* takes the client end and will make calls on the interface when
* the master performs reads or writes.
* \param p_scl the SCL port of the I2C bus
* \param p_sda the SDA port of the I2C bus
* \param device_addr the address of the slave device
*
*/
[[combinable]]
void i2c_slave(client i2c_slave_callback_if i,
port p_scl, port p_sda,
uint8_t device_addr);
#endif // __XC__
#endif
PK U*Mm0 m0 lib_i2c/lib_i2c/doc/pdf/i2c.pdf%PDF-1.5
%
1 0 obj
<< /S /GoTo /D (section*.1) >>
endobj
4 0 obj
(I2C Library)
endobj
5 0 obj
<< /S /GoTo /D (section.1) >>
endobj
8 0 obj
(External signal description)
endobj
9 0 obj
<< /S /GoTo /D (subsection.1.1) >>
endobj
12 0 obj
(Connecting to the xCORE device)
endobj
13 0 obj
<< /S /GoTo /D (section.2) >>
endobj
16 0 obj
(Usage)
endobj
17 0 obj
<< /S /GoTo /D (subsection.2.1) >>
endobj
20 0 obj
(I2C master synchronous operation)
endobj
21 0 obj
<< /S /GoTo /D (subsection.2.2) >>
endobj
24 0 obj
(I2C master asynchronous operation)
endobj
25 0 obj
<< /S /GoTo /D (subsection.2.3) >>
endobj
28 0 obj
(Repeated start bits)
endobj
29 0 obj
<< /S /GoTo /D (subsection.2.4) >>
endobj
32 0 obj
(I2C slave library usage)
endobj
33 0 obj
<< /S /GoTo /D (section.3) >>
endobj
36 0 obj
(Master API)
endobj
37 0 obj
<< /S /GoTo /D (subsection.3.1) >>
endobj
40 0 obj
(Creating an I2C master instance)
endobj
41 0 obj
<< /S /GoTo /D (subsection.3.2) >>
endobj
44 0 obj
(I2C master supporting typedefs)
endobj
45 0 obj
<< /S /GoTo /D (subsection.3.3) >>
endobj
48 0 obj
(I2C master synchronous interface)
endobj
49 0 obj
<< /S /GoTo /D (subsection.3.4) >>
endobj
52 0 obj
(I2C master asynchronous interface)
endobj
53 0 obj
<< /S /GoTo /D (section.4) >>
endobj
56 0 obj
(Slave API)
endobj
57 0 obj
<< /S /GoTo /D (subsection.4.1) >>
endobj
60 0 obj
(Creating an I2C slave instance)
endobj
61 0 obj
<< /S /GoTo /D (subsection.4.2) >>
endobj
64 0 obj
(I2C slave interface)
endobj
65 0 obj
<< /S /GoTo /D (section.A) >>
endobj
68 0 obj
(Known Issues)
endobj
69 0 obj
<< /S /GoTo /D (section.B) >>
endobj
72 0 obj
(I2C library change log)
endobj
73 0 obj
<< /S /GoTo /D (subsection.B.1) >>
endobj
76 0 obj
(5.0.0)
endobj
77 0 obj
<< /S /GoTo /D (subsection.B.2) >>
endobj
80 0 obj
(4.0.2)
endobj
81 0 obj
<< /S /GoTo /D (subsection.B.3) >>
endobj
84 0 obj
(4.0.1)
endobj
85 0 obj
<< /S /GoTo /D (subsection.B.4) >>
endobj
88 0 obj
(4.0.0)
endobj
89 0 obj
<< /S /GoTo /D (subsection.B.5) >>
endobj
92 0 obj
(3.1.6)
endobj
93 0 obj
<< /S /GoTo /D (subsection.B.6) >>
endobj
96 0 obj
(3.1.5)
endobj
97 0 obj
<< /S /GoTo /D (subsection.B.7) >>
endobj
100 0 obj
(3.1.4)
endobj
101 0 obj
<< /S /GoTo /D (subsection.B.8) >>
endobj
104 0 obj
(3.1.3)
endobj
105 0 obj
<< /S /GoTo /D (subsection.B.9) >>
endobj
108 0 obj
(3.1.2)
endobj
109 0 obj
<< /S /GoTo /D (subsection.B.10) >>
endobj
112 0 obj
(3.1.1)
endobj
113 0 obj
<< /S /GoTo /D (subsection.B.11) >>
endobj
116 0 obj
(3.1.0)
endobj
117 0 obj
<< /S /GoTo /D (subsection.B.12) >>
endobj
120 0 obj
(3.0.0)
endobj
121 0 obj
<< /S /GoTo /D [122 0 R /Fit] >>
endobj
125 0 obj <<
/Length 2525
/Filter /FlateDecode
>>
stream
xڽZm۸B̐Z &4
]EWɒ,W-XR8p|82{vC?ľ4Pէix{&_?v͍yK_n~`܋xxXq~7sc0P!o~Usq&d;b 3L'Pj`F~{c|ĢЎ0XioQ0L|<=Ij&9
xVz|"ecZs<ˊ嶪b3"GPPozVk͕"*usbWֽZr!M
8x&Q)5*|r˗m#ʺBR
Y A1;Q:}BpLDNwbV(S2Kr3)Yҏ1IoU-i.6RUgߜGd2bbEZԕFSS (G=
0TvVYZ6T~˽y-Di:җ:-La/ܪaB9"]Ԧb9a׆u'Um)<6+(@BNc֪4fj6銤sk:4 _gԌO_VFOoJ֦ ql6NXHo1N ƽ$}`
>Vr1.`r&շJwH[ef C\LiXd,J/hm/YUBi)О3ݩ:`!=%5 iSTql`Qv,C0vKj_eIAJ?BGiOLbݠ 8D"*ߣ60"A4vl#̧֑
C[X
o?6;`9Fӯ1;>t\y
r~6 \cFAeSvG1sK+uݨcoR{l7dOo[`<.s9f;? H^a\,eZ/VͱYiیkb*E!Uoq%U;S{' ؈EhIɳY>IR,,#N}Udf6f!&I+-~Ŗ|UE(-R D:{eO*T -@zqPi"$=oK8!gpg_LB.,ϵ&E/$%T<)/zh<&M:wמ-:>h ×c~{K胹#?zs-\{-?:>bXqhTLJ
p
!BAv51,ăpXPXEǸ0]t)Gl 3) IEU;
j!r~JRt60*%6&),|$C.88GOQٱl,|p 5Y !ɐ)YsX~Dϑs $ՄwqTӜz؆ڸt^U1kk-,y#zȆڐO#5-L"#H)QNnrp3{"NrpSJBqk?U
.nkj5_`6$+c )T,Ve&lh 4hl
\c]汋1Dqn&spS[2dv\l3a5IsD>Lg=T6F
U 0*b^Mc46fCcm?hl
\Kcm1@17ei-McgIcnN9
hc2i1+o^@ņ:
u1/)Vc&lx u46U&a.V@&?7e-M~gI~nN1(G44?{6lChm1B !.E6j
1{sЮ&6 bŎ
Dq
2!hCiC"!gRfas[ǴXdVƂR,&c6iY'^L=(DLovygkKKfFtvg^>V]7#8f`p8 h/wޫXZfujbVU+Ѿ5Ou"g(k3wg&