aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/sensor/yas_pcb_test.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/sensor/yas_pcb_test.c')
-rw-r--r--drivers/sensor/yas_pcb_test.c1282
1 files changed, 1282 insertions, 0 deletions
diff --git a/drivers/sensor/yas_pcb_test.c b/drivers/sensor/yas_pcb_test.c
new file mode 100644
index 0000000..686c8c6
--- /dev/null
+++ b/drivers/sensor/yas_pcb_test.c
@@ -0,0 +1,1282 @@
+/*
+ * Copyright (c) 2010-2011 Yamaha Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+/*
+ * File yas_pcb_test.c
+ * Brief pcb test program for yas530/yas532
+ * Date 2013/1/22
+ * Revision 1.4.3
+ */
+#include "yas_pcb_test.h"
+
+/* define */
+/* reg num */
+#define YAS530_CAL_REG_NUM (16)
+#define YAS532_CAL_REG_NUM (14)
+#define YAS_PCB_MEASURE_DATA_REG_NUM (8)
+
+/* default value */
+#define YAS_PCB_TEST1_DEFAULT (0x00)
+#define YAS_PCB_TEST2_DEFAULT (0x00)
+#define YAS_PCB_INTERVAL_DEFAULT (0x00)
+#define YAS_PCB_CONFIG_DEFAULT (0x01) /* INTON = 1 */
+#define YAS_PCB_COIL_DEFAULT (0x00)
+
+/* measure command */
+#define YAS_PCB_MEASURE_COMMAND_START (0x01)
+#define YAS_PCB_MEASURE_COMMAND_LDTC (0x02)
+#define YAS_PCB_MEASURE_COMMAND_FORS (0x04)
+
+#define YAS_PCB_MEASURE_BUSY (0x80)
+
+#define YAS_PCB_MEASURE_WAIT_TIME (2) /* ms */
+#define YAS_PCB_HARD_OFFSET_CORRECT (16)
+#define YAS_PCB_COIL_INIT_CALC_NUM (5)
+
+#define YAS_PCB_HARD_OFFSET_MASK (0x3F)
+
+#define YAS_PCB_INT_CHECK (1)
+#define YAS_PCB_INT_NOTCHECK (0)
+#define YAS_PCB_INT_HIGH (1)
+#define YAS_PCB_INT_LOW (0)
+
+#define YAS_PCB_ACC_Z (9806550L) /* m/s2 */
+
+#define YAS530_DEVICE_ID (0x01) /* MS-3E */
+#define YAS532_DEVICE_ID (0x02) /* MS-3R */
+
+#define YAS530_VERSION_A (0) /* MS-3E Aver */
+#define YAS530_VERSION_B (1) /* MS-3E Bver */
+/*#define YAS530_VERSION_AB (0)*/ /* MS-3R ABver */
+#define YAS532_VERSION_AC (1) /* MS-3R ACver */
+
+#define YAS530_COEF_VERSION_A (380)
+#define YAS530_COEF_VERSION_B (550)
+/*#define YAS532_COEF_VERSION_AB (1800)*/
+/*#define YAS532_COEF_VERSION_AC (900)*/
+#define YAS532_COEFX_VERSION_AC (850)
+#define YAS532_COEFY1_VERSION_AC (750)
+#define YAS532_COEFY2_VERSION_AC (750)
+
+#define YAS530_RAWDATA_CENTER (2048)
+#define YAS530_RAWDATA_OVERFLOW (4095)
+#define YAS532_RAWDATA_CENTER (4096)
+#define YAS532_RAWDATA_OVERFLOW (8190)
+
+#define YAS_PCB_DIR_DIVIDER (400)
+
+#define YAS_PCB_TEST1 (0)
+#define YAS_PCB_TEST3 (1)
+#define YAS_PCB_TEST4 (2)
+#define YAS_PCB_TEST5 (3)
+#define YAS_PCB_TEST6 (4)
+#define YAS_PCB_TEST7 (5)
+#define YAS_PCB_TEST8 (6)
+#define YAS_PCB_TEST2 (7)
+#define YAS_PCB_TEST_NUM (8)
+
+/* typedef */
+struct yas_pcb_vector {
+ int32_t v[3];
+};
+
+struct yas_pcb_correction {
+ int32_t s32Cx, s32Cy1, s32Cy2;
+ int32_t s32A2, s32A3, s32A4, s32A5, s32A6, s32A7, s32A8, s32A9, s32K;
+ int32_t s32ZFlag;
+ int32_t s32Rx, s32Ry1, s32Ry2;
+ int32_t s32Fx, s32Fy1, s32Fy2;
+ int32_t s32Ver;
+};
+
+struct yas_pcb_sensitivity {
+ int32_t s32Sx, s32Sy, s32Sz;
+};
+
+/* values */
+static uint16_t gu16State;
+static struct yas_pcb_test_callback g_callback;
+static struct yas_pcb_vector gstXy1y2;
+static int8_t gs08HardOffset[3];
+static struct yas_pcb_correction gstCorrect;
+static uint8_t gu08DevId;
+static int32_t gs32Center;
+static int32_t gs32Overflow;
+#ifdef YAS_PCBTEST_EXTRA
+static uint8_t gu08Recalc;
+static int32_t gs32RecalcWait;
+#endif
+
+/* functions */
+static int Ms3AxesLibAtan8(int, int, short *);
+static int Ms3AxesLibDir8(int, int, unsigned short *);
+static int yas_pcb_check_state(int);
+static void yas_pcb_update_state(int);
+static int yas_pcb_power_on(void);
+static int yas_pcb_power_off(void);
+static int yas_pcb_reset_coil(void);
+static int yas530_read_cal(uint8_t *);
+static int yas532_read_cal(uint8_t *);
+static void yas530_calc_correction(const uint8_t *);
+static void yas532_calc_correction(const uint8_t *);
+static int yas_pcb_set_offset(const int8_t *);
+static int yas_pcb_measure(struct yas_pcb_vector *, int *, uint8_t, uint8_t);
+static int yas_pcb_is_flow_occued(struct yas_pcb_vector *, int32_t, int32_t);
+static void yas_pcb_calc_sensitivity(struct yas_pcb_vector *,
+ int, struct yas_pcb_sensitivity *);
+static void yas_pcb_calc_position(struct yas_pcb_vector *,
+ struct yas_pcb_vector *, int);
+static int yas_pcb_calc_magnetic_field(struct yas_pcb_vector *,
+ struct yas_pcb_vector *);
+static int yas_pcb_test1(int *);
+static int yas_pcb_test2(void);
+static int yas_pcb_test3(void);
+static int yas_pcb_test4(int *, int *, int *);
+static int yas_pcb_test5(int *);
+static int yas_pcb_test6(int *, int *);
+#ifdef YAS_PCBTEST_EXTRA
+static int yas_pcb_test7(int *, int *, int *);
+#endif
+
+static int Ms3AxesLibAtan8(int ss, int cc, short *ans)
+{
+ static const unsigned char AtanTable[] = {
+ 0, 1, 3, 5, 6, 8, 11, 13,
+ 15, 18, 21, 24, 27, 31, 34, 39,
+ 43, 48, 53, 58, 63, 69, 75, 82,
+ 89, 96, 103, 110, 118, 126, 134, 143,
+ 152
+ };
+
+ unsigned char idx;
+ unsigned short idx_mul64;
+ signed char sign = 1;
+ unsigned int ucc;
+ unsigned int uss;
+ unsigned short ans_mul8;
+ unsigned char idx_mod64;
+ unsigned short ans_diff8;
+
+ if (cc < 0) {
+ sign = -sign;
+ ucc = -cc;
+ } else {
+ ucc = cc;
+ }
+
+ if (ss < 0) {
+ sign = -sign;
+ uss = -ss;
+ } else {
+ uss = ss;
+ }
+
+ while (ucc >= 0x400) {
+ ucc >>= 1;
+ uss >>= 1;
+ }
+
+ if (ucc == 0)
+ return -1;
+
+ idx_mul64 = (uss << 11) / ucc;
+
+ idx = idx_mul64 >> 6;
+ ans_mul8 = (idx << 4) - AtanTable[idx];
+
+ idx_mod64 = (unsigned char)idx_mul64 & 0x3f;
+
+ if (idx < 32) {
+ idx++;
+ ans_diff8 = (idx << 4) - AtanTable[idx] - ans_mul8;
+ ans_mul8 += (ans_diff8 * idx_mod64) >> 6;
+ }
+
+ *ans = (sign == 1) ? ans_mul8 : (-ans_mul8);
+
+ return 0;
+}
+
+static int Ms3AxesLibDir8(int ss, int cc, unsigned short *ans)
+{
+ short temp_ans = 0;
+ int ucc = cc;
+ int uss = ss;
+ int ret = 0;
+
+ if (cc < -2147483647)
+ cc++;
+ if (ss < -2147483647)
+ ss++;
+
+ if (cc < 0)
+ ucc = -cc;
+
+ if (ss < 0)
+ uss = -ss;
+
+ if (uss <= ucc) {
+ ret = Ms3AxesLibAtan8(ss, cc, &temp_ans);
+ if (ret < 0)
+ return 1;
+
+ if (cc > 0) {
+ if (temp_ans < 0)
+ temp_ans += 2880;
+ } else
+ temp_ans += 1440;
+ } else {
+ ret = Ms3AxesLibAtan8(cc, ss, &temp_ans);
+ if (ret < 0)
+ return 1;
+
+ if (ss > 0)
+ temp_ans = 720 - temp_ans;
+ else
+ temp_ans = 2160 - temp_ans;
+ }
+
+ *ans = temp_ans;
+
+ return 0;
+}
+
+static int yas_pcb_check_state(int id)
+{
+ int result = YAS_PCB_ERROR_TEST_ORDER;
+ uint16_t u16Mask;
+ const uint16_t u16TestTable[] = {
+ 0x0000, /* 1 */
+ 0x0000, /* 3 */
+ (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3), /* 4 */
+ (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3)
+ | (1 << YAS_PCB_TEST4), /* 5 */
+ (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3)
+ | (1 << YAS_PCB_TEST4), /* 6 */
+ (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3)
+ | (1 << YAS_PCB_TEST4) /* 7 */
+ | (1 << YAS_PCB_TEST5),
+ (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3)
+ | (1 << YAS_PCB_TEST4), /* 8 */
+ (1 << YAS_PCB_TEST1), /* 2 */
+ };
+
+ if ((YAS_PCB_TEST1 <= id) && (id < YAS_PCB_TEST_NUM)) {
+ u16Mask = u16TestTable[id];
+ if (u16Mask == 0) {
+ switch (id) {
+ case YAS_PCB_TEST1:
+ if ((gu16State == 0)
+ || (gu16State == (1 << YAS_PCB_TEST1)))
+ result = YAS_PCB_NO_ERROR;
+ break;
+
+ case YAS_PCB_TEST3:
+ if ((gu16State == (1 << YAS_PCB_TEST1))
+ || (gu16State ==
+ ((1 << YAS_PCB_TEST1)
+ | (1 << YAS_PCB_TEST3))))
+ result = YAS_PCB_NO_ERROR;
+ break;
+
+ default:
+ break;
+ }
+ } else {
+ if ((gu16State & u16Mask) == u16Mask)
+ result = YAS_PCB_NO_ERROR;
+ }
+ }
+
+ return result;
+}
+
+static void yas_pcb_update_state(int id)
+{
+ if ((YAS_PCB_TEST1 <= id) && (id < YAS_PCB_TEST2))
+ gu16State |= (uint16_t)(1 << id);
+ else
+ gu16State = 0;
+}
+
+static int yas_pcb_power_on(void)
+{
+ int result = YAS_PCB_NO_ERROR;
+ int ret;
+
+ if (NULL != g_callback.power_on) {
+ ret = g_callback.power_on();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_POWER;
+ }
+
+ return result;
+}
+
+static int yas_pcb_power_off(void)
+{
+ int result = YAS_PCB_NO_ERROR;
+ int ret;
+
+ if (NULL != g_callback.power_off) {
+ ret = g_callback.power_off();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_POWER;
+ }
+
+ return result;
+}
+
+static int yas_pcb_reset_coil(void)
+{
+ int ret;
+ uint8_t u08Data;
+ u08Data = YAS_PCB_COIL_DEFAULT;
+ ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_COIL,
+ &u08Data, 1);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ return YAS_PCB_NO_ERROR;
+}
+static int yas530_read_cal(uint8_t *pu08Buf)
+{
+ int i;
+ int ret;
+ int size = YAS530_CAL_REG_NUM;
+
+ /* Dummy read */
+ ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL,
+ pu08Buf, size);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL,
+ pu08Buf, size);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ /* cal register is all 0 */
+ for (i = 0; i < size; i++) {
+ if (pu08Buf[i] != 0x00)
+ return YAS_PCB_NO_ERROR;
+ }
+
+ return YAS_PCB_ERROR_CALREG;
+}
+
+
+static int yas532_read_cal(uint8_t *pu08Buf)
+{
+ int i;
+ int ret;
+ int size = YAS532_CAL_REG_NUM;
+ int len = size - 1;
+
+ /* Dummy read */
+ ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL,
+ pu08Buf, size);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL,
+ pu08Buf, size);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ /* cal register is all 0 */
+ for (i = 0; i < len; i++) {
+ if (pu08Buf[i] != 0x00)
+ return YAS_PCB_NO_ERROR;
+ }
+
+ /* MSB is not 0 */
+ if (pu08Buf[len] & 0x80)
+ return YAS_PCB_NO_ERROR;
+
+ return YAS_PCB_ERROR_CALREG;
+}
+
+static void yas530_calc_correction(const uint8_t *pu08Data)
+{
+ uint8_t u08Dx = pu08Data[0];
+ uint8_t u08Dy1 = pu08Data[1];
+ uint8_t u08Dy2 = pu08Data[2];
+ uint8_t u08D2 = (uint8_t)((pu08Data[3] >> 2) & 0x3F);
+ uint8_t u08D3 = (uint8_t)(((pu08Data[3] << 2) & 0x0C)
+ | ((pu08Data[4] >> 6) & 0x03));
+ uint8_t u08D4 = (uint8_t)(pu08Data[4] & 0x3F);
+ uint8_t u08D5 = (uint8_t)((pu08Data[5] >> 2) & 0x3f);
+ uint8_t u08D6 = (uint8_t)(((pu08Data[5] << 4) & 0x30)
+ | ((pu08Data[6] >> 4) & 0x0F));
+ uint8_t u08D7 = (uint8_t)(((pu08Data[6] << 3) & 0x78)
+ | ((pu08Data[7] >> 5) & 0x07));
+ uint8_t u08D8 = (uint8_t)(((pu08Data[7] << 1) & 0x3E)
+ | ((pu08Data[8] >> 7) & 0x01));
+ uint8_t u08D9 = (uint8_t)(((pu08Data[8] << 1) & 0xFE)
+ | ((pu08Data[9] >> 7) & 0x01));
+ uint8_t u08D0 = (uint8_t)((pu08Data[9] >> 2) & 0x1F);
+ uint8_t u08ZFlag = (uint8_t)((pu08Data[11] >> 5) & 0x01);
+ uint8_t u08Rx = (uint8_t)(((pu08Data[11] << 1) & 0x3E)
+ | ((pu08Data[12] >> 7) & 0x01));
+ uint8_t u08Fx = (uint8_t)((pu08Data[12] >> 5) & 0x03);
+ uint8_t u08Ry1 = (uint8_t)(((pu08Data[12] << 1) & 0x3E)
+ | ((pu08Data[13] >> 7) & 0x01));
+ uint8_t u08Fy1 = (uint8_t)((pu08Data[13] >> 5) & 0x03);
+ uint8_t u08Ry2 = (uint8_t)(((pu08Data[13] << 1) & 0x3E)
+ | ((pu08Data[14] >> 7) & 0x01));
+ uint8_t u08Fy2 = (uint8_t)((pu08Data[14] >> 5) & 0x03);
+ uint8_t u08Ver = pu08Data[15] & 0x07;
+
+ gstCorrect.s32Cx = (int32_t)((u08Dx * 6) - 768);
+ gstCorrect.s32Cy1 = (int32_t)((u08Dy1 * 6) - 768);
+ gstCorrect.s32Cy2 = (int32_t)((u08Dy2 * 6) - 768);
+ gstCorrect.s32A2 = (int32_t)(u08D2 - 32);
+ gstCorrect.s32A3 = (int32_t)(u08D3 - 8);
+ gstCorrect.s32A4 = (int32_t)(u08D4 - 32);
+ gstCorrect.s32A5 = (int32_t)(u08D5 + 38);
+ gstCorrect.s32A6 = (int32_t)(u08D6 - 32);
+ gstCorrect.s32A7 = (int32_t)(u08D7 - 64);
+ gstCorrect.s32A8 = (int32_t)(u08D8 - 32);
+ gstCorrect.s32A9 = (int32_t)u08D9;
+ gstCorrect.s32K = (int32_t)(u08D0) + 10;
+ gstCorrect.s32ZFlag = (int32_t)u08ZFlag;
+ gstCorrect.s32Rx = (int32_t)((int8_t)(u08Rx << 2) >> 2);
+ gstCorrect.s32Fx = (int32_t)u08Fx;
+ gstCorrect.s32Ry1 = (int32_t)((int8_t)(u08Ry1 << 2) >> 2);
+ gstCorrect.s32Fy1 = (int32_t)u08Fy1;
+ gstCorrect.s32Ry2 = (int32_t)((int8_t)(u08Ry2 << 2) >> 2);
+ gstCorrect.s32Fy2 = (int32_t)u08Fy2;
+ gstCorrect.s32Ver = (int32_t)u08Ver;
+}
+
+static void yas532_calc_correction(const uint8_t *pu08Data)
+{
+ uint8_t u08Dx = pu08Data[0];
+ uint8_t u08Dy1 = pu08Data[1];
+ uint8_t u08Dy2 = pu08Data[2];
+ uint8_t u08D2 = (uint8_t)((pu08Data[3] >> 2) & 0x3F);
+ uint8_t u08D3 = (uint8_t)(((pu08Data[3] << 2) & 0x0C)
+ | ((pu08Data[4] >> 6) & 0x03));
+ uint8_t u08D4 = (uint8_t)(pu08Data[4] & 0x3F);
+ uint8_t u08D5 = (uint8_t)((pu08Data[5] >> 2) & 0x3f);
+ uint8_t u08D6 = (uint8_t)(((pu08Data[5] << 4) & 0x30)
+ | ((pu08Data[6] >> 4) & 0x0F));
+ uint8_t u08D7 = (uint8_t)(((pu08Data[6] << 3) & 0x78)
+ | ((pu08Data[7] >> 5) & 0x07));
+ uint8_t u08D8 = (uint8_t)(((pu08Data[7] << 1) & 0x3E)
+ | ((pu08Data[8] >> 7) & 0x01));
+ uint8_t u08D9 = (uint8_t)(((pu08Data[8] << 1) & 0xFE)
+ | ((pu08Data[9] >> 7) & 0x01));
+ uint8_t u08D0 = (uint8_t)((pu08Data[9] >> 2) & 0x1F);
+ uint8_t u08Rx = (uint8_t)((pu08Data[10] >> 1) & 0x3F);
+ uint8_t u08Fx = (uint8_t)(((pu08Data[10] & 0x01) << 1)
+ | ((pu08Data[11] >> 7) & 0x01));
+ uint8_t u08Ry1 = (uint8_t)((pu08Data[11] >> 1) & 0x3F);
+ uint8_t u08Fy1 = (uint8_t)(((pu08Data[11] & 0x01) << 1)
+ | ((pu08Data[12] >> 7) & 0x01));
+ uint8_t u08Ry2 = (uint8_t)((pu08Data[12] >> 1) & 0x3F);
+ uint8_t u08Fy2 = (uint8_t)(((pu08Data[12] & 0x01) << 1)
+ | ((pu08Data[13] >> 7) & 0x01));
+ uint8_t u08Ver = pu08Data[13] & 0x01;
+
+ gstCorrect.s32Cx = (int32_t)((u08Dx * 10) - 1280);
+ gstCorrect.s32Cy1 = (int32_t)((u08Dy1 * 10) - 1280);
+ gstCorrect.s32Cy2 = (int32_t)((u08Dy2 * 10) - 1280);
+ gstCorrect.s32A2 = (int32_t)(u08D2 - 32);
+ gstCorrect.s32A3 = (int32_t)(u08D3 - 8);
+ gstCorrect.s32A4 = (int32_t)(u08D4 - 32);
+ gstCorrect.s32A5 = (int32_t)(u08D5 + 38);
+ gstCorrect.s32A6 = (int32_t)(u08D6 - 32);
+ gstCorrect.s32A7 = (int32_t)(u08D7 - 64);
+ gstCorrect.s32A8 = (int32_t)(u08D8 - 32);
+ gstCorrect.s32A9 = (int32_t)u08D9;
+ gstCorrect.s32K = (int32_t)u08D0;
+ gstCorrect.s32ZFlag = (int32_t)1;
+ gstCorrect.s32Rx = (int32_t)((int8_t)(u08Rx << 2) >> 2);
+ gstCorrect.s32Fx = (int32_t)u08Fx;
+ gstCorrect.s32Ry1 = (int32_t)((int8_t)(u08Ry1 << 2) >> 2);
+ gstCorrect.s32Fy1 = (int32_t)u08Fy1;
+ gstCorrect.s32Ry2 = (int32_t)((int8_t)(u08Ry2 << 2) >> 2);
+ gstCorrect.s32Fy2 = (int32_t)u08Fy2;
+ gstCorrect.s32Ver = (int32_t)u08Ver;
+}
+
+static int yas_pcb_set_offset(const int8_t *ps08Offset)
+{
+ int result = YAS_PCB_NO_ERROR;
+ int ret;
+ uint8_t u08Addr;
+ uint8_t u08Data;
+ uint8_t i;
+
+ for (i = 0; i < 3; i++) {
+ u08Addr = (uint8_t)(YAS_PCB_ADDR_OFFSET + i);
+ u08Data = (uint8_t)ps08Offset[i] & YAS_PCB_HARD_OFFSET_MASK;
+ ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE,
+ u08Addr, &u08Data, 1);
+ if (0 != ret) {
+ result = YAS_PCB_ERROR_I2C;
+ break;
+ }
+ }
+
+ return result;
+}
+
+static int yas_pcb_measure(struct yas_pcb_vector *pstXy1y2, int *temperature,
+ uint8_t u08Command, uint8_t u08CheckIni)
+{
+ int ret;
+ uint8_t u08Buf[YAS_PCB_MEASURE_DATA_REG_NUM];
+ int low_or_high;
+
+ if ((YAS_PCB_INT_CHECK == u08CheckIni)
+ && (NULL != g_callback.read_intpin)) {
+ ret = g_callback.read_intpin(&low_or_high);
+ if ((0 != ret) || (YAS_PCB_INT_HIGH != low_or_high))
+ return YAS_PCB_ERROR_INTERRUPT;
+ }
+
+ ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE,
+ YAS_PCB_ADDR_MEASURE_COMMAND,
+ &u08Command, 1);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ g_callback.msleep(YAS_PCB_MEASURE_WAIT_TIME);
+
+ if ((YAS_PCB_INT_CHECK == u08CheckIni)
+ && (NULL != g_callback.read_intpin)) {
+ ret = g_callback.read_intpin(&low_or_high);
+ if ((0 != ret) || (YAS_PCB_INT_LOW != low_or_high))
+ return YAS_PCB_ERROR_INTERRUPT;
+ }
+
+ ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_MEASURE_DATA,
+ u08Buf, YAS_PCB_MEASURE_DATA_REG_NUM);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ /* calc measure data */
+ if (YAS532_DEVICE_ID == gu08DevId) {
+ *temperature = (((int32_t)(u08Buf[0] & 0x7F) << 3)
+ | ((u08Buf[1] >> 5) & 0x07));
+ pstXy1y2->v[0] = (int32_t)(((int32_t)(u08Buf[2] & 0x7F) << 6)
+ | ((u08Buf[3] >> 2) & 0x3F));
+ pstXy1y2->v[1] = (int32_t)(((int32_t)(u08Buf[4] & 0x7F) << 6)
+ | ((u08Buf[5] >> 2) & 0x3F));
+ pstXy1y2->v[2] = (int32_t)(((int32_t)(u08Buf[6] & 0x7F) << 6)
+ | ((u08Buf[7] >> 2) & 0x3F));
+ } else {
+ *temperature = (((int32_t)(u08Buf[0] & 0x7F) << 2)
+ | ((u08Buf[1] >> 6) & 0x03));
+ pstXy1y2->v[0] = (int32_t)(((int32_t)(u08Buf[2] & 0x7F) << 5)
+ | ((u08Buf[3] >> 3) & 0x1F));
+ pstXy1y2->v[1] = (int32_t)(((int32_t)(u08Buf[4] & 0x7F) << 5)
+ | ((u08Buf[5] >> 3) & 0x1F));
+ pstXy1y2->v[2] = (int32_t)(((int32_t)(u08Buf[6] & 0x7F) << 5)
+ | ((u08Buf[7] >> 3) & 0x1F));
+ }
+
+ if (YAS_PCB_MEASURE_BUSY == (u08Buf[0] & YAS_PCB_MEASURE_BUSY))
+ return YAS_PCB_ERROR_BUSY;
+
+ return YAS_PCB_NO_ERROR;
+}
+
+static int yas_pcb_is_flow_occued(struct yas_pcb_vector *pstXy1y2,
+ int32_t underflow, int32_t overflow)
+{
+ int result = YAS_PCB_NO_ERROR;
+ int32_t s32Tmp;
+ uint8_t i;
+
+ for (i = 0; i < 3; i++) {
+ s32Tmp = pstXy1y2->v[i];
+ if (s32Tmp <= underflow)
+ result = YAS_PCB_ERROR_UNDERFLOW;
+ else
+ if (overflow <= s32Tmp)
+ result = YAS_PCB_ERROR_OVERFLOW;
+ }
+
+ return result;
+}
+
+static void yas_pcb_calc_sensitivity(struct yas_pcb_vector *pstXy1y2,
+ int temperature, struct yas_pcb_sensitivity *pstYasSensitivity)
+{
+ /* calc XYZ data from xy1y2 data */
+ int32_t s32Sx = pstXy1y2->v[0]
+ - ((gstCorrect.s32Cx * temperature) / 100);
+ int32_t s32Sy1 = pstXy1y2->v[1]
+ - ((gstCorrect.s32Cy1 * temperature) / 100);
+ int32_t s32Sy2 = pstXy1y2->v[2]
+ - ((gstCorrect.s32Cy2 * temperature) / 100);
+ int32_t s32Sy = s32Sy1 - s32Sy2;
+ int32_t s32Sz = -s32Sy1 - s32Sy2;
+
+ pstYasSensitivity->s32Sx = s32Sx;
+ pstYasSensitivity->s32Sy = s32Sy;
+ pstYasSensitivity->s32Sz = s32Sz;
+}
+
+static void yas_pcb_calc_position(struct yas_pcb_vector *pstXy1y2,
+ struct yas_pcb_vector *pstXyz, int temperature)
+{
+ struct yas_pcb_sensitivity stSensitivity;
+ struct yas_pcb_sensitivity *pst;
+
+ yas_pcb_calc_sensitivity(pstXy1y2, temperature, &stSensitivity);
+
+ pst = &stSensitivity;
+ pstXyz->v[0] = (gstCorrect.s32K
+ * ((100 * pst->s32Sx) + (gstCorrect.s32A2 * pst->s32Sy)
+ + (gstCorrect.s32A3 * pst->s32Sz))) / 10;
+ pstXyz->v[1] = (gstCorrect.s32K * ((gstCorrect.s32A4 * pst->s32Sx)
+ + (gstCorrect.s32A5 * pst->s32Sy)
+ + (gstCorrect.s32A6 * pst->s32Sz))) / 10;
+ pstXyz->v[2] = (gstCorrect.s32K * ((gstCorrect.s32A7 * pst->s32Sx)
+ + (gstCorrect.s32A8 * pst->s32Sy)
+ + (gstCorrect.s32A9 * pst->s32Sz))) / 10;
+}
+
+static void yas530_calc_magnetic_field(struct yas_pcb_vector *pstXy1y2,
+ struct yas_pcb_vector *pstXyz, int32_t s32Coef)
+{
+ int32_t s32Oy;
+ int32_t s32Oz;
+ static const int32_t s32HTbl[] = {
+ 1748, 1948, 2148, 2348
+ };
+
+ pstXy1y2->v[0] = gstXy1y2.v[0] - s32HTbl[gstCorrect.s32Fx]
+ + (gs08HardOffset[0] - gstCorrect.s32Rx) * s32Coef;
+ pstXy1y2->v[1] = gstXy1y2.v[1] - s32HTbl[gstCorrect.s32Fy1]
+ + (gs08HardOffset[1] - gstCorrect.s32Ry1) * s32Coef;
+ pstXy1y2->v[2] = gstXy1y2.v[2] - s32HTbl[gstCorrect.s32Fy2]
+ + (gs08HardOffset[2] - gstCorrect.s32Ry2) * s32Coef;
+ s32Oy = pstXy1y2->v[1] - pstXy1y2->v[2];
+ s32Oz = -pstXy1y2->v[1] - pstXy1y2->v[2];
+
+ pstXyz->v[0] = (gstCorrect.s32K
+ * ((100 * pstXy1y2->v[0])
+ + (gstCorrect.s32A2 * s32Oy)
+ + (gstCorrect.s32A3 * s32Oz))) / 10;
+ pstXyz->v[1] = (gstCorrect.s32K
+ * ((gstCorrect.s32A4 * pstXy1y2->v[0])
+ + (gstCorrect.s32A5 * s32Oy)
+ + (gstCorrect.s32A6 * s32Oz))) / 10;
+ pstXyz->v[2] = (gstCorrect.s32K
+ * ((gstCorrect.s32A7 * pstXy1y2->v[0])
+ + (gstCorrect.s32A8 * s32Oy)
+ + (gstCorrect.s32A9 * s32Oz))) / 10;
+}
+
+static void yas532_calc_magnetic_field(struct yas_pcb_vector *pstXy1y2,
+ struct yas_pcb_vector *pstXyz,
+ int32_t s32CoefX, int32_t s32CoefY1, int32_t s32CoefY2)
+{
+ int32_t s32Oy;
+ int32_t s32Oz;
+ static const int32_t s32HTbl[] = {
+ 3721, 3971, 4221, 4471
+ };
+
+ pstXy1y2->v[0] = gstXy1y2.v[0] - s32HTbl[gstCorrect.s32Fx]
+ + (gs08HardOffset[0] - gstCorrect.s32Rx) * s32CoefX;
+ pstXy1y2->v[1] = gstXy1y2.v[1] - s32HTbl[gstCorrect.s32Fy1]
+ + (gs08HardOffset[1] - gstCorrect.s32Ry1) * s32CoefY1;
+ pstXy1y2->v[2] = gstXy1y2.v[2] - s32HTbl[gstCorrect.s32Fy2]
+ + (gs08HardOffset[2] - gstCorrect.s32Ry2) * s32CoefY2;
+ s32Oy = pstXy1y2->v[1] - pstXy1y2->v[2];
+ s32Oz = -pstXy1y2->v[1] - pstXy1y2->v[2];
+
+ pstXyz->v[0] = (gstCorrect.s32K
+ * ((100 * pstXy1y2->v[0])
+ + (gstCorrect.s32A2 * s32Oy)
+ + (gstCorrect.s32A3 * s32Oz))) / 10;
+ pstXyz->v[1] = (gstCorrect.s32K
+ * ((gstCorrect.s32A4 * pstXy1y2->v[0])
+ + (gstCorrect.s32A5 * s32Oy)
+ + (gstCorrect.s32A6 * s32Oz))) / 10;
+ pstXyz->v[2] = (gstCorrect.s32K
+ * ((gstCorrect.s32A7 * pstXy1y2->v[0])
+ + (gstCorrect.s32A8 * s32Oy)
+ + (gstCorrect.s32A9 * s32Oz))) / 10;
+}
+
+static int yas_pcb_calc_magnetic_field(struct yas_pcb_vector *pstXy1y2,
+ struct yas_pcb_vector *pstXyz)
+{
+ int32_t s32Coef;
+
+ if (YAS532_DEVICE_ID == gu08DevId) {
+ switch (gstCorrect.s32Ver) {
+ case YAS532_VERSION_AC:
+ break;
+
+ default:
+ return YAS_PCB_ERROR_I2C;
+ /* break; */
+ }
+
+ /* calculate Ohx/y/z[nT] */
+ yas532_calc_magnetic_field(pstXy1y2, pstXyz,
+ YAS532_COEFX_VERSION_AC,
+ YAS532_COEFY1_VERSION_AC,
+ YAS532_COEFY2_VERSION_AC);
+ } else {
+ switch (gstCorrect.s32Ver) {
+ case YAS530_VERSION_A:
+ s32Coef = YAS530_COEF_VERSION_A;
+ break;
+
+ case YAS530_VERSION_B:
+ s32Coef = YAS530_COEF_VERSION_B;
+ break;
+
+ default:
+ return YAS_PCB_ERROR_I2C;
+ /* break; */
+ }
+
+ /* calculate Ohx/y/z[nT] */
+ yas530_calc_magnetic_field(pstXy1y2, pstXyz, s32Coef);
+ }
+
+ return YAS_PCB_NO_ERROR;
+}
+
+static int yas_pcb_test1(int *id)
+{
+ int result;
+ int ret;
+
+ result = yas_pcb_power_on();
+ if (YAS_PCB_NO_ERROR == result) {
+ result = YAS_PCB_ERROR_I2C;
+ ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE,
+ YAS_PCB_ADDR_ID, &gu08DevId, 1);
+ if (0 == ret) {
+ *id = (int)gu08DevId;
+ result = YAS_PCB_NO_ERROR;
+ }
+ }
+
+ return result;
+}
+
+static int yas_pcb_test2(void)
+{
+ return yas_pcb_power_off();
+}
+
+static int yas_pcb_test3(void)
+{
+ int result;
+ int ret;
+ uint8_t u08Data;
+ uint8_t pu08Buf[YAS530_CAL_REG_NUM];
+
+ u08Data = YAS_PCB_TEST1_DEFAULT;
+ ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_TEST1,
+ &u08Data, 1);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ u08Data = YAS_PCB_TEST2_DEFAULT;
+ ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_TEST2,
+ &u08Data, 1);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ u08Data = YAS_PCB_INTERVAL_DEFAULT;
+ ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE,
+ YAS_PCB_ADDR_MEASURE_INTERVAL, &u08Data, 1);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ if (YAS532_DEVICE_ID == gu08DevId) {
+ gs32Center = YAS532_RAWDATA_CENTER;
+ gs32Overflow = YAS532_RAWDATA_OVERFLOW;
+ result = yas532_read_cal(pu08Buf);
+ if (YAS_PCB_NO_ERROR == result)
+ yas532_calc_correction(pu08Buf);
+ } else {
+ gs32Center = YAS530_RAWDATA_CENTER;
+ gs32Overflow = YAS530_RAWDATA_OVERFLOW;
+ result = yas530_read_cal(pu08Buf);
+ if (YAS_PCB_NO_ERROR == result)
+ yas530_calc_correction(pu08Buf);
+ }
+
+ if (YAS_PCB_NO_ERROR != result)
+ return result;
+
+ u08Data = (uint8_t)(YAS_PCB_CONFIG_DEFAULT
+ | (uint8_t)((pu08Buf[9] & 0x03) << 3)
+ | (uint8_t)((pu08Buf[10] & 0x80) >> 5));
+ ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE,
+ YAS_PCB_ADDR_CONFIG, &u08Data, 1);
+ if (0 != ret)
+ return YAS_PCB_ERROR_I2C;
+
+ ret = yas_pcb_reset_coil();
+ if (YAS_PCB_NO_ERROR != ret)
+ return ret;
+ return YAS_PCB_NO_ERROR;
+}
+
+static int yas_pcb_test4(int *x, int *y1, int *y2)
+{
+ int result;
+ struct yas_pcb_vector stXy1y2;
+ int temperature;
+ int32_t s32Tmp;
+ int8_t s08Correct = YAS_PCB_HARD_OFFSET_CORRECT;
+ uint8_t i;
+ uint8_t k;
+
+ gs08HardOffset[0] = 0;
+ gs08HardOffset[1] = 0;
+ gs08HardOffset[2] = 0;
+ result = yas_pcb_set_offset(&gs08HardOffset[0]);
+ if (YAS_PCB_NO_ERROR == result) {
+ /* calc hard offset */
+ for (i = 0; i < YAS_PCB_COIL_INIT_CALC_NUM; i++) {
+ result = yas_pcb_measure(&stXy1y2, &temperature,
+ YAS_PCB_MEASURE_COMMAND_START,
+ YAS_PCB_INT_NOTCHECK);
+ if (YAS_PCB_NO_ERROR != result)
+ break;
+
+ for (k = 0; k < 3; k++) {
+ s32Tmp = stXy1y2.v[k];
+ if (gs32Center < s32Tmp)
+ gs08HardOffset[k] += s08Correct;
+ else {
+ if (s32Tmp < gs32Center)
+ gs08HardOffset[k] -= s08Correct;
+ }
+ }
+
+ result = yas_pcb_set_offset(&gs08HardOffset[0]);
+ if (YAS_PCB_NO_ERROR != result)
+ break;
+
+ s08Correct = (int8_t)((uint8_t)s08Correct >> 1);
+ }
+
+ if (YAS_PCB_NO_ERROR == result) {
+ *x = (int)gs08HardOffset[0];
+ *y1 = (int)gs08HardOffset[1];
+ *y2 = (int)gs08HardOffset[2];
+ result = yas_pcb_is_flow_occued(&stXy1y2,
+ 0, gs32Overflow);
+ }
+ }
+
+ return result;
+}
+
+static int yas_pcb_test5(int *direction)
+{
+ uint16_t dir;
+ int result;
+ int ret;
+ int x;
+ int y;
+ int nTemp;
+ struct yas_pcb_vector stXyz;
+
+ result = yas_pcb_measure(&gstXy1y2, &nTemp,
+ YAS_PCB_MEASURE_COMMAND_START, YAS_PCB_INT_NOTCHECK);
+ if (YAS_PCB_NO_ERROR == result) {
+ result = YAS_PCB_ERROR_DIRCALC;
+ yas_pcb_calc_position(&gstXy1y2, &stXyz, nTemp);
+
+ x = -stXyz.v[0] / YAS_PCB_DIR_DIVIDER;
+ y = stXyz.v[1] / YAS_PCB_DIR_DIVIDER;
+ ret = Ms3AxesLibDir8(x, y, &dir);
+ if (0 == ret) {
+ *direction = (int)(dir / 8);
+ result = yas_pcb_is_flow_occued(&gstXy1y2,
+ 0, gs32Overflow);
+ }
+ }
+
+ return result;
+}
+
+static int yas_pcb_test6(int *sx, int *sy)
+{
+ int result;
+ struct yas_pcb_vector stXy1y2P;
+ struct yas_pcb_vector stXy1y2N;
+ int temperature;
+ uint8_t u08Command;
+ struct yas_pcb_vector *pP = &stXy1y2P;
+ struct yas_pcb_vector *pN = &stXy1y2N;
+ struct yas_pcb_correction *pC = &gstCorrect;
+
+ u08Command = YAS_PCB_MEASURE_COMMAND_START
+ | YAS_PCB_MEASURE_COMMAND_LDTC;
+ result = yas_pcb_measure(pP, &temperature,
+ u08Command, YAS_PCB_INT_CHECK);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ u08Command = YAS_PCB_MEASURE_COMMAND_START
+ | YAS_PCB_MEASURE_COMMAND_LDTC
+ | YAS_PCB_MEASURE_COMMAND_FORS;
+ result = yas_pcb_measure(pN, &temperature, u08Command,
+ YAS_PCB_INT_NOTCHECK);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ if (YAS532_DEVICE_ID == gu08DevId) {
+ *sx = (int)(pC->s32K * 100
+ * (pP->v[0] - pN->v[0]));
+ *sx /= 1000;
+ *sx /= YAS_VCORE;
+ *sy = (int)(pC->s32K * pC->s32A5
+ * ((pP->v[1] - pN->v[1])
+ - (pP->v[2] - pN->v[2])));
+ *sy /= 1000;
+ *sy /= YAS_VCORE;
+ } else {
+ *sx = (int)(pN->v[0] - pP->v[0]);
+ *sy = (int)((pN->v[1] - pP->v[1])
+ - (pN->v[2] - pP->v[2]));
+ }
+
+ result = yas_pcb_is_flow_occued(pP, 0, gs32Overflow);
+ if (YAS_PCB_NO_ERROR == result)
+ result = yas_pcb_is_flow_occued(pN,
+ 0, gs32Overflow);
+ }
+ }
+
+ return result;
+}
+
+#ifdef YAS_PCBTEST_EXTRA
+static int yas_pcb_test7(int *ohx, int *ohy, int *ohz)
+{
+ int nRet = YAS_PCB_ERROR_NOT_SUPPORTED;
+ struct yas_pcb_vector stOhxy1y2, stOhxyz;
+
+ if (0 != gstCorrect.s32ZFlag) {
+ nRet = yas_pcb_calc_magnetic_field(&stOhxy1y2, &stOhxyz);
+ if (YAS_PCB_NO_ERROR == nRet) {
+ /* [nT]->[uT] */
+ *ohx = stOhxyz.v[0] / 1000;
+ *ohy = stOhxyz.v[1] / 1000;
+ *ohz = stOhxyz.v[2] / 1000;
+ }
+ }
+
+ return nRet;
+}
+
+static int yas_pcb_test8(int *hx0, int *hy0, int *hz0)
+{
+ int nRet;
+ int nTemp;
+ int nX, nY1, nY2;
+ int32_t s32Underflow = 0;
+ int32_t s32Overflow = gs32Overflow;
+ struct yas_pcb_vector stOhxy1y2, stOhxyz;
+
+ if (YAS532_DEVICE_ID == gu08DevId) {
+ s32Underflow = YAS_PCB_NOISE_UNDERFLOW;
+ s32Overflow = YAS_PCB_NOISE_OVERFLOW;
+ }
+
+ if (gu08Recalc != 0) {
+ gs32RecalcWait++;
+ if (YAS_PCB_NOISE_INTERVAL <= gs32RecalcWait) {
+ nRet = yas_pcb_reset_coil();
+ if (YAS_PCB_NO_ERROR == nRet)
+ nRet = yas_pcb_test4(&nX, &nY1, &nY2);
+
+ if (YAS_PCB_NO_ERROR == nRet)
+ gu08Recalc = 0;
+
+ gs32RecalcWait = 0;
+ }
+ }
+
+ if (0 != gstCorrect.s32ZFlag) {
+ nRet = yas_pcb_measure(&gstXy1y2, &nTemp,
+ YAS_PCB_MEASURE_COMMAND_START,
+ YAS_PCB_INT_NOTCHECK);
+ if (YAS_PCB_NO_ERROR == nRet) {
+ nRet = yas_pcb_calc_magnetic_field(&stOhxy1y2,
+ &stOhxyz);
+ if (YAS_PCB_NO_ERROR == nRet) {
+ *hx0 = stOhxy1y2.v[0];
+ *hy0 = stOhxy1y2.v[1] - stOhxy1y2.v[2];
+ *hz0 = -stOhxy1y2.v[1] - stOhxy1y2.v[2];
+ nRet = yas_pcb_is_flow_occued(&gstXy1y2,
+ s32Underflow, s32Overflow);
+ if (YAS_PCB_NO_ERROR != nRet) {
+ if (gu08Recalc == 0) {
+ gu08Recalc++;
+ gs32RecalcWait = 0;
+ }
+ }
+ }
+ }
+ } else
+ nRet = YAS_PCB_ERROR_NOT_SUPPORTED;
+
+ return nRet;
+}
+
+#endif
+
+/* test 1 */
+static int power_on_and_device_check(int *id)
+{
+ int ret;
+ int result = yas_pcb_check_state(YAS_PCB_TEST1);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ if (id != NULL) {
+ result = YAS_PCB_ERROR_I2C;
+ ret = g_callback.i2c_open();
+ if (0 == ret) {
+ result = yas_pcb_test1(id);
+ ret = g_callback.i2c_close();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_I2C;
+ }
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST1);
+ } else
+ result = YAS_PCB_ERROR_ARG;
+ }
+
+ return result;
+}
+
+/* test 2 */
+static int power_off(void)
+{
+ int result = yas_pcb_check_state(YAS_PCB_TEST2);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ result = yas_pcb_test2();
+
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST2);
+ }
+
+ return result;
+}
+
+/* test 3 */
+static int initialization(void)
+{
+ int ret;
+ int result = yas_pcb_check_state(YAS_PCB_TEST3);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ result = YAS_PCB_ERROR_I2C;
+ ret = g_callback.i2c_open();
+ if (0 == ret) {
+ result = yas_pcb_test3();
+ ret = g_callback.i2c_close();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_I2C;
+ }
+
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST3);
+ }
+
+ return result;
+}
+
+/* test 4 */
+static int offset_control_measurement_and_set_offset_register(int *x,
+ int *y1, int *y2)
+{
+ int ret;
+ int result = yas_pcb_check_state(YAS_PCB_TEST4);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ if ((x != NULL) && (y1 != NULL) && (y2 != NULL)) {
+ result = YAS_PCB_ERROR_I2C;
+ ret = g_callback.i2c_open();
+ if (0 == ret) {
+ result = yas_pcb_test4(x, y1, y2);
+ ret = g_callback.i2c_close();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_I2C;
+ }
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST4);
+ } else
+ result = YAS_PCB_ERROR_ARG;
+ }
+
+ return result;
+}
+
+/* test 5 */
+static int direction_measurement(int *direction)
+{
+ int ret;
+ int result = yas_pcb_check_state(YAS_PCB_TEST5);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ if (direction != NULL) {
+ result = YAS_PCB_ERROR_I2C;
+ ret = g_callback.i2c_open();
+ if (0 == ret) {
+ result = yas_pcb_test5(direction);
+ ret = g_callback.i2c_close();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_I2C;
+ }
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST5);
+ } else
+ result = YAS_PCB_ERROR_ARG;
+ }
+
+ return result;
+}
+
+/* test 6 */
+static int sensitivity_measurement_of_magnetic_sensor_by_test_coil(
+ int *sx, int *sy)
+{
+ int ret;
+ int result = yas_pcb_check_state(YAS_PCB_TEST6);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ if ((sx != NULL) && (sy != NULL)) {
+ result = YAS_PCB_ERROR_I2C;
+ ret = g_callback.i2c_open();
+ if (0 == ret) {
+ result = yas_pcb_test6(sx, sy);
+ ret = g_callback.i2c_close();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_I2C;
+ }
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST6);
+ } else
+ result = YAS_PCB_ERROR_ARG;
+ }
+
+ return result;
+}
+
+/* test 7 */
+static int magnetic_field_level_check(int *ohx, int *ohy, int *ohz)
+{
+#ifdef YAS_PCBTEST_EXTRA
+ int result = yas_pcb_check_state(YAS_PCB_TEST7);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ if ((ohx != NULL) && (ohy != NULL) && (ohz != NULL)) {
+ result = yas_pcb_test7(ohx, ohy, ohz);
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST7);
+ } else
+ result = YAS_PCB_ERROR_ARG;
+ }
+
+ return result;
+#else
+ return YAS_PCB_ERROR_NOT_SUPPORTED;
+#endif
+}
+
+/* test 8 */
+static int noise_level_check(int *hx0, int *hy0, int *hz0)
+{
+#ifdef YAS_PCBTEST_EXTRA
+ int ret;
+ int result = yas_pcb_check_state(YAS_PCB_TEST8);
+
+ if (YAS_PCB_NO_ERROR == result) {
+ if ((hx0 != NULL) && (hy0 != NULL) && (hz0 != NULL)) {
+ result = YAS_PCB_ERROR_I2C;
+ ret = g_callback.i2c_open();
+ if (0 == ret) {
+ result = yas_pcb_test8(hx0, hy0, hz0);
+ ret = g_callback.i2c_close();
+ if (0 != ret)
+ result = YAS_PCB_ERROR_I2C;
+ }
+ if (YAS_PCB_NO_ERROR == result)
+ yas_pcb_update_state(YAS_PCB_TEST8);
+ } else
+ result = YAS_PCB_ERROR_ARG;
+ }
+
+ return result;
+#else
+ return YAS_PCB_ERROR_NOT_SUPPORTED;
+#endif
+}
+
+/* pcb test module initialize */
+int yas_pcb_test_init(struct yas_pcb_test *func)
+{
+ int result = YAS_PCB_ERROR_ARG;
+
+ if ((NULL != func)
+ && (NULL != func->callback.i2c_open)
+ && (NULL != func->callback.i2c_close)
+ && (NULL != func->callback.i2c_write)
+ && (NULL != func->callback.i2c_read)
+ && (NULL != func->callback.msleep)) {
+ func->power_on_and_device_check = power_on_and_device_check;
+ func->initialization = initialization;
+ func->offset_control_measurement_and_set_offset_register
+ = offset_control_measurement_and_set_offset_register;
+ func->direction_measurement = direction_measurement;
+ func->sensitivity_measurement_of_magnetic_sensor_by_test_coil
+ = sensitivity_measurement_of_magnetic_sensor_by_test_coil;
+ func->magnetic_field_level_check = magnetic_field_level_check;
+ func->noise_level_check = noise_level_check;
+ func->power_off = power_off;
+
+ g_callback = func->callback;
+
+ if (0 != gu16State) {
+ gu16State = 0;
+ yas_pcb_power_off();
+ }
+#ifdef YAS_PCBTEST_EXTRA
+ gu08Recalc = 0;
+ gs32RecalcWait = 0;
+#endif
+ result = YAS_PCB_NO_ERROR;
+ }
+
+ return result;
+}
+/* end of file */