void
i2c_udp_periodic(void)
{
if(STATSI2C.timeout == 1){
i2c_master_disable();
reset_connection(uip_udp_conn);
/* FIXME: PORTC &= ~_BV(PC2); */
}
if(STATSI2C.timeout > 0)
STATSI2C.timeout--;
/* error detection on i2c bus */
if((TWSR & 0xF8) == 0x00)
i2c_master_disable();
}
/**
* \brief Resets the hardware module
*
* Reset the module to hardware defaults.
*
* \param[in,out] module Pointer to software module structure
*/
void i2c_master_reset(struct i2c_master_module *const module)
{
/* Sanity check arguments */
Assert(module);
Assert(module->hw);
SercomI2cm *const i2c_module = &(module->hw->I2CM);
/* Wait for sync */
_i2c_master_wait_for_sync(module);
/* Disable module */
i2c_master_disable(module);
#if I2C_MASTER_CALLBACK_MODE == true
/* Clear all pending interrupts */
system_interrupt_enter_critical_section();
system_interrupt_clear_pending(_sercom_get_interrupt_vector(module->hw));
system_interrupt_leave_critical_section();
#endif
/* Wait for sync */
_i2c_master_wait_for_sync(module);
/* Reset module */
i2c_module->CTRLA.reg = SERCOM_I2CM_CTRLA_SWRST;
}
/*
* @fn nm_bus_deinit
* @brief De-initialize the bus wrapper
*/
sint8 nm_bus_deinit(void)
{
sint8 result = M2M_SUCCESS;
struct port_config pin_conf;
port_get_config_defaults(&pin_conf);
/* Configure control pins as input no pull up. */
pin_conf.direction = PORT_PIN_DIR_INPUT;
pin_conf.input_pull = PORT_PIN_PULL_NONE;
#ifdef CONF_WINC_USE_I2C
i2c_master_disable(&i2c_master_instance);
#endif /* CONF_WINC_USE_I2C */
#ifdef CONF_WINC_USE_SPI
spi_disable(&master);
#endif /* CONF_WINC_USE_SPI */
return result;
}
void EEP_Reset()
{
i2c_master_disable(&i2c_master_instance);
pinMux(SCL, Disablemux);
pinMux(SDA, Disablemux);
pinMode(SDA,INPUT);
for (uint8_t i=0;i<9; i++)
{
PinSet(SCL);
delay_us(10);
if(PinRead(SDA))
{
break;
}
PinClr(SCL);
}
pinMux(SCL, CSERCOMmux);
pinMode(SDA,OUTPUT);
pinMux(SDA, CSERCOMmux);
i2c_master_enable(&i2c_master_instance);
I2C_STATUS|=(1<<4);
}
/*! \brief Main function. Execution starts here.
*/
int main(void)
{
uint8_t write_data[PATTERN_TEST_LENGTH];
uint8_t read_data[PATTERN_TEST_LENGTH];
uint32_t file_size = 0,remaining_len = 0;;
struct i2c_master_packet tx_buf = {
.address = SLAVE_ADDRESS,
.data_length = PATTERN_TEST_LENGTH,
.data = write_data,
.ten_bit_address = false,
.high_speed = false,
.hs_master_code = 0x0,
};
struct i2c_master_packet rx_buf = {
.address = SLAVE_ADDRESS,
.data_length = 1,
.data = read_data,
.ten_bit_address = false,
.high_speed = false,
.hs_master_code = 0x0,
};
uint8_t nb_twi_packets_sent;
uint16_t cdc_rx_size;
irq_initialize_vectors();
cpu_irq_enable();
sleepmgr_init();
system_init();
configure_usart();
ui_init();
ui_powerdown();
udc_start();
printf("Start application\r\n");
while (true) {
if (!b_com_port_opened) {
continue;
}
if (b_cdc_data_rx == true) {
b_cdc_data_rx = false;
cdc_rx_size = udi_cdc_get_nb_received_data();
udi_cdc_read_buf((void *)cdc_data, cdc_rx_size);
if (file_size == 0 && cdc_rx_size == 4) {
MSB0W(file_size) = cdc_data[0];
MSB1W(file_size) = cdc_data[1];
MSB2W(file_size) = cdc_data[2];
MSB3W(file_size) = cdc_data[3];
printf("File size :%ld\r\n",file_size);
}
remaining_len += cdc_rx_size;
if (cdc_rx_size == TARGET_PAGE_SIZE/2) {
if (!b_wait) {
memcpy((void *)(write_data), (const void *)cdc_data, cdc_rx_size);
b_wait = true;
if (file_size + 4 == remaining_len) {
tx_buf.data_length = TARGET_PAGE_SIZE/2;
while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ;
}
}
else {
memcpy((void *)(write_data + (TARGET_PAGE_SIZE/2)), (const void *)cdc_data, cdc_rx_size);
tx_buf.data_length = TARGET_PAGE_SIZE;
while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ;
b_wait = false;
}
} else {
if ((cdc_rx_size) <= PATTERN_TEST_LENGTH) {
tx_buf.data_length = cdc_rx_size;
memcpy((void *)(write_data), (const void *)cdc_data, cdc_rx_size);
while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ;
} else {
nb_twi_packets_sent = 0;
while(cdc_rx_size / PATTERN_TEST_LENGTH) {
tx_buf.data_length = PATTERN_TEST_LENGTH;
memcpy((void *)(write_data), (const void *)(&cdc_data[(nb_twi_packets_sent++) * (PATTERN_TEST_LENGTH)]), PATTERN_TEST_LENGTH);
while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ;
cdc_rx_size -= (PATTERN_TEST_LENGTH);
}
if(cdc_rx_size) {
tx_buf.data_length = cdc_rx_size;
memcpy((void *)(write_data), (const void *)(&cdc_data[(nb_twi_packets_sent) * (PATTERN_TEST_LENGTH)]), cdc_rx_size);
while (i2c_master_write_packet_wait(&i2c_master_instance, &tx_buf) != STATUS_OK) ;
cdc_rx_size = 0;
}
}
}
}
if (i2c_master_read_packet_wait(&i2c_master_instance, &rx_buf) == STATUS_OK) {
udi_cdc_write_buf((const void *)(rx_buf.data),(iram_size_t)read_data[0]);
if (file_size + 4 == remaining_len) {
printf("File transfer successfully, file size:%ld, transefer size :%ld\r\n",file_size,remaining_len-4);
}
}
}
}
void main_suspend_action(void)
{
ui_powerdown();
}
void main_resume_action(void)
{
ui_wakeup();
}
void main_sof_action(void)
{
if (!main_b_cdc_enable)
return;
ui_process(udd_get_frame_number());
}
#ifdef USB_DEVICE_LPM_SUPPORT
void main_suspend_lpm_action(void)
{
ui_powerdown();
}
void main_remotewakeup_lpm_disable(void)
{
ui_wakeup_disable();
}
void main_remotewakeup_lpm_enable(void)
{
ui_wakeup_enable();
}
#endif
bool main_cdc_enable(uint8_t port)
{
main_b_cdc_enable = true;
configure_i2c_master();
return true;
}
void main_cdc_disable(uint8_t port)
{
main_b_cdc_enable = false;
b_com_port_opened = false;
i2c_master_disable(&i2c_master_instance);
}
/**
* \internal
* \brief Test for I2C master transfer.
*
* First test transfer function with stop.
* write to slave, read from slave and then compare the data.
* the slave send out the data it received,
* so master write and read data should be the same.
*
* Then test transfer function without stop.
* write to slave, then use i2c_master_send_stop to complete writing,
* read from slave, compare the data.
* finally, use function with stop to complete the transfer.
*
* \param test Current test case.
*/
static void run_i2c_master_transfer_test(const struct test_case *test)
{
uint32_t timeout_cycles = 1000;
uint32_t i;
bool status = true;
uint8_t read_buffer[DATA_LENGTH] = {0};
struct i2c_master_packet packet = {
.address = SLAVE_ADDRESS,
.data_length = DATA_LENGTH,
.data = write_buffer,
.ten_bit_address = false,
.high_speed = false,
.hs_master_code = 0x0,
};
/* with stop function: master transfer test */
/* wait the master write to complete */
do {
timeout_cycles--;
if (i2c_master_write_packet_wait(&i2c_master_instance, &packet) ==
STATUS_OK) {
break;
}
} while (timeout_cycles > 0);
test_assert_true(test, timeout_cycles > 0,
"i2c master write failed");
/* wait the master read to complete */
packet.data = read_buffer;
timeout_cycles = 1000;
do {
timeout_cycles--;
if (i2c_master_read_packet_wait(&i2c_master_instance, &packet) ==
STATUS_OK) {
break;
}
} while (timeout_cycles > 0);
test_assert_true(test, timeout_cycles > 0,
"i2c master read failed");
/* Compare the sent and the received */
for (i = 0; i < DATA_LENGTH; i++) {
if (read_buffer[i] != write_buffer[i]) {
status = false;
break;
}
}
test_assert_true(test, status == true,
"i2c master transfer comparsion failed");
/* with stop function master transfer test end */
/* without stop function: master transfer test*/
/* wait the master write to finish */
packet.data = write_buffer;
timeout_cycles = 1000;
do {
timeout_cycles--;
if (i2c_master_write_packet_wait_no_stop(&i2c_master_instance, &packet) ==
STATUS_OK) {
break;
}
} while (timeout_cycles > 0);
test_assert_true(test, timeout_cycles > 0,
"i2c master write without stop failed");
/* use i2c_master_send_stop to complete master writing */
i2c_master_send_stop(&i2c_master_instance);
/* wait the master read to finish */
packet.data = read_buffer;
timeout_cycles = 1000;
do {
timeout_cycles--;
if (i2c_master_read_packet_wait_no_stop(&i2c_master_instance, &packet) ==
STATUS_OK) {
break;
}
} while (timeout_cycles > 0);
test_assert_true(test, timeout_cycles > 0,
"i2c master read without stop failed");
/* Compare the sent and the received */
for (i = 0; i < DATA_LENGTH; i++) {
if (read_buffer[i] != write_buffer[i]) {
status = false;
break;
}
}
test_assert_true(test, status == true,
"i2c master transfer without stop comparsion failed");
/* use i2c_master_write_packet_wait to complete the transfer */
packet.data = write_buffer;
do {
timeout_cycles--;
if (i2c_master_write_packet_wait(&i2c_master_instance, &packet) ==
STATUS_OK) {
break;
}
} while (timeout_cycles > 0);
test_assert_true(test, timeout_cycles > 0,
"i2c master write with repeated start failed");
/* without stop function: master transfer test end*/
}
/**
* \internal
* \brief Test full speed mode master transfer.
*
* test function with stop in full speed mode.
* \param test Current test case.
*/
static void run_i2c_full_speed_test(const struct test_case *test)
{
enum status_code status;
struct i2c_master_config config_i2c_master;
/* init i2c master in full speed mode*/
i2c_master_get_config_defaults(&config_i2c_master);
config_i2c_master.buffer_timeout = 10000;
config_i2c_master.baud_rate = I2C_MASTER_BAUD_RATE_400KHZ;
i2c_master_disable(&i2c_master_instance);
status = i2c_master_init(&i2c_master_instance, SERCOM2, &config_i2c_master);
/* Check for successful initialization */
test_assert_true(test, status == STATUS_OK,
"I2C master fast-mode initialization failed");
i2c_master_enable(&i2c_master_instance);
uint32_t timeout_cycles = 1000;
uint32_t i;
bool status1 = true;
struct i2c_master_packet packet = {
.address = SLAVE_ADDRESS,
.data_length = DATA_LENGTH,
.data = write_buffer,
.ten_bit_address = false,
.high_speed = false,
.hs_master_code = 0x0,
};
uint8_t read_buffer[DATA_LENGTH] = {0};
/* wait master write complete */
do {
timeout_cycles--;
if (i2c_master_write_packet_wait(&i2c_master_instance, &packet) ==
STATUS_OK) {
break;
}
} while (timeout_cycles > 0);
test_assert_true(test, timeout_cycles > 0,
"i2c master write failed");
/* wait master read complete */
packet.data = read_buffer;
timeout_cycles = 1000;
do {
timeout_cycles--;
if (i2c_master_read_packet_wait(&i2c_master_instance, &packet) ==
STATUS_OK) {
break;
}
} while (timeout_cycles > 0);
test_assert_true(test, timeout_cycles > 0,
"i2c master read failed");
/* Compare the sent and the received */
for (i = 0; i < DATA_LENGTH; i++) {
if (read_buffer[i] != write_buffer[i]) {
status1 = false;
break;
}
}
test_assert_true(test, status1 == true,
"i2c master transfer comparsion failed");
}
/**
* \brief Run I2C master unit tests
*
* Initializes the system and serial output, then sets up the
* I2C master unit test suite and runs it.
*/
int main(void)
{
system_init();
cdc_uart_init();
/* Define Test Cases */
DEFINE_TEST_CASE(i2c_init_test,
NULL,
run_i2c_init_test,
NULL,
"Testing I2C Initialization");
DEFINE_TEST_CASE(i2c_master_transfer_test,
NULL,
run_i2c_master_transfer_test,
NULL,
"Testing I2C master data transfer");
DEFINE_TEST_CASE(i2c_full_speed_test,
NULL,
run_i2c_full_speed_test,
NULL,
"Testing I2C change speed transfer");
/* Put test case addresses in an array */
DEFINE_TEST_ARRAY(i2c_tests) = {
&i2c_init_test,
&i2c_master_transfer_test,
&i2c_full_speed_test,
};
/* Define the test suite */
DEFINE_TEST_SUITE(i2c_test_suite, i2c_tests,
"SAM I2C driver test suite");
/* Run all tests in the suite*/
test_suite_run(&i2c_test_suite);
while (true) {
/* Intentionally left empty */
}
}