i2c_eeprom_asynch.cpp

00001 /* mbed Microcontroller Library
00002  * Copyright (c) 2015 ARM Limited
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #include <stdio.h>
00017 #include "TestHarness.h"
00018 #include "mbed.h"
00019 
00020 /* EEPROM 24LC256 Test Unit, to test I2C asynchronous communication.
00021  */
00022 
00023 #if !DEVICE_I2C || !DEVICE_I2C_ASYNCH
00024 #error i2c_master_eeprom_asynch requires asynch I2C
00025 #endif
00026 
00027 #if defined(TARGET_K64F)
00028 #define TEST_SDA_PIN PTE25
00029 #define TEST_SCL_PIN PTE24
00030 
00031 #elif defined(TARGET_K66F)
00032 #define TEST_SDA_PIN PTD9
00033 #define TEST_SCL_PIN PTD8
00034 
00035 #elif defined(TARGET_EFM32LG_STK3600) || defined(TARGET_EFM32GG_STK3700) || defined(TARGET_EFM32WG_STK3800)
00036 #define TEST_SDA_PIN PD6
00037 #define TEST_SCL_PIN PD7
00038 
00039 #elif defined(TARGET_EFM32ZG_STK3200)
00040 #define TEST_SDA_PIN PE12
00041 #define TEST_SCL_PIN PE13
00042 
00043 #elif defined(TARGET_EFM32HG_STK3400)
00044 #define TEST_SDA_PIN PD6
00045 #define TEST_SCL_PIN PD7
00046 
00047 #elif defined(TARGET_RZ_A1H)
00048 #define TEST_SDA_PIN P1_3
00049 #define TEST_SCL_PIN P1_2
00050 void sleep()
00051 {
00052 }
00053 
00054 #else
00055 #error Target not supported
00056 #endif
00057 
00058 #define PATTERN_MASK 0x66, ~0x66, 0x00, 0xFF, 0xA5, 0x5A, 0xF0, 0x0F
00059 
00060 volatile int why;
00061 volatile bool complete;
00062 void cbdone(int event) {
00063     complete = true;
00064     why = event;
00065 }
00066 
00067 const unsigned char pattern[] = { PATTERN_MASK };
00068 
00069 TEST_GROUP(I2C_Master_EEPROM_Asynchronous)
00070 {
00071     I2C *obj;
00072     const int eeprom_address = 0xA0;
00073     event_callback_t callback;
00074 
00075     void setup() {
00076         obj = new I2C(TEST_SDA_PIN, TEST_SCL_PIN);
00077         obj->frequency(400000);
00078         complete = false;
00079         why = 0;
00080         callback.attach(cbdone);
00081     }
00082 
00083     void teardown() {
00084         delete obj;
00085         obj = NULL;
00086     }
00087 
00088 };
00089 
00090 TEST(I2C_Master_EEPROM_Asynchronous, tx_rx_one_byte_separate_transactions)
00091 {
00092     int rc;
00093     char data[] = { 0, 0, 0x66};
00094 
00095     rc = obj->transfer(eeprom_address, data, sizeof(data), NULL, 0, callback, I2C_EVENT_ALL, false);
00096     CHECK_EQUAL(0, rc);
00097     while (!complete) {
00098         sleep();
00099     }
00100 
00101     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00102 
00103     // wait until slave is ready
00104     do {
00105         complete = 0;
00106         why = 0;
00107         obj->transfer(eeprom_address, NULL, 0, NULL, 0, callback, I2C_EVENT_ALL, false);
00108         while (!complete) {
00109             sleep();
00110         }
00111     } while (why != I2C_EVENT_TRANSFER_COMPLETE);
00112 
00113 
00114     // write the address for reading (0,0) then start reading data
00115     data[0] = 0;
00116     data[1] = 0;
00117     data[2] = 0;
00118     why = 0;
00119     complete = 0;
00120     obj->transfer(eeprom_address, data, 2, NULL, 0, callback, I2C_EVENT_ALL, true);
00121     while (!complete) {
00122         sleep();
00123     }
00124     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00125 
00126     data[0] = 0;
00127     data[1] = 0;
00128     data[2] = 0;
00129     why = 0;
00130     complete = 0;
00131     rc = obj->transfer(eeprom_address, NULL, 0, data, 1, callback, I2C_EVENT_ALL, false);
00132     CHECK_EQUAL(0, rc);
00133     while (!complete) {
00134         sleep();
00135     }
00136     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00137     CHECK_EQUAL(data[0], 0x66);
00138 }
00139 
00140 TEST(I2C_Master_EEPROM_Asynchronous, tx_rx_one_byte_one_transactions)
00141 {
00142     int rc;
00143     char send_data[] = { 0, 0, 0x66};
00144     rc = obj->transfer(eeprom_address, send_data, sizeof(send_data), NULL, 0, callback, I2C_EVENT_ALL, false);
00145     CHECK_EQUAL(0, rc)
00146 
00147     while (!complete) {
00148         sleep();
00149     }
00150 
00151     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00152 
00153     // wait until slave is ready
00154     do {
00155         complete = 0;
00156         why = 0;
00157         obj->transfer(eeprom_address, NULL, 0, NULL, 0, callback, I2C_EVENT_ALL, false);
00158         while (!complete) {
00159             sleep();
00160         }
00161     } while (why != I2C_EVENT_TRANSFER_COMPLETE);
00162 
00163 
00164     send_data[0] = 0;
00165     send_data[1] = 0;
00166     send_data[2] = 0;
00167     char receive_data[1] = {0};
00168     why = 0;
00169     complete = 0;
00170     rc = obj->transfer(eeprom_address, send_data, 2, receive_data, 1, callback, I2C_EVENT_ALL, false);
00171     CHECK_EQUAL(0, rc);
00172     while (!complete) {
00173         sleep();
00174     }
00175 
00176     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00177     CHECK_EQUAL(receive_data[0], 0x66);
00178 }
00179 
00180 TEST(I2C_Master_EEPROM_Asynchronous, tx_rx_pattern)
00181 {
00182     int rc;
00183     char data[] = { 0, 0, PATTERN_MASK};
00184     // write 8 bytes to 0x0, then read them
00185     rc = obj->transfer(eeprom_address, data, sizeof(data), NULL, 0, callback, I2C_EVENT_ALL, false);
00186     CHECK_EQUAL(0, rc);
00187 
00188     while (!complete) {
00189         sleep();
00190     }
00191     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00192 
00193     // wait until slave is ready
00194     do {
00195         complete = 0;
00196         why = 0;
00197         obj->transfer(eeprom_address, NULL, 0, NULL, 0, callback, I2C_EVENT_ALL, false);
00198         while (!complete) {
00199             sleep();
00200         }
00201     } while (why != I2C_EVENT_TRANSFER_COMPLETE);
00202 
00203     complete = 0;
00204     why = 0;
00205     char rec_data[8] = {0};
00206     rc = obj->transfer(eeprom_address, rec_data, 2, NULL, 0, callback, I2C_EVENT_ALL, true);
00207     CHECK_EQUAL(0, rc);
00208     while (!complete) {
00209         sleep();
00210     }
00211     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00212 
00213     complete = 0;
00214     why = 0;
00215     rc = obj->transfer(eeprom_address, NULL, 0, rec_data, 8, callback, I2C_EVENT_ALL, false);
00216     CHECK_EQUAL(0, rc);
00217     while (!complete) {
00218         sleep();
00219     }
00220     CHECK_EQUAL(why, I2C_EVENT_TRANSFER_COMPLETE);
00221 
00222     // received buffer match with pattern
00223     rc = memcmp(pattern, rec_data, sizeof(rec_data));
00224     CHECK_EQUAL(0, rc);
00225 }