Tux Leon / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-dev by mbed official

targets/TARGET_Maxim/TARGET_MAX32630/mxc/owm.c@157:ff67d9f36b67, 2017-02-02 (annotated)

Committer:
<>
Date:
Thu Feb 02 17:01:33 2017 +0000
Revision:
157:ff67d9f36b67
This updates the lib to the mbed lib v135

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 157:ff67d9f36b67 1 /**
<> 157:ff67d9f36b67 2 * @file
<> 157:ff67d9f36b67 3 * @brief 1-Wire Master (OWM) API Function Implementations.
<> 157:ff67d9f36b67 4 */
<> 157:ff67d9f36b67 5 /* *****************************************************************************
<> 157:ff67d9f36b67 6 * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
<> 157:ff67d9f36b67 7 *
<> 157:ff67d9f36b67 8 * Permission is hereby granted, free of charge, to any person obtaining a
<> 157:ff67d9f36b67 9 * copy of this software and associated documentation files (the "Software"),
<> 157:ff67d9f36b67 10 * to deal in the Software without restriction, including without limitation
<> 157:ff67d9f36b67 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
<> 157:ff67d9f36b67 12 * and/or sell copies of the Software, and to permit persons to whom the
<> 157:ff67d9f36b67 13 * Software is furnished to do so, subject to the following conditions:
<> 157:ff67d9f36b67 14 *
<> 157:ff67d9f36b67 15 * The above copyright notice and this permission notice shall be included
<> 157:ff67d9f36b67 16 * in all copies or substantial portions of the Software.
<> 157:ff67d9f36b67 17 *
<> 157:ff67d9f36b67 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
<> 157:ff67d9f36b67 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
<> 157:ff67d9f36b67 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
<> 157:ff67d9f36b67 21 * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
<> 157:ff67d9f36b67 22 * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
<> 157:ff67d9f36b67 23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
<> 157:ff67d9f36b67 24 * OTHER DEALINGS IN THE SOFTWARE.
<> 157:ff67d9f36b67 25 *
<> 157:ff67d9f36b67 26 * Except as contained in this notice, the name of Maxim Integrated
<> 157:ff67d9f36b67 27 * Products, Inc. shall not be used except as stated in the Maxim Integrated
<> 157:ff67d9f36b67 28 * Products, Inc. Branding Policy.
<> 157:ff67d9f36b67 29 *
<> 157:ff67d9f36b67 30 * The mere transfer of this software does not imply any licenses
<> 157:ff67d9f36b67 31 * of trade secrets, proprietary technology, copyrights, patents,
<> 157:ff67d9f36b67 32 * trademarks, maskwork rights, or any other form of intellectual
<> 157:ff67d9f36b67 33 * property whatsoever. Maxim Integrated Products, Inc. retains all
<> 157:ff67d9f36b67 34 * ownership rights.
<> 157:ff67d9f36b67 35 *
<> 157:ff67d9f36b67 36 * $Date: 2016-03-14 10:08:53 -0500 (Mon, 14 Mar 2016) $
<> 157:ff67d9f36b67 37 * $Revision: 21855 $
<> 157:ff67d9f36b67 38 *
<> 157:ff67d9f36b67 39 **************************************************************************** */
<> 157:ff67d9f36b67 40
<> 157:ff67d9f36b67 41 /* **** Includes **** */
<> 157:ff67d9f36b67 42 #include <string.h>
<> 157:ff67d9f36b67 43 #include "mxc_assert.h"
<> 157:ff67d9f36b67 44 #include "mxc_sys.h"
<> 157:ff67d9f36b67 45 #include "owm.h"
<> 157:ff67d9f36b67 46
<> 157:ff67d9f36b67 47 /**
<> 157:ff67d9f36b67 48 * @ingroup owm
<> 157:ff67d9f36b67 49 * @{
<> 157:ff67d9f36b67 50 */
<> 157:ff67d9f36b67 51 ///@cond
<> 157:ff67d9f36b67 52 /* **** Definitions **** */
<> 157:ff67d9f36b67 53 #define OWM_CLK_FREQ 1000000 //1-Wire requires 1MHz clock
<> 157:ff67d9f36b67 54
<> 157:ff67d9f36b67 55 /* **** Globals **** */
<> 157:ff67d9f36b67 56 int LastDiscrepancy;
<> 157:ff67d9f36b67 57 int LastDeviceFlag;
<> 157:ff67d9f36b67 58
<> 157:ff67d9f36b67 59 /* **** Functions **** */
<> 157:ff67d9f36b67 60 static uint8_t CalculateCRC8(uint8_t* data, int len);
<> 157:ff67d9f36b67 61 static uint8_t update_crc8(uint8_t crc, uint8_t value);
<> 157:ff67d9f36b67 62 ///@endcond
<> 157:ff67d9f36b67 63
<> 157:ff67d9f36b67 64
<> 157:ff67d9f36b67 65 /* ************************************************************************* */
<> 157:ff67d9f36b67 66 int OWM_Init(mxc_owm_regs_t *owm, const owm_cfg_t *cfg, const sys_cfg_owm_t *sys_cfg)
<> 157:ff67d9f36b67 67 {
<> 157:ff67d9f36b67 68 int err = 0;
<> 157:ff67d9f36b67 69 uint32_t owm_clk, clk_div = 0;
<> 157:ff67d9f36b67 70 uint32_t ext_pu_mode = 0;
<> 157:ff67d9f36b67 71 uint32_t ext_pu_polarity = 0;
<> 157:ff67d9f36b67 72
<> 157:ff67d9f36b67 73 // Check the OWM register pointer is valid
<> 157:ff67d9f36b67 74 MXC_ASSERT(MXC_OWM_GET_IDX(owm) >= 0);
<> 157:ff67d9f36b67 75
<> 157:ff67d9f36b67 76 if(cfg == NULL) {
<> 157:ff67d9f36b67 77 return E_NULL_PTR;
<> 157:ff67d9f36b67 78 }
<> 157:ff67d9f36b67 79
<> 157:ff67d9f36b67 80 // Set system level configurations
<> 157:ff67d9f36b67 81 if ((err = SYS_OWM_Init(owm, sys_cfg)) != E_NO_ERROR) {
<> 157:ff67d9f36b67 82 return err;
<> 157:ff67d9f36b67 83 }
<> 157:ff67d9f36b67 84
<> 157:ff67d9f36b67 85 // Configure clk divisor to get 1MHz OWM clk
<> 157:ff67d9f36b67 86 owm_clk = SYS_OWM_GetFreq(owm);
<> 157:ff67d9f36b67 87
<> 157:ff67d9f36b67 88 if(owm_clk == 0) {
<> 157:ff67d9f36b67 89 return E_UNINITIALIZED;
<> 157:ff67d9f36b67 90 }
<> 157:ff67d9f36b67 91
<> 157:ff67d9f36b67 92 // Return error if clk doesn't divide evenly to 1MHz
<> 157:ff67d9f36b67 93 if(owm_clk % OWM_CLK_FREQ) {
<> 157:ff67d9f36b67 94 return E_NOT_SUPPORTED;
<> 157:ff67d9f36b67 95 }
<> 157:ff67d9f36b67 96
<> 157:ff67d9f36b67 97 clk_div = (owm_clk / (OWM_CLK_FREQ));
<> 157:ff67d9f36b67 98
<> 157:ff67d9f36b67 99 // Can not support lower frequencies
<> 157:ff67d9f36b67 100 if(clk_div == 0) {
<> 157:ff67d9f36b67 101 return E_NOT_SUPPORTED;
<> 157:ff67d9f36b67 102 }
<> 157:ff67d9f36b67 103
<> 157:ff67d9f36b67 104 // Select the PU mode and polarity based on cfg input
<> 157:ff67d9f36b67 105 switch(cfg->ext_pu_mode)
<> 157:ff67d9f36b67 106 {
<> 157:ff67d9f36b67 107 case OWM_EXT_PU_ACT_HIGH:
<> 157:ff67d9f36b67 108 ext_pu_mode = MXC_V_OWM_CFG_EXT_PULLUP_MODE_USED;
<> 157:ff67d9f36b67 109 ext_pu_polarity = MXC_V_OWM_CTRL_STAT_EXT_PULLUP_POL_ACT_HIGH;
<> 157:ff67d9f36b67 110 break;
<> 157:ff67d9f36b67 111 case OWM_EXT_PU_ACT_LOW:
<> 157:ff67d9f36b67 112 ext_pu_mode = MXC_V_OWM_CFG_EXT_PULLUP_MODE_USED;
<> 157:ff67d9f36b67 113 ext_pu_polarity = MXC_V_OWM_CTRL_STAT_EXT_PULLUP_POL_ACT_LOW;
<> 157:ff67d9f36b67 114 break;
<> 157:ff67d9f36b67 115 case OWM_EXT_PU_UNUSED:
<> 157:ff67d9f36b67 116 ext_pu_mode = MXC_V_OWM_CFG_EXT_PULLUP_MODE_UNUSED;
<> 157:ff67d9f36b67 117 ext_pu_polarity = MXC_V_OWM_CTRL_STAT_EXT_PULLUP_POL_ACT_HIGH;
<> 157:ff67d9f36b67 118 break;
<> 157:ff67d9f36b67 119 default:
<> 157:ff67d9f36b67 120 return E_BAD_PARAM;
<> 157:ff67d9f36b67 121 }
<> 157:ff67d9f36b67 122
<> 157:ff67d9f36b67 123 // Set clk divisor
<> 157:ff67d9f36b67 124 owm->clk_div_1us = (clk_div << MXC_F_OWM_CLK_DIV_1US_DIVISOR_POS) & MXC_F_OWM_CLK_DIV_1US_DIVISOR;
<> 157:ff67d9f36b67 125
<> 157:ff67d9f36b67 126 // Set configuration
<> 157:ff67d9f36b67 127 owm->cfg = (((cfg->int_pu_en << MXC_F_OWM_CFG_INT_PULLUP_ENABLE_POS) & MXC_F_OWM_CFG_INT_PULLUP_ENABLE) |
<> 157:ff67d9f36b67 128 ((ext_pu_mode << MXC_F_OWM_CFG_EXT_PULLUP_MODE_POS) & MXC_F_OWM_CFG_EXT_PULLUP_MODE) |
<> 157:ff67d9f36b67 129 ((cfg->long_line_mode << MXC_F_OWM_CFG_LONG_LINE_MODE) & MXC_F_OWM_CFG_LONG_LINE_MODE_POS));
<> 157:ff67d9f36b67 130
<> 157:ff67d9f36b67 131 owm->ctrl_stat = (((ext_pu_polarity << MXC_F_OWM_CTRL_STAT_EXT_PULLUP_POL_POS) & MXC_F_OWM_CTRL_STAT_EXT_PULLUP_POL) |
<> 157:ff67d9f36b67 132 ((cfg->overdrive_spec << MXC_F_OWM_CTRL_STAT_OD_SPEC_MODE_POS) & MXC_F_OWM_CTRL_STAT_OD_SPEC_MODE));
<> 157:ff67d9f36b67 133
<> 157:ff67d9f36b67 134 // Clear all interrupt flags
<> 157:ff67d9f36b67 135 owm->intfl = owm->intfl;
<> 157:ff67d9f36b67 136
<> 157:ff67d9f36b67 137 return E_NO_ERROR;
<> 157:ff67d9f36b67 138 }
<> 157:ff67d9f36b67 139
<> 157:ff67d9f36b67 140 /* ************************************************************************* */
<> 157:ff67d9f36b67 141 int OWM_Shutdown(mxc_owm_regs_t *owm)
<> 157:ff67d9f36b67 142 {
<> 157:ff67d9f36b67 143 int err;
<> 157:ff67d9f36b67 144
<> 157:ff67d9f36b67 145 // Disable and clear interrupts
<> 157:ff67d9f36b67 146 owm->inten = 0;
<> 157:ff67d9f36b67 147 owm->intfl = owm->intfl;
<> 157:ff67d9f36b67 148
<> 157:ff67d9f36b67 149 // Release IO pins and disable clk
<> 157:ff67d9f36b67 150 if ((err = SYS_OWM_Shutdown(owm)) != E_NO_ERROR) {
<> 157:ff67d9f36b67 151 return err;
<> 157:ff67d9f36b67 152 }
<> 157:ff67d9f36b67 153
<> 157:ff67d9f36b67 154 return E_NO_ERROR;
<> 157:ff67d9f36b67 155 }
<> 157:ff67d9f36b67 156
<> 157:ff67d9f36b67 157 /* ************************************************************************* */
<> 157:ff67d9f36b67 158 int OWM_Reset(mxc_owm_regs_t *owm)
<> 157:ff67d9f36b67 159 {
<> 157:ff67d9f36b67 160 owm->intfl = MXC_F_OWM_INTFL_OW_RESET_DONE; // Clear the reset flag
<> 157:ff67d9f36b67 161 owm->ctrl_stat |= MXC_F_OWM_CTRL_STAT_START_OW_RESET; // Generate a reset pulse
<> 157:ff67d9f36b67 162 while((owm->intfl & MXC_F_OWM_INTFL_OW_RESET_DONE) == 0); // Wait for reset time slot to complete
<> 157:ff67d9f36b67 163
<> 157:ff67d9f36b67 164 return (!!(owm->ctrl_stat & MXC_F_OWM_CTRL_STAT_PRESENCE_DETECT)); // Return presence pulse detect status
<> 157:ff67d9f36b67 165 }
<> 157:ff67d9f36b67 166
<> 157:ff67d9f36b67 167 /* ************************************************************************* */
<> 157:ff67d9f36b67 168 int OWM_TouchByte(mxc_owm_regs_t *owm, uint8_t data)
<> 157:ff67d9f36b67 169 {
<> 157:ff67d9f36b67 170 owm->cfg &= ~MXC_F_OWM_CFG_SINGLE_BIT_MODE; // Set to 8 bit mode
<> 157:ff67d9f36b67 171 owm->intfl = (MXC_F_OWM_INTFL_TX_DATA_EMPTY | MXC_F_OWM_INTFL_RX_DATA_READY); // Clear the flags
<> 157:ff67d9f36b67 172 owm->data = (data << MXC_F_OWM_DATA_TX_RX_POS) & MXC_F_OWM_DATA_TX_RX; // Write data
<> 157:ff67d9f36b67 173 while((owm->intfl & MXC_F_OWM_INTFL_TX_DATA_EMPTY) == 0); // Wait for data to be sent
<> 157:ff67d9f36b67 174 while((owm->intfl & MXC_F_OWM_INTFL_RX_DATA_READY) == 0); // Wait for data to be read
<> 157:ff67d9f36b67 175
<> 157:ff67d9f36b67 176 return (owm->data >> MXC_F_OWM_DATA_TX_RX_POS) & 0xFF; // Return the data read
<> 157:ff67d9f36b67 177 }
<> 157:ff67d9f36b67 178
<> 157:ff67d9f36b67 179 /* ************************************************************************* */
<> 157:ff67d9f36b67 180 int OWM_WriteByte(mxc_owm_regs_t *owm, uint8_t data)
<> 157:ff67d9f36b67 181 {
<> 157:ff67d9f36b67 182 // Send one byte of data and verify the data sent = data parameter
<> 157:ff67d9f36b67 183 return (OWM_TouchByte(owm, data) == data) ? E_NO_ERROR : E_COMM_ERR;
<> 157:ff67d9f36b67 184 }
<> 157:ff67d9f36b67 185
<> 157:ff67d9f36b67 186 /* ************************************************************************* */
<> 157:ff67d9f36b67 187 int OWM_ReadByte(mxc_owm_regs_t *owm)
<> 157:ff67d9f36b67 188 {
<> 157:ff67d9f36b67 189 // Read one byte of data
<> 157:ff67d9f36b67 190 return OWM_TouchByte(owm, 0xFF);
<> 157:ff67d9f36b67 191 }
<> 157:ff67d9f36b67 192
<> 157:ff67d9f36b67 193 /* ************************************************************************* */
<> 157:ff67d9f36b67 194 int OWM_TouchBit(mxc_owm_regs_t *owm, uint8_t bit)
<> 157:ff67d9f36b67 195 {
<> 157:ff67d9f36b67 196 MXC_OWM->cfg |= MXC_F_OWM_CFG_SINGLE_BIT_MODE; // Set to 1 bit mode
<> 157:ff67d9f36b67 197 owm->intfl = (MXC_F_OWM_INTFL_TX_DATA_EMPTY | MXC_F_OWM_INTFL_RX_DATA_READY); // Clear the flags
<> 157:ff67d9f36b67 198 owm->data = (bit << MXC_F_OWM_DATA_TX_RX_POS) & MXC_F_OWM_DATA_TX_RX; // Write data
<> 157:ff67d9f36b67 199 while((owm->intfl & MXC_F_OWM_INTFL_TX_DATA_EMPTY) == 0); // Wait for data to be sent
<> 157:ff67d9f36b67 200 while((owm->intfl & MXC_F_OWM_INTFL_RX_DATA_READY) == 0); // Wait for data to be read
<> 157:ff67d9f36b67 201
<> 157:ff67d9f36b67 202 return (owm->data >> MXC_F_OWM_DATA_TX_RX_POS) & 0x1; // Return the bit read
<> 157:ff67d9f36b67 203 }
<> 157:ff67d9f36b67 204
<> 157:ff67d9f36b67 205 /* ************************************************************************* */
<> 157:ff67d9f36b67 206 int OWM_WriteBit(mxc_owm_regs_t *owm, uint8_t bit)
<> 157:ff67d9f36b67 207 {
<> 157:ff67d9f36b67 208 // Send a bit and verify the bit sent = bit parameter
<> 157:ff67d9f36b67 209 return (OWM_TouchBit(owm, bit) == bit) ? E_NO_ERROR : E_COMM_ERR;
<> 157:ff67d9f36b67 210 }
<> 157:ff67d9f36b67 211
<> 157:ff67d9f36b67 212 /* ************************************************************************* */
<> 157:ff67d9f36b67 213 int OWM_ReadBit(mxc_owm_regs_t *owm)
<> 157:ff67d9f36b67 214 {
<> 157:ff67d9f36b67 215 // Read a bit
<> 157:ff67d9f36b67 216 return OWM_TouchBit(owm, 1);
<> 157:ff67d9f36b67 217 }
<> 157:ff67d9f36b67 218
<> 157:ff67d9f36b67 219 /* ************************************************************************* */
<> 157:ff67d9f36b67 220 int OWM_Write(mxc_owm_regs_t *owm, uint8_t* data, int len)
<> 157:ff67d9f36b67 221 {
<> 157:ff67d9f36b67 222 int num = 0;
<> 157:ff67d9f36b67 223
<> 157:ff67d9f36b67 224 owm->cfg &= ~MXC_F_OWM_CFG_SINGLE_BIT_MODE; // Set to 8 bit mode
<> 157:ff67d9f36b67 225
<> 157:ff67d9f36b67 226 while(num < len) // Loop for number of bytes to write
<> 157:ff67d9f36b67 227 {
<> 157:ff67d9f36b67 228 owm->intfl = (MXC_F_OWM_INTFL_TX_DATA_EMPTY | MXC_F_OWM_INTFL_RX_DATA_READY | MXC_F_OWM_INTEN_LINE_SHORT); // Clear the flags
<> 157:ff67d9f36b67 229 owm->data = (data[num] << MXC_F_OWM_DATA_TX_RX_POS) & MXC_F_OWM_DATA_TX_RX; // Write data
<> 157:ff67d9f36b67 230 while((owm->intfl & MXC_F_OWM_INTFL_TX_DATA_EMPTY) == 0); // Wait for data to be sent
<> 157:ff67d9f36b67 231 while((owm->intfl & MXC_F_OWM_INTFL_RX_DATA_READY) == 0); // Wait for data to be read
<> 157:ff67d9f36b67 232
<> 157:ff67d9f36b67 233 // Verify data sent is correct
<> 157:ff67d9f36b67 234 if(owm->data != data[num]) {
<> 157:ff67d9f36b67 235 return E_COMM_ERR;
<> 157:ff67d9f36b67 236 }
<> 157:ff67d9f36b67 237
<> 157:ff67d9f36b67 238 // Check error flag
<> 157:ff67d9f36b67 239 if(owm->intfl & MXC_F_OWM_INTEN_LINE_SHORT) {
<> 157:ff67d9f36b67 240 return E_COMM_ERR; // Wire was low before transaction
<> 157:ff67d9f36b67 241 }
<> 157:ff67d9f36b67 242
<> 157:ff67d9f36b67 243 num++; // Keep track of how many bytes written
<> 157:ff67d9f36b67 244 }
<> 157:ff67d9f36b67 245
<> 157:ff67d9f36b67 246 return num; // Return number of bytes written
<> 157:ff67d9f36b67 247 }
<> 157:ff67d9f36b67 248
<> 157:ff67d9f36b67 249 /* ************************************************************************* */
<> 157:ff67d9f36b67 250 int OWM_Read(mxc_owm_regs_t *owm, uint8_t* data, int len)
<> 157:ff67d9f36b67 251 {
<> 157:ff67d9f36b67 252 int num = 0;
<> 157:ff67d9f36b67 253
<> 157:ff67d9f36b67 254 owm->cfg &= ~MXC_F_OWM_CFG_SINGLE_BIT_MODE; // Set to 8 bit mode
<> 157:ff67d9f36b67 255
<> 157:ff67d9f36b67 256 while(num < len) // Loop for number of bytes to read
<> 157:ff67d9f36b67 257 {
<> 157:ff67d9f36b67 258 owm->intfl = (MXC_F_OWM_INTFL_TX_DATA_EMPTY | MXC_F_OWM_INTFL_RX_DATA_READY | MXC_F_OWM_INTEN_LINE_SHORT); // Clear the flags
<> 157:ff67d9f36b67 259 owm->data = 0xFF; // Write 0xFF for a read
<> 157:ff67d9f36b67 260 while((owm->intfl & MXC_F_OWM_INTFL_TX_DATA_EMPTY) == 0); // Wait for data to be sent
<> 157:ff67d9f36b67 261 while((owm->intfl & MXC_F_OWM_INTFL_RX_DATA_READY) == 0); // Wait for data to be read
<> 157:ff67d9f36b67 262
<> 157:ff67d9f36b67 263 // Check error flag
<> 157:ff67d9f36b67 264 if(owm->intfl & MXC_F_OWM_INTEN_LINE_SHORT) {
<> 157:ff67d9f36b67 265 return E_COMM_ERR; // Wire was low before transaction
<> 157:ff67d9f36b67 266 }
<> 157:ff67d9f36b67 267
<> 157:ff67d9f36b67 268 // Store read data into buffer
<> 157:ff67d9f36b67 269 data[num] = (owm->data >> MXC_F_OWM_DATA_TX_RX_POS) & MXC_F_OWM_DATA_TX_RX;
<> 157:ff67d9f36b67 270
<> 157:ff67d9f36b67 271 num++; // Keep track of how many bytes read
<> 157:ff67d9f36b67 272 }
<> 157:ff67d9f36b67 273
<> 157:ff67d9f36b67 274 return num; // Return number of bytes read
<> 157:ff67d9f36b67 275 }
<> 157:ff67d9f36b67 276
<> 157:ff67d9f36b67 277 /* ************************************************************************* */
<> 157:ff67d9f36b67 278 int OWM_ReadROM(mxc_owm_regs_t *owm, uint8_t* ROMCode)
<> 157:ff67d9f36b67 279 {
<> 157:ff67d9f36b67 280 int num_read = 0;
<> 157:ff67d9f36b67 281
<> 157:ff67d9f36b67 282 // Send reset and wait for presence pulse
<> 157:ff67d9f36b67 283 if(OWM_Reset(owm))
<> 157:ff67d9f36b67 284 {
<> 157:ff67d9f36b67 285 // Send Read ROM command code
<> 157:ff67d9f36b67 286 if(OWM_WriteByte(owm, READ_ROM_COMMAND) == E_NO_ERROR)
<> 157:ff67d9f36b67 287 {
<> 157:ff67d9f36b67 288 // Read 8 bytes and store in buffer
<> 157:ff67d9f36b67 289 num_read = OWM_Read(owm, ROMCode, 8);
<> 157:ff67d9f36b67 290
<> 157:ff67d9f36b67 291 // Check the number of bytes read
<> 157:ff67d9f36b67 292 if(num_read != 8) {
<> 157:ff67d9f36b67 293 return E_COMM_ERR;
<> 157:ff67d9f36b67 294 }
<> 157:ff67d9f36b67 295 }
<> 157:ff67d9f36b67 296 else
<> 157:ff67d9f36b67 297 {
<> 157:ff67d9f36b67 298 // Write failed
<> 157:ff67d9f36b67 299 return E_COMM_ERR;
<> 157:ff67d9f36b67 300 }
<> 157:ff67d9f36b67 301 }
<> 157:ff67d9f36b67 302 else
<> 157:ff67d9f36b67 303 {
<> 157:ff67d9f36b67 304 // No presence pulse
<> 157:ff67d9f36b67 305 return E_COMM_ERR;
<> 157:ff67d9f36b67 306 }
<> 157:ff67d9f36b67 307
<> 157:ff67d9f36b67 308 return E_NO_ERROR;
<> 157:ff67d9f36b67 309 }
<> 157:ff67d9f36b67 310
<> 157:ff67d9f36b67 311 /* ************************************************************************* */
<> 157:ff67d9f36b67 312 int OWM_MatchROM(mxc_owm_regs_t *owm, uint8_t* ROMCode)
<> 157:ff67d9f36b67 313 {
<> 157:ff67d9f36b67 314 int num_wrote = 0;
<> 157:ff67d9f36b67 315
<> 157:ff67d9f36b67 316 // Send reset and wait for presence pulse
<> 157:ff67d9f36b67 317 if(OWM_Reset(owm))
<> 157:ff67d9f36b67 318 {
<> 157:ff67d9f36b67 319 // Send match ROM command code
<> 157:ff67d9f36b67 320 if(OWM_WriteByte(owm, MATCH_ROM_COMMAND) == E_NO_ERROR)
<> 157:ff67d9f36b67 321 {
<> 157:ff67d9f36b67 322 // Write 8 bytes in ROMCode buffer
<> 157:ff67d9f36b67 323 num_wrote = OWM_Write(owm, ROMCode, 8);
<> 157:ff67d9f36b67 324
<> 157:ff67d9f36b67 325 // Check the number of bytes written
<> 157:ff67d9f36b67 326 if(num_wrote != 8) {
<> 157:ff67d9f36b67 327 return E_COMM_ERR;
<> 157:ff67d9f36b67 328 }
<> 157:ff67d9f36b67 329 }
<> 157:ff67d9f36b67 330 else
<> 157:ff67d9f36b67 331 {
<> 157:ff67d9f36b67 332 // Write failed
<> 157:ff67d9f36b67 333 return E_COMM_ERR;
<> 157:ff67d9f36b67 334 }
<> 157:ff67d9f36b67 335 }
<> 157:ff67d9f36b67 336 else
<> 157:ff67d9f36b67 337 {
<> 157:ff67d9f36b67 338 // No presence pulse
<> 157:ff67d9f36b67 339 return E_COMM_ERR;
<> 157:ff67d9f36b67 340 }
<> 157:ff67d9f36b67 341
<> 157:ff67d9f36b67 342 return E_NO_ERROR;
<> 157:ff67d9f36b67 343 }
<> 157:ff67d9f36b67 344
<> 157:ff67d9f36b67 345 /* ************************************************************************* */
<> 157:ff67d9f36b67 346 int OWM_ODMatchROM(mxc_owm_regs_t *owm, uint8_t* ROMCode)
<> 157:ff67d9f36b67 347 {
<> 157:ff67d9f36b67 348 int num_wrote = 0;
<> 157:ff67d9f36b67 349
<> 157:ff67d9f36b67 350 // Set to standard speed
<> 157:ff67d9f36b67 351 owm->cfg &= ~(MXC_F_OWM_CFG_OVERDRIVE);
<> 157:ff67d9f36b67 352
<> 157:ff67d9f36b67 353 // Send reset and wait for presence pulse
<> 157:ff67d9f36b67 354 if(OWM_Reset(owm))
<> 157:ff67d9f36b67 355 {
<> 157:ff67d9f36b67 356 // Send Overdrive match ROM command code
<> 157:ff67d9f36b67 357 if(OWM_WriteByte(owm, OD_MATCH_ROM_COMMAND) == E_NO_ERROR)
<> 157:ff67d9f36b67 358 {
<> 157:ff67d9f36b67 359 // Set overdrive
<> 157:ff67d9f36b67 360 owm->cfg |= MXC_F_OWM_CFG_OVERDRIVE;
<> 157:ff67d9f36b67 361
<> 157:ff67d9f36b67 362 // Write 8 bytes in ROMCode buffer
<> 157:ff67d9f36b67 363 num_wrote = OWM_Write(owm, ROMCode, 8);
<> 157:ff67d9f36b67 364
<> 157:ff67d9f36b67 365 // Check the number of bytes written
<> 157:ff67d9f36b67 366 if(num_wrote != 8) {
<> 157:ff67d9f36b67 367 return E_COMM_ERR;
<> 157:ff67d9f36b67 368 }
<> 157:ff67d9f36b67 369 }
<> 157:ff67d9f36b67 370 else
<> 157:ff67d9f36b67 371 {
<> 157:ff67d9f36b67 372 // Write failed
<> 157:ff67d9f36b67 373 return E_COMM_ERR;
<> 157:ff67d9f36b67 374 }
<> 157:ff67d9f36b67 375 }
<> 157:ff67d9f36b67 376 else
<> 157:ff67d9f36b67 377 {
<> 157:ff67d9f36b67 378 // No presence pulse
<> 157:ff67d9f36b67 379 return E_COMM_ERR;
<> 157:ff67d9f36b67 380 }
<> 157:ff67d9f36b67 381
<> 157:ff67d9f36b67 382 return E_NO_ERROR;
<> 157:ff67d9f36b67 383 }
<> 157:ff67d9f36b67 384
<> 157:ff67d9f36b67 385 /* ************************************************************************* */
<> 157:ff67d9f36b67 386 int OWM_SkipROM(mxc_owm_regs_t *owm)
<> 157:ff67d9f36b67 387 {
<> 157:ff67d9f36b67 388 // Send reset and wait for presence pulse
<> 157:ff67d9f36b67 389 if(OWM_Reset(owm))
<> 157:ff67d9f36b67 390 {
<> 157:ff67d9f36b67 391 // Send skip ROM command code
<> 157:ff67d9f36b67 392 return OWM_WriteByte(owm, SKIP_ROM_COMMAND);
<> 157:ff67d9f36b67 393 }
<> 157:ff67d9f36b67 394 else
<> 157:ff67d9f36b67 395 {
<> 157:ff67d9f36b67 396 // No presence pulse
<> 157:ff67d9f36b67 397 return E_COMM_ERR;
<> 157:ff67d9f36b67 398 }
<> 157:ff67d9f36b67 399 }
<> 157:ff67d9f36b67 400
<> 157:ff67d9f36b67 401 /* ************************************************************************* */
<> 157:ff67d9f36b67 402 int OWM_ODSkipROM(mxc_owm_regs_t *owm)
<> 157:ff67d9f36b67 403 {
<> 157:ff67d9f36b67 404 // Set to standard speed
<> 157:ff67d9f36b67 405 owm->cfg &= ~(MXC_F_OWM_CFG_OVERDRIVE);
<> 157:ff67d9f36b67 406
<> 157:ff67d9f36b67 407 // Send reset and wait for presence pulse
<> 157:ff67d9f36b67 408 if(OWM_Reset(owm))
<> 157:ff67d9f36b67 409 {
<> 157:ff67d9f36b67 410 // Send Overdrive skip ROM command code
<> 157:ff67d9f36b67 411 if(OWM_WriteByte(owm, OD_SKIP_ROM_COMMAND) == E_NO_ERROR)
<> 157:ff67d9f36b67 412 {
<> 157:ff67d9f36b67 413 // Set overdrive speed
<> 157:ff67d9f36b67 414 owm->cfg |= MXC_F_OWM_CFG_OVERDRIVE;
<> 157:ff67d9f36b67 415
<> 157:ff67d9f36b67 416 return E_NO_ERROR;
<> 157:ff67d9f36b67 417 }
<> 157:ff67d9f36b67 418 else
<> 157:ff67d9f36b67 419 {
<> 157:ff67d9f36b67 420 // Write failed
<> 157:ff67d9f36b67 421 return E_COMM_ERR;
<> 157:ff67d9f36b67 422 }
<> 157:ff67d9f36b67 423 }
<> 157:ff67d9f36b67 424 else
<> 157:ff67d9f36b67 425 {
<> 157:ff67d9f36b67 426 // No presence pulse
<> 157:ff67d9f36b67 427 return E_COMM_ERR;
<> 157:ff67d9f36b67 428 }
<> 157:ff67d9f36b67 429 }
<> 157:ff67d9f36b67 430
<> 157:ff67d9f36b67 431 /* ************************************************************************* */
<> 157:ff67d9f36b67 432 int OWM_Resume(mxc_owm_regs_t *owm)
<> 157:ff67d9f36b67 433 {
<> 157:ff67d9f36b67 434 // Send reset and wait for presence pulse
<> 157:ff67d9f36b67 435 if(OWM_Reset(owm))
<> 157:ff67d9f36b67 436 {
<> 157:ff67d9f36b67 437 // Send resume command code
<> 157:ff67d9f36b67 438 return OWM_WriteByte(owm, RESUME_COMMAND);
<> 157:ff67d9f36b67 439 }
<> 157:ff67d9f36b67 440 else
<> 157:ff67d9f36b67 441 {
<> 157:ff67d9f36b67 442 // No presence pulse
<> 157:ff67d9f36b67 443 return E_COMM_ERR;
<> 157:ff67d9f36b67 444 }
<> 157:ff67d9f36b67 445 }
<> 157:ff67d9f36b67 446
<> 157:ff67d9f36b67 447 /* ************************************************************************* */
<> 157:ff67d9f36b67 448 int OWM_SearchROM(mxc_owm_regs_t *owm, int newSearch, uint8_t* ROMCode)
<> 157:ff67d9f36b67 449 {
<> 157:ff67d9f36b67 450 int nibble_start_bit = 1;
<> 157:ff67d9f36b67 451 int rom_byte_number = 0;
<> 157:ff67d9f36b67 452 uint8_t rom_nibble_mask = 0x0F;
<> 157:ff67d9f36b67 453 uint8_t search_direction = 0;
<> 157:ff67d9f36b67 454 int readValue = 0;
<> 157:ff67d9f36b67 455 int sentBits = 0;
<> 157:ff67d9f36b67 456 int discrepancy = 0;
<> 157:ff67d9f36b67 457 int bit_position = 0;
<> 157:ff67d9f36b67 458 int discrepancy_mask = 0;
<> 157:ff67d9f36b67 459 int last_zero = 0;
<> 157:ff67d9f36b67 460 uint8_t crc8 = 0;
<> 157:ff67d9f36b67 461 int search_result = 0;
<> 157:ff67d9f36b67 462
<> 157:ff67d9f36b67 463 // Clear ROM array
<> 157:ff67d9f36b67 464 memset(ROMCode, 0x0, 8);
<> 157:ff67d9f36b67 465
<> 157:ff67d9f36b67 466 if(newSearch)
<> 157:ff67d9f36b67 467 {
<> 157:ff67d9f36b67 468 // Reset all global variables to start search from begining
<> 157:ff67d9f36b67 469 LastDiscrepancy = 0;
<> 157:ff67d9f36b67 470 LastDeviceFlag = 0;
<> 157:ff67d9f36b67 471 }
<> 157:ff67d9f36b67 472
<> 157:ff67d9f36b67 473 // Check if the last call was the last device
<> 157:ff67d9f36b67 474 if(LastDeviceFlag)
<> 157:ff67d9f36b67 475 {
<> 157:ff67d9f36b67 476 // Reset the search
<> 157:ff67d9f36b67 477 LastDiscrepancy = 0;
<> 157:ff67d9f36b67 478 LastDeviceFlag = 0;
<> 157:ff67d9f36b67 479 return 0;
<> 157:ff67d9f36b67 480 }
<> 157:ff67d9f36b67 481
<> 157:ff67d9f36b67 482 // Send reset and wait for presence pulse
<> 157:ff67d9f36b67 483 if (OWM_Reset(owm))
<> 157:ff67d9f36b67 484 {
<> 157:ff67d9f36b67 485 // Send the search command
<> 157:ff67d9f36b67 486 OWM_WriteByte(owm, SEARCH_ROM_COMMAND);
<> 157:ff67d9f36b67 487
<> 157:ff67d9f36b67 488 // Set search ROM accelerator bit
<> 157:ff67d9f36b67 489 owm->ctrl_stat |= MXC_F_OWM_CTRL_STAT_SRA_MODE;
<> 157:ff67d9f36b67 490
<> 157:ff67d9f36b67 491 // Loop until through all ROM bytes 0-7 (this loops 2 times per byte)
<> 157:ff67d9f36b67 492 while(rom_byte_number < 8)
<> 157:ff67d9f36b67 493 {
<> 157:ff67d9f36b67 494 // Each loop finds the discrepancy bits and finds 4 bits (nibble) of the ROM
<> 157:ff67d9f36b67 495
<> 157:ff67d9f36b67 496 // Set the search direction the same as last time for the nibble masked
<> 157:ff67d9f36b67 497 search_direction = ROMCode[rom_byte_number] & rom_nibble_mask;
<> 157:ff67d9f36b67 498
<> 157:ff67d9f36b67 499 // If the upper nibble is the mask then shift bits to lower nibble
<> 157:ff67d9f36b67 500 if(rom_nibble_mask > 0x0F) {
<> 157:ff67d9f36b67 501 search_direction = search_direction >> 4;
<> 157:ff67d9f36b67 502 }
<> 157:ff67d9f36b67 503
<> 157:ff67d9f36b67 504 // Get the last discrepancy bit position relative to the nibble start bit
<> 157:ff67d9f36b67 505 bit_position = LastDiscrepancy - nibble_start_bit;
<> 157:ff67d9f36b67 506
<> 157:ff67d9f36b67 507 // Check if last discrepancy is witin this nibble
<> 157:ff67d9f36b67 508 if( (bit_position >= 0) && (bit_position < 4) )
<> 157:ff67d9f36b67 509 {
<> 157:ff67d9f36b67 510 // Last discrepancy is within this nibble
<> 157:ff67d9f36b67 511 // Set the bit of the last discrepancy bit
<> 157:ff67d9f36b67 512 search_direction |= (1 << (bit_position));
<> 157:ff67d9f36b67 513 }
<> 157:ff67d9f36b67 514
<> 157:ff67d9f36b67 515 // Performs two read bits and a write bit for 4 bits of the ROM
<> 157:ff67d9f36b67 516 readValue = OWM_TouchByte(owm, search_direction);
<> 157:ff67d9f36b67 517 // Get discrepancy flags
<> 157:ff67d9f36b67 518 discrepancy = readValue & 0xF;
<> 157:ff67d9f36b67 519 // Get the 4 bits sent to select the ROM
<> 157:ff67d9f36b67 520 sentBits = (readValue >> 4) & 0xF;
<> 157:ff67d9f36b67 521
<> 157:ff67d9f36b67 522 // Store the bit location of the MSB discrepancy with sentbit = 0
<> 157:ff67d9f36b67 523 if(discrepancy)
<> 157:ff67d9f36b67 524 {
<> 157:ff67d9f36b67 525 // Initialize bit_position to MSB of nibble
<> 157:ff67d9f36b67 526 bit_position = 3;
<> 157:ff67d9f36b67 527
<> 157:ff67d9f36b67 528 while(bit_position >= 0)
<> 157:ff67d9f36b67 529 {
<> 157:ff67d9f36b67 530 // Get discrepancy flag of the current bit position
<> 157:ff67d9f36b67 531 discrepancy_mask = discrepancy & (1 << bit_position);
<> 157:ff67d9f36b67 532
<> 157:ff67d9f36b67 533 // If there is a discrepancy and the sent bit is 0 save this bit position
<> 157:ff67d9f36b67 534 if( (discrepancy_mask) && !(sentBits & discrepancy_mask))
<> 157:ff67d9f36b67 535 {
<> 157:ff67d9f36b67 536 last_zero = nibble_start_bit + bit_position;
<> 157:ff67d9f36b67 537 break;
<> 157:ff67d9f36b67 538 }
<> 157:ff67d9f36b67 539
<> 157:ff67d9f36b67 540 bit_position--;
<> 157:ff67d9f36b67 541 }
<> 157:ff67d9f36b67 542 }
<> 157:ff67d9f36b67 543
<> 157:ff67d9f36b67 544 // Clear the nibble
<> 157:ff67d9f36b67 545 ROMCode[rom_byte_number] &= ~rom_nibble_mask;
<> 157:ff67d9f36b67 546
<> 157:ff67d9f36b67 547 // Store the sentBits in the ROMCode
<> 157:ff67d9f36b67 548 if(rom_nibble_mask > 0x0F) {
<> 157:ff67d9f36b67 549 ROMCode[rom_byte_number] |= (sentBits << 4);
<> 157:ff67d9f36b67 550 }
<> 157:ff67d9f36b67 551 else {
<> 157:ff67d9f36b67 552 ROMCode[rom_byte_number] |= sentBits;
<> 157:ff67d9f36b67 553 }
<> 157:ff67d9f36b67 554
<> 157:ff67d9f36b67 555 // Increment the nibble start bit and shift mask
<> 157:ff67d9f36b67 556 nibble_start_bit += 4;
<> 157:ff67d9f36b67 557 rom_nibble_mask <<= 4;
<> 157:ff67d9f36b67 558
<> 157:ff67d9f36b67 559 // If the mask is 0 then go to new ROM byte rom_byte_number and reset mask
<> 157:ff67d9f36b67 560 if (rom_nibble_mask == 0)
<> 157:ff67d9f36b67 561 {
<> 157:ff67d9f36b67 562 rom_byte_number++;
<> 157:ff67d9f36b67 563 rom_nibble_mask = 0x0F;
<> 157:ff67d9f36b67 564 }
<> 157:ff67d9f36b67 565
<> 157:ff67d9f36b67 566 } // End while(rom_byte_number < 8)
<> 157:ff67d9f36b67 567
<> 157:ff67d9f36b67 568 // Clear search ROM accelerator
<> 157:ff67d9f36b67 569 owm->ctrl_stat &= ~(MXC_F_OWM_CTRL_STAT_SRA_MODE);
<> 157:ff67d9f36b67 570
<> 157:ff67d9f36b67 571 // Calculate CRC to verify ROM code is correct
<> 157:ff67d9f36b67 572 crc8 = CalculateCRC8(ROMCode, 7);
<> 157:ff67d9f36b67 573
<> 157:ff67d9f36b67 574 // If the search was successful then
<> 157:ff67d9f36b67 575 if ((nibble_start_bit >= 65) && (crc8 == ROMCode[7]))
<> 157:ff67d9f36b67 576 {
<> 157:ff67d9f36b67 577 // Search successful so set LastDiscrepancy,LastDeviceFlag,search_result
<> 157:ff67d9f36b67 578 LastDiscrepancy = last_zero;
<> 157:ff67d9f36b67 579
<> 157:ff67d9f36b67 580 // Check for last device
<> 157:ff67d9f36b67 581 if (LastDiscrepancy == 0) {
<> 157:ff67d9f36b67 582 LastDeviceFlag = 1;
<> 157:ff67d9f36b67 583 }
<> 157:ff67d9f36b67 584
<> 157:ff67d9f36b67 585 search_result = 1;
<> 157:ff67d9f36b67 586 }
<> 157:ff67d9f36b67 587 } // End if (OWM_Reset)
<> 157:ff67d9f36b67 588
<> 157:ff67d9f36b67 589 // If no device found then reset counters so next 'search' will be like a first
<> 157:ff67d9f36b67 590 if (!search_result || !ROMCode[0])
<> 157:ff67d9f36b67 591 {
<> 157:ff67d9f36b67 592 LastDiscrepancy = 0;
<> 157:ff67d9f36b67 593 LastDeviceFlag = 0;
<> 157:ff67d9f36b67 594 search_result = 0;
<> 157:ff67d9f36b67 595 }
<> 157:ff67d9f36b67 596
<> 157:ff67d9f36b67 597 return search_result;
<> 157:ff67d9f36b67 598 }
<> 157:ff67d9f36b67 599
<> 157:ff67d9f36b67 600 /*
<> 157:ff67d9f36b67 601 * Calcualate CRC8 of the buffer of data provided
<> 157:ff67d9f36b67 602 */
<> 157:ff67d9f36b67 603 uint8_t CalculateCRC8(uint8_t* data, int len)
<> 157:ff67d9f36b67 604 {
<> 157:ff67d9f36b67 605 int i;
<> 157:ff67d9f36b67 606 uint8_t crc = 0;
<> 157:ff67d9f36b67 607
<> 157:ff67d9f36b67 608 for(i = 0; i < len; i++)
<> 157:ff67d9f36b67 609 {
<> 157:ff67d9f36b67 610 crc = update_crc8(crc, data[i]);
<> 157:ff67d9f36b67 611 }
<> 157:ff67d9f36b67 612
<> 157:ff67d9f36b67 613 return crc;
<> 157:ff67d9f36b67 614 }
<> 157:ff67d9f36b67 615
<> 157:ff67d9f36b67 616 /*
<> 157:ff67d9f36b67 617 * Calculate the CRC8 of the byte value provided with the current crc value
<> 157:ff67d9f36b67 618 * provided Returns updated crc value
<> 157:ff67d9f36b67 619 */
<> 157:ff67d9f36b67 620 uint8_t update_crc8(uint8_t crc, uint8_t val)
<> 157:ff67d9f36b67 621 {
<> 157:ff67d9f36b67 622 uint8_t inc, tmp;
<> 157:ff67d9f36b67 623
<> 157:ff67d9f36b67 624 for (inc = 0; inc < 8; inc++)
<> 157:ff67d9f36b67 625 {
<> 157:ff67d9f36b67 626 tmp = (uint8_t)(crc << 7); // Save X7 bit value
<> 157:ff67d9f36b67 627 crc >>= 1; // Shift crc
<> 157:ff67d9f36b67 628 if (((tmp >> 7) ^ (val & 0x01)) == 1) // If X7 xor X8 (input data)
<> 157:ff67d9f36b67 629 {
<> 157:ff67d9f36b67 630 crc ^= 0x8c; // XOR crc with X4 and X5, X1 = X7^X8
<> 157:ff67d9f36b67 631 crc |= 0x80; // Carry
<> 157:ff67d9f36b67 632 }
<> 157:ff67d9f36b67 633 val >>= 1;
<> 157:ff67d9f36b67 634 }
<> 157:ff67d9f36b67 635
<> 157:ff67d9f36b67 636 return crc;
<> 157:ff67d9f36b67 637 }
<> 157:ff67d9f36b67 638
<> 157:ff67d9f36b67 639 /**@} end of group owm */