В одном из своих проектов использую микроконтроллеры STM32F030. Недавно возникла необходимость подключения внешней EEPROM памяти по шине I 2 C. Сначала я хотел взять готовый пример с инета, но в итоге пришлось изобретать свой велосипед писать свой код. В статье рассказываю о типичных граблях при работе с шиной I 2 C STM32F030, и предлагаю свой велосипед вариант работы с шиной.

Итак, для критики возьму один из примеров кода, взятый с интернета:

/** Описание Записывает байт данных в I2C EEPROM. * Параметр data: переменная для записи в EEPROM. * Параметр WriteAddr: Внутренний адрес EEPROM для записи. * Возвращаемое значение нет */ uint32_t EEPROM_I2C_Write(uint8_t data, uint16_t WriteAddr) { //uint32_t DataNum = 0; Address = Address + (WriteAddr / 256); /* Конфигурирование адреса ведомого; количество байтов, которые будут запрограммированы (переданы); перезагрузки и генерировать старт */ I2C_TransferHandling(I2C1, Address, 1, I2C_Reload_Mode, I2C_Generate_Start_Write); /* Подождите, пока TXIS флаг не будет установлен */ while(I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET); /* Отправить адрес памяти */ I2C_SendData(I2C1, (uint8_t)WriteAddr); /* Подождите, пока TCR флаг не будет установлен */ while(I2C_GetFlagStatus(I2C1, I2C_ISR_TCR) == RESET); /* Обновить CR2: установить Адрес ведомого, установить запрос на запись, генерировать Пуск и заданного конечного режим */ I2C_TransferHandling(I2C1, Address, 1, I2C_AutoEnd_Mode, I2C_No_StartStop); /* Подождите, пока TXIS флаг не будет установлен */ while(I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET); /* Запись данных в TXDR */ I2C_SendData(I2C1, data); /* Подождите, пока STOPF флаг не будет установлен */ while(I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET); /* Очистить флаг STOPF */ I2C_ClearFlag(I2C1, I2C_ICR_STOPCF); }

Вставляю этот код в свой проект, проверяю, шина работает. Дальше начинаю проверять код на наличие граблей. Для начала отключаю микросхему памяти, чтобы при обращении на шине отсутствовал ACK. Проверяю работу кода, и тут же натыкаюсь на грабли. Давайте разбираться где подвох.

На шину выдан старт, отправлен адрес устройства. Так как мы отключили микросхему памяти, установился флаг NACKF (Not Acknowledge Flag). Смотрим код дальше.

А вот здесь микроконтроллер зависает, так как ждёт запрос на передачу байта (установку флага TXIS, Transmit Interrupt Status). Запрос никогда не поступит, так как ведомое устройство на шине не отвечает. Это первые грабли. Соответственно, пока никаких сбоев на шине нет - наше устройство работает нормально. Как только произошёл малейший сбой - микроконтроллер наглухо виснет. Смотрю код дальше.

Здесь тоже имеется ошибка. Если микросхема не отвечает, устанавливается флаг NACKF, а флаг TCR (Transfer Complete Reload) никогда не будет возведён. Микроконтроллер зависнет.

Последняя строчка ожидает возведения флага STOPF (Stop detection Flag), но мы замкнули ножки и заблокировали обмен данными. Шина замечает подвох, и взлетает флаг ARLO (Arbitration Lost). Флаг STOPF не устанавливается, микроконтроллер зависает. Более того, появляются ещё одни грабли.

Так как возведён флаг ARLO, обмен данными по шине невозможен, микроконтроллер не будет выдавать даже старт на шину.

Таким образом, применив вышеописанный код, мы закладываем в проект пачку хаотично появляющихся граблей. В общем я решил изобрести велосипед написать свой вариант кода. Весь код расписывать не буду (можно скачать в конце статьи), лишь поясню ключевые моменты.

Отправка данных.

/* Выполняет транзакцию записи Size байт в регистр Register по адресу Adress. Параметры: Adress - адрес ведомого устройства Register - регистр, в который хотим передать данные Data - указывает откуда брать данные для передачи Size - сколько байт хотим передать (от 1 до 254) Возвращает: 1 - если данные успешно переданы 0 - если произошла ошибка */ u8 I2C_Write_Transaction (u8 Adress, u8 Register, u8 *Data, u8 Size) { u8 Count=0; // Счётчик успешно переданных байт // Старт I2C_Start_Direction_Adress_Size (I2C_Transmitter, Adress, 1+Size); // Сейчас либо I2C запросит первый байт для отправки, // Либо взлетит NACK-флаг, говорящий о том, что микросхема не отвечает. // Если взлетит NACK-флаг, отправку прекращаем. while ((((I2C_BUS->ISR & I2C_ISR_TXIS)==0) && ((I2C_BUS->ISR & I2C_ISR_NACKF)==0)) && (I2C_BUS->ISR & I2C_ISR_BUSY)) {}; if (I2C_BUS->ISR & I2C_ISR_TXIS) I2C_BUS->TXDR=Register; // Отправляю адрес регистра // Отправляем байты до тех пор, пока не взлетит TC-флаг. // Если взлетит NACK-флаг, отправку прекращаем. while ((((I2C_BUS->ISR & I2C_ISR_TC)==0) && ((I2C_BUS->ISR & I2C_ISR_NACKF)==0)) && (I2C_BUS->ISR & I2C_ISR_BUSY)) { if (I2C_BUS->ISR & I2C_ISR_TXIS) I2C_BUS->TXDR=*(Data+Count++); // Отправляю данные } I2C_Stop(); if (Count == Size) return 1; return 0; }

После старта шины и отправки адреса микросхемы, есть 3 варианта исхода событий:

• байт успешно отправлен, если в очереди есть ещё один байт - возводится TXIS, если все байты переданы - возводится TC (Transfer Complete)
• микросхема не отвечает - возводится NACKF
• прочие ошибки на шине - возводится ARLO или BERR (Bus Error), опускается BUSY (Bus Busy)

Следует обратить внимание на циклы while - они реализованы с учётом всех вышеописанных вариантов. Идём дальше.

Приём данных.

/* Выполняет транзакцию чтения Size байт из регистра Register по адресу Adress. Параметры: Adress - адрес ведомого устройства Register - регистр, из которого хотим принять данные Data - указывает куда складывать принятые данные Size - сколько байт хотим принять (от 1 до 255) Возвращает: 1 - если данные успешно приняты 0 - если произошла ошибка */ u8 I2C_Read_Transaction (u8 Adress, u8 Register, u8 *Data, u8 Size) { u8 Count=0; // Счётчик успешно принятых байт // Старт I2C_Start_Direction_Adress_Size (I2C_Transmitter, Adress, 1); // Сейчас либо I2C запросит первый байт для отправки, // Либо взлетит NACK-флаг, говорящий о том, что микросхема не отвечает. // Если взлетит NACK-флаг, отправку прекращаем. while ((((I2C_BUS->ISR & I2C_ISR_TC)==0) && ((I2C_BUS->ISR & I2C_ISR_NACKF)==0)) && (I2C_BUS->ISR & I2C_ISR_BUSY)) { if (I2C_BUS->ISR & I2C_ISR_TXIS) I2C_BUS->TXDR = Register; // Отправляю адрес регистра } // Повторный старт I2C_Start_Direction_Adress_Size (I2C_Receiver, Adress, Size); // Принимаем байты до тех пор, пока не взлетит TC-флаг. // Если взлетит NACK-флаг, приём прекращаем. while ((((I2C_BUS->ISR & I2C_ISR_TC)==0) && ((I2C_BUS->ISR & I2C_ISR_NACKF)==0)) && (I2C_BUS->ISR & I2C_ISR_BUSY)) { if (I2C_BUS->ISR & I2C_ISR_RXNE) *(Data+Count++) = I2C_BUS->RXDR; // Принимаю данные } I2C_Stop(); if (Count == Size) return 1; return 0; }

Здесь всё почти так же, как и при передаче. Подробно описывать не буду, идём дальше.

Шина I2C существует уже достаточно давно: ее в 1980х создала компания Philips для низкоскоростных устройств. В настоящий момент она достаточно широко применяется, и, скорей всего, дома у вас есть хоть одно устройство с данной шиной. Название шины расшифровывается как Inter-Integrated Circuit. Хардварным модулем I2C в настоящее время обладает большинство микроконтроллеров, в некоторых их и вовсе несколько, как у тех же STM32 (в серии F4 есть целых три модуля I2C).

Шина представляет собой 2 линии, одна из которых данные (SDA), другая - синхросигнал (SCL), обе линии изначально притянуты к питанию. Следует отметить, что четкого указания какое именно должно быть напряжение нет, но чаще всего используется +5В и +3.3В. Устройства в линии не одноранговые, как в CAN, поэтому всегда должно быть Master-устройство. Допускается наличие нескольких Master-устройств, но это все же гораздо реже, чем один Master и ворох Slave устройств.

Передача данных инициируется мастером, который отправляет в шину адрес необходимого устройства, тактирование осуществляется так же мастером. Но, при этом, Slave-устройство имеет возможность «придержать» линию тактирования, как бы сообщая Master-устройству, что не успевает принять или отправить данные, что порой бывает очень полезно. Наибольшее распространение получили в текущий вариант реализации I2C с частотой шины 100 kHz (Standard mode) и 400 kHz (Fast mode).

Существует реализация I2C версии 2.0, которая позволяет достичь гораздо больших скоростей, в 2-3 Мбит/с, но они пока что весьма редкие. Так же у линии есть ограничение по емкости в 400 пФ. Обычно в даташитах для датчиков и прочих I2C устройств указывается их емкость, так что приблизительно можно вычислить «влезет» ли еще один датчик или нет.

В микроконтроллерах очень часто есть внутренняя подтяжка на выводах, что в свободном состоянии даст необходимые +3.3В (или +5В) на линии, но этой подтяжки абсолютно не хватит на нормальную линию. Поэтому всегда стоит делать внешнюю подтяжку и SCL и SDA к питанию резисторами в 4.7кОм..2кОм.

Отдельно стоит отметить то, что обычно линию I2C не рекомендуют делать длинной, да и чаще всего она встречается на печатных платах для обмена между некими цифровыми устройствами, гораздо реже I2C пускают по проводам (но не стоит думать, что это редкость, и то и другое вполне нормально). Если у вас возникла надобность сделать длинную линию I2C, да еще на 400 кГц, то стоит уменьшить сопротивление резисторов подтяжки. 1 кОм - вполне приемлемое значение для линии длиной чуть более метра и с несколькими устройствами на ней. Только не забывайте, что уменьшая сопротивление резисторов, вы увеличиваете ток в линии, что при переизбытке может привести к повреждению устройств.

С программной точки зрения обмен по шине I2C выглядит следующим образом: Master отправляет стартовую последовательность START (при высоком уровне SCL к нулю притягивается SDA), затем отправляет адрес с бит-флагом, указывающим режим чтения или записи, причем в следующим формате:

Если бит режима равен нулю, то это значит, что Master будет записывать информацию в Slave устройство, единица - чтение из Slave. Если взглянуть на это с другой стороны, то каждое I2C устройство предоставляет два «виртуальных» устройства, исходя из чего получается, что если весь байт адреса (т.е. исконные 7 бит + бит режима) четный, то это адрес записи, если нечетный - адрес чтения. Исходя из этого появляется ограничение на количество устройств в шине: 127.

После получения адреса Slave устройство должно сообщить мастеру о принятии адреса, что подтвердит сам факт существования Slave устройства с таким адресом на линии. Подтверждение - это специальный 9й бит, который равен нулю, если адрес совпал и готовы работать, и единице, если не совпал. Это сигналы ACK и NACK соответственно. Так же, ACK используется при последующим приеме и передаче данных. Если мастер записывает в слейв, то слейв должен каждый байт подтверждать сигналом ACK. Если слейв отправляет данные мастеру, то мастер должен на все байты отвечать ACK, кроме последнего - это будет сигналом, что больше отправлять данные не требуется.

В конце всей передачи Master должен отправить завершающую последовательность STOP, которая заключается в поднятии линии SDA до высокого уровня при поднятой линии SCL.

Таким образом, стандартный «пакет» выглядит следующим образом:

Теперь можно перейти к рассмотрению работы с данной шиной на микроконтроллере STM32. Сразу стоит заметить, что во всех сериях данный модуль приблизительно одинаковый, за исключением регистра фильтра в старших сериях (например, STM32F407), поэтому единожды написанный код сможет работать и далее.

Для начала следует включить тактирование модуля I2C, что, впрочем, необходимо и для всей периферии. Так же необходимо включить и настроить пины в режим альтернативной функции. Чтобы посмотреть на какой шине что находится, необходимо обратиться к даташиту, в раздел Device Overview (для F4, это, например, страница 18) (рис.1). Из изображения видно, что I2C находятся на шине APB1. Следующий шаг - включение и настройка GPIO, все, что необходимо: режим альтернативной функции (по даташиту I2C относится к AF4), тип OpenDrain, а подтяжка должна быть внешняя. «Скорость» пинов для 100кГц можно выбрать Low (2 MHz), а для 400 кГц ST рекомендуют выбирать уже Medium или Fast (от 10 MHz). И, наконец, можно настроить I2C. Показывать регистры не имеет смысла, они есть все в reference manual, все, что нужно для стандартного случая будет ниже. До включения непосредственно модуля I2C следует в регистр CR2 записать текущее значение частоты той шины, на которой сидит модуль I2C, в данном случае это частота шины APB1. В рамках даташита это значение называется PCLK.

В разных контроллерах количество и именование шин разное. Так, в серии F4xx есть и APB1 и APB2, и переменная PCLK будет соответственно нумероваться - PCLK1 и PCLK2. Чтобы посмотреть или высчитать конкретную частоту тактирования шины можно воспользоваться приложением CubeMX, которое загружается с официального сайта ST Microelectronics.

Рис. 1 - Схема периферии контроллера STM32F407.

В регистре CR2 так же включаются прерывания от данного модуля. Под этим понимается то, что будет ли модуль сообщать в NVIC о том, что что-то произошло, либо же просто поставит нужные флаги в статусном регистре. Стоит заметить, что в статусном регистре всегда будут ставиться событийные флаги, что логично. В первую очередь интересны прерывания ITEVTEN и ITERREN, прерывания событий и ошибок соответственно. Можно обойтись вполне и только событиями, как наиболее общим.

I2C1->CR2 |= 48; // Peripheral frequency 24MHz I2C1->CR2 |= I2C_CR2_ITEVTEN; // Enable events

Регистр CCR отвечает за тактирование самой шины наружу, поэтому сюда необходимо внести значение, которое рассчитывается по формуле PCLK/I2C_SPEED. Например, мы хотим шину на 400 кГц завести, внутренняя шина APB1 тактируется 48 МГц, соответственно в CCR запишем значение, равное 48*106/4*105 = 120. Так же в данном регистре необходимо указать режим работы Slow/Fast, это последний, 16й бит.

I2C1->CCR &= ~I2C_CCR_CCR; I2C1->CCR |= 120; I2C1->CCR |= I2C_CCR_FS; // FastMode, 400 kHz

Регистр TRISE отвечает за фронты сигналов на SDA и SCL, сюда необходимо внести значение с небольшим запасом. Можно и без запаса, главное не меньше - ничего не заработает. Вносимое значение рассчитывается так: TRISE = RISE/tPCLK. tPCLK = 1/PCLK. Константа RISE - это максимальное время нарастания сигнала, по спецификации это 1000 нс для Slow Mode и 300 нс для Fast mode. tPCLK - это просто период, получается стандартно по формуле 1/F. Так как у нас Fast Mode, то значение в TRISE необходимо следующее: 3.000*10-7/2.083*10-8 = 14.4, и т.к. необходим запас, то округляем в большую сторону, т.е. 15.

Данный показатель важен, но не настолько, как сбившаяся частота тактирования. Я по ошибке посчитал константу TRISE в Fast Mode по формуле для Slow Mode и все работает. Но все же лучше делать правильно, по спецификации шины. Найти ее можно по поисковой фразе “i2c specification”. Да-да, она на английском языке.

I2C1->TRISE = 24;

После того, как данные действия будут выполнены, можно включать модуль и прерывания в модуле NVIC (если нужны).

I2C1->CR1 |= I2C_CR1_PE; // Enable I2C block NVIC_EnableIRQ(I2C1_EV_IRQn); NVIC_SetPriority(I2C1_EV_IRQn, 1);

После настройки модуля, есть два варианта как вы будете с ним работать. Вариант первый - поллингом, т.е. вы будете ждать появления флага в цикле while (и контроллер будет занят только этим, что в большинстве случаев плохо), либо вариант второй - на прерываниях. Я рассмотрю второй вариант, так как он предпочтительный, а если понять логику состояний по прерываниям, то перейти на поллинг не является проблемой.

Итак, первое что необходимо сделать - добавить в код обработчик прерываний событий от модуля I2C. Функция должна называться определенным образом, и ее название можно взять из startup-файла. Для модуля I2C1 функция называется I2C1_EV_IRQHandler. Поэтому в необходимый.c файл добавляем такую функцию:

Void I2C1_EV_IRQHandler(void) { }

Именование данного метода, понятное дело, можно изменять. В startup-файле в ассемблерном коде просто создаются метки, которые не требуют обязательного наличия данной функции. Компилятор языка Си найдя в исходном файле функцию, например ту же I2C1_EV_IRQHandler, выделить под нее точно такое же имя. Когда уже будет происходить окончательная сборка, все это сведется воедино и вместо имени будет присутствовать переход в нужную позицию в коде. Поэтому можно изменять название метки как заблагорассудится (по правилам именования функций, конечно), хотя и не рекомендуется - другие разработчики могут просто не понять, обработчик прерываний это или нет.

Если вы пишете на языке С++, не забудьте «обернуть» обработчик прерываний в блок extern “C” { … }, так как компилятор С++ изменяет имя функции по своим правилам во время компиляции (туда вносится информация о параметрах и возвращаемом значении, например), поэтому сборщик потом не свяжет написанный обработчик и метку в startup файле.

Для написания обработчика прерываний можно обратиться напрямую к документации, reference manual, там есть достаточно подробные схемы для разных режимов работы. Для начала возьмем отправку slave-устройству данных:

Например, мы хотим просто отправить 1 байт данных устройству и прекратить передачу. Для этого нам потребуется только состояния EV5, EV6 и EV8. Где-то в коде программы у нас была глобальная переменная data типа uint8_t, которую мы проинициализировали каким-то значением и хотим передать slave устройству. Инициацию передачи, как мы уже знаем, делает последовательность START:

I2C1->CR1 |= I2C_CR1_START;

Данную строку можно поставить по ходу программы там, когда нужно начинать передачу. Например, после того, как инициализировали переменную data. Дальше уже будет код внутри функции-обработчика прерываний. Для начала необходимо в отдельные переменные сохранить значение статусов:

Volatile uint32_t sr1 = I2C1->SR1, sr2 = I2C1->SR2;

После отправки стартовой последовательности произойдет прерывание с событием EV5. В данном случае в статусном регистре должен выставиться бит SB. Если данный бит выставлен, нам необходимо отправить адрес с битом режима чтения или записи. Для упрощения можно сделать так:

<<1) | mode)

Теперь можно написать обработчик состояния EV5:

If(sr1 & I2C_SR1_SB) { I2C1->DR = I2C_ADDRESS(0x14,I2C_MODE_READ); }

Когда адрес отправится и slave-устройство ответит последовательностью ACK, то произойдет событие EV6 и одновременно EV8: установится флаг ADDR и TXE. А рамках Master-режима, ADDR означает, что адрес отправлен и воспринят slave-устройством, а TXE означает, что буфер свободен для внесения данных для последующей передачи. Флаг ADDR сбросится сам, как только мы прочитаем SR1 и SR2 (необходимо их оба прочитать), а флаг TXE обработаем отдельным блоком кода. Так что, по факту, обрабатывать необходимо только EV5 и EV8, EV6 только информирует о наличии нужного slave на линии. В обработчике TXE все, что нужно - это передавать данные. Так как передавать мы хотим только 1 байт, то сразу же отправим и последовательность STOP:

If(sr1 & I2C_SR1_TXE) { I2C1->DR = data; I2C1->CR1 |= I2C_CR1_STOP; }

Таким образом, заполнив переменную data и дав команду формирования последовательности START, вся работа будет идти в прерываниях, а контроллер тем временем будет занят другой полезной работой большую часть времени (т.е. другая работа кроме, собственно, обработчика прерываний).

Если данных требуется отправить больше 1 байта, то изменения в коде минимальны. Теперь вместо uint8_t data создадим такие глобальные переменные:

Uint8_t iter; uint8_t data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Так как глобальные переменные целого типа по умолчанию равны нулю, то явно инициализировать переменную iter не требуется. Изменения в обработчике же вообще минимальные - требуется переписать блок обработки события EV8:

If(sr1 & I2C_SR1_TXE) { if(iter < 10) { I2C1->DR = data; } else { I2C1->CR1 |= I2C_CR1_STOP; } }

Таким образом, мы получили вот такую функцию-обработчик:

#define I2C_MODE_READ 1 #define I2C_MODE_WRITE 0 #define I2C_ADDRESS(addr, mode) ((addr<<1) | mode) uint8_t iter; uint8_t data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; void I2C1_EV_IRQHandler(void) { volatile uint32_t sr1 = module ->SR1, sr2 = module ->SR2; if(sr1 & I2C_SR1_SB) { module ->DR = I2C_ADDRESS(0x14,I2C_MODE_READ); } if(sr1 & I2C_SR1_TXE) { if(iter < 10) { I2C1->DR = data; } else { I2C1->CR1 |= I2C_CR1_STOP; } } }

Код можно модифицировать и далее, создав, например, контекст модуля, сделать одну функцию-обработчик, которая будет на вход принимать только контекст и делать необходимые действия с необходимым модулем и так далее. Например, можно сделать такую функцию:

Void I2C_handler(I2C_TypeDef* module, uint8_t addr, uint8_t data) { volatile uint32_t sr1 = module ->SR1, sr2 = module ->SR2; if(sr1 & I2C_SR1_SB) { module ->DR = I2C_ADDRESS(addr,I2C_MODE_READ); } if(sr1 & I2C_SR1_TXE) { module ->DR = data; module ->CR1 |= I2C_CR1_STOP; } }

Это позволит одну и ту же функцию использовать сразу в двух модулях. Например, мы можем ее вставить вот так:

Void I2C1_EV_IRQHandler(void) { I2C_handler(I2C1, 0x14, 0x10); } void I2C1_EV_IRQHandler(void) { I2C_handler(I2C1, 0x27, 0xFF); }

Еще раз напомню, что адрес устройства, который мы видим в документации - это биты из того байта, который передается модулем, а бит 0 - это режим. Так, указав выше в аргументах адрес 0x14 и режим передачи данных, я получу на передачу байт 0x29. Так как в макросе проверки нет, стоит не забывать, что передавать в него можно максимум адрес 0x7F, иначе получите чехарду.

Для режима чтения все похоже, как можно видеть из диаграммы:

Для обработки нам нужны состояния EV5, EV6, EV7, EV7_1. Статус EV6 по-прежнему сбросится сам после чтения регистров SR1 и SR2, а статус EV7_1 соответствует последнему необходимому байту. Т.е. когда мы приняли предпоследний байт, мы должны отключить отправку сообщения ACK слейву, чтобы следующий байт уже был последним. Итак, возьмем наш предыдущий код и просто внесем в него дополнительный обработчик такого вида, чтобы принять 10 байт данных:

If(sr1 & I2C_SR1_RXNE) { if(rx_iter == 8) { I2C1->CR1 &= ~I2C_CR1_ACK; } else if (rx_iter == 9) { I2C1-> < 10) { rx_data = I2C1->DR; } }

При этом должны быть глобальные переменные:

Uint8_t rx_iter; uint8_t rx_data;

Таким образом, получили вот такой обработчик прерываний для модуля I2C1:

#define I2C_MODE_READ 1 #define I2C_MODE_WRITE 0 #define I2C_ADDRESS(addr, mode) ((addr<<1) | mode) uint8_t iter; uint8_t data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; uint8_t rx_iter; uint8_t rx_data; uint8_t i2c_mode; void I2C1_EV_IRQHandler(void) { volatile uint32_t sr1 = I2C1->SR1, sr2 = I2C1->SR2; if(sr1 & I2C_SR1_SB) { I2C1->DR = I2C_ADDRESS(0x14,i2c_mode); } if(sr1 & I2C_SR1_TXE) { if(iter < 10) { I2C1->DR = data; } else { I2C1->CR1 |= I2C_CR1_STOP; } } if(sr1 & I2C_SR1_RXNE) { if(rx_iter == 8) { I2C1->CR1 &= ~I2C_CR1_ACK; } else if (rx_iter == 9) { I2C1->CR1 |= I2C_CR1_ACK; } if(rx_iter < 10) { rx_data = I2C1->DR; } }

Данных выше хватает, в общем-то, для очень многих случаев, и, поняв логику написания кода выше, можно по документации будет расширить код необходимым. И еще одно - часто для того, чтобы что-то прочитать из slave-устройства, необходимо в него что-то записать.

Post Views: 318

Для использования в дальнейшем понадобилось связать, используя I2C микроконтроллер STM32 с экраном 2004. Не найдя аналогичного решения в сети, публикую здесь. Данный рецепт подойдёт также для экранов 1602. Далее под катом. (Осторожно, картинки).

Игрушечная касса, купленная сыну, оказалось с дефектом, и работала через раз. Появилась идея переделать её внутренности, и момент выбора микроконтроллера совпал с публикацией статьи про STM32 . Немного прикинув и сравнив цены: STM32+LCD2004+I2C = ArduinoMega (причина была в том, что нужно было реализовать клавиатуру, динамик, устройство ввода штрих-кода и экран, поэтому каждый вывод микроконтроллера на счету) я выбрал первый набор.

Были сделаны покупки, и наступило время ожидания. Для прошивки купил ещё USB-USART переходник.

Что и где покупалось.

1. 2004 LCD HD44780 . Оказался без кириллицы. Обращайте внимание на данную особенность при поиске, если нужен русский язык на экране.
2. IIC/I2C/TWI/SP​​I Serial Interface Board Module Port For Arduino 1602LCD Display По описанию совместим с 2004. Но думаю подойдёт любой аналогичный.
3. USB to UART TTL CP2012 для прошивки и отладки. Можно воспользоваться и другими поддерживаемыми способами прошивки и отладки, но этот вариант самый дешевый.

Средства для программирования, прошивки и отладки, используемые мною:

1. Прошивальщик с оригинального сайта: STM32 and STM8 Flash loader demonstrator .
2. Терминал для чтения сигналов от MK через USB2UART: Terminal v1.91b . Но подойдёт и Putty (Connection->Serial).

После получения микроконтроллера попробовал поиграть с светодиодами, получилось. А потом были несколько часов попыток связать экран с МК. Всё это описывать скучно, попробую вспомнить грабли, на которые напоролся.

Первым опишу подключение. Странно, описывая использование STM32 мало где рисуют схемы, в основном код, сам догадайся, что и как подключить.
Подключение изображу на фотографии (по клику - крупнее).


Данное подключение актуально для STM32F103C8. Для других плат МК проверьте пины подключения I2C1 по даташиту.
USART переходник в USB. Тут понятно. Далее - USART подключаем к STM32 к выведенному около разъема miniUSB USART1. TX к RX и соответственно RX к TX. У меня на USART есть вывод 3v3, я от него и запитал МК. Землю я подключил отдельно, для удобного её отключения во время переключения режимов прошивки и работы. К экрану я припаял I2C (так же на ebay есть экраны с припаянными I2C). Питание для I2C и экрана берётся от 3v3 МК или 5В от USART. Ниже написал про настройку контраста при различном напряжении питании. Далее: SCL от I2C подключается к PB6, SDA от I2C к PB7. Притягивать SCL и SDA к питанию при использовании одного данного устройства нет необходимости.

Первыми граблями был USART. Его я использовал для отладки, в приведённом здесь коде строки работы с ним закомментированы. Но с ним проблему так и не решил. Такое впечатление, что нет синхронизации между компьютером и микроконтроллером до посылки первого символа. Причем если использовать код из примера - то МК прекрасно дублирует получаемый текст, а сам писать не может. Я добился наиболее приемлемого для отладки вывода строк, добавив Delay(500) после каждого символа.

Потом попытался реализовать работу с I2C. Взял код из примера , обратил внимание на комментарии про подвисание МК, проанализировав исходники, увидел что как и автору комментариев, мне необходим сдвиг адреса устройства влево:

//http://microtechnics.ru/stm32-ispolzovanie-i2c/#comment-8109 I2C_Send7bitAddress(I2Cx, slaveAddress<<1, transmissionDirection);
Вставил код и попробовал запустить. Программа повисала на моменте ожидания освобождения шины:

While(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
Тут грабли в адресе I2C устройства. Судя из описания продавца, у меня был адрес 0x20. Вот тут я и потерял 15 минут впустую, но вчитавшись в описание разных моделей I2C переходников, ссылку на которое привёл в своей статье , обратил внимание на последнюю модель и попробовал поменять адрес на 0x27. Всё заработало. Вывод такой: если у Вас на переходнике запаяны A0 A1 A2 - адрес 0x20, не запаяны - 0x27.
Сравните:

Далее - экран. Оказалось, что он прекрасно работает и от 3.3 Вольт, как и переходник I2C (в даташите микросхемы переходника - от 2.5 до 6 В). Но сначала я его проверял от 5В. И контраст был выкручен на максимум. В итоге в результате запуска программы экран был полностью заполнен. Я расстроился и продолжил ковырять код. Но спустя полчаса проснулся и подбежал виновник разработки, я ему показал экран и случайно увидел под углом сбоку, что там что-то написано. Причиной этому является неправильная регулировка контраста. (Извините, если описал тут очевидные вещи, может найдутся такие же, кто этого не знал.)

Ничего не видно

То же самое, но под углом

При 5В питания контраст нужно немного уменьшить. А при 3.3В поставить на максимум, на настройке от 5В ничего не видно. Результат представлен на первой картинке в посте. Мой оказался без русского языка, я это увидел, пролистав символы. Попробовал нарисовать кляксу, не зная, что максимум можно определить 8 своих символов, написал для кляксы 12. Подобрал похожие из китайских, вроде получилось.


Код представлен на гихабе, так как для достижения результата переписал библиотеку от Ардуины.

Кто-то любит пирожки, а кто-то - нет.

Интерфейс i2c широко распространён и используется. В stm32f4 модулей, реализующих данный протокол, аж целых три штуки.
Естественно, с полной поддержкой всего этого дела.

Работа с модулем, в целом, такая же, как и в других контроллерах: даёшь ему команды, он их выполняет и отчитывается о результате:
Я> Шли START.
S> Ок, послал.
Я> Круто, шли адрес теперь. Вот такой: 0xXX.
S> Ок, послал. Мне сказали, что ACK. Давай дальше.
Я> Жив ещё, хорошо. Вот тебе номер регистра: 0xYY, - шли.
S> Послал, получил ACK.
Я> Шли ему теперь данные, вот тебе байт: 0xZZ.
S> Послал, он согласен на большее: ACK.
Я> Фиг ему, а не ещё. Шли STOP.
S> Okay.

И всё примерно в таком духе.

В данном контроллере выводы i2c раскиданы по портам таким образом:
PB6: I2C1_SCL
PB7: I2C1_SDA

PB8: I2C1_SCL
PB9: I2C1_SDA

PB10: I2C2_SCL
PB11: I2C2_SDA

PA8: I2C3_SCL
PC9: I2C3_SDA
Вообще, распиновку периферии удобно смотреть в на 59 странице.

Что удивительно, но для работы с i2c нужны все его регистры, благо их немного:
I2C_CR1 - команды модулю для отправки команд/состояний и выбор режимов работы;
I2C_CR2 - настройка DMA и указание рабочей частоты модуля (2-42 МГц);
I2C_OAR1 - настройка адреса устройства (для slave), размер адреса (7 или 10 бит);
I2C_OAR2 - настройка адреса устройства (если адресов два);
I2C_DR - регистр данных;
I2C_SR1 - регистр состояния модуля;
I2C_SR2 - регистр статуса (slave, должен читаться, если установлен флаги ADDR или STOPF в SR1);
I2C_CCR - настройка скорости интерфейса;
I2C_TRISE - настройка таймингов фронтов.

Впрочем, половина из них типа «записать и забыть».

На плате STM32F4-Discovery уже есть I2C устройство, с коим можно попрактиковаться: CS43L22 , аудиоЦАП. Он подключён к выводам PB6/PB9. Главное, не забыть подать высокий уровень на вывод PD4 (там сидит ~RESET), иначе ЦАП не станет отвечать.

Порядок настройки примерно таков:
1 . Разрешить тактирование портов и самого модуля.
Нам нужны выводы PB6/PB9, потому надо установить бит 1 (GPIOBEN) в регистре RCC_AHB1ENR, чтоб порт завёлся.
И установить бит 21 (I2C1EN) в регистре RCC_APB1ENR, чтоб включить модуль I2C. Для второго и третьего модуля номера битов 22 и 23 соответственно.
2 . Дальше настраиваются выводы: выход Oped Drain (GPIO->OTYPER), режим альтернативной функции (GPIO->MODER), и номер альтренативной функции (GPIO->AFR).
По желанию можно настроить подтяжку (GPIO->PUPDR), если её нет на плате (а подтяжка к питанию обеих линий необходима в любом виде). Номер для I2C всегда один и тот же: 4. Приятно, что для каждого типа периферии заведён отдельный номер.
3 . Указывается текущая частота тактирования периферии Fpclk1 (выраженная в МГц) в регистре CR2. Я так понял, это нужно для расчёта разных таймингов протокола.
Кстати, она должна быть не менее двух для обычного режима и не менее четырёх для быстрого. А если нужна полная скорость в 400 кГц, то она ещё и должна делиться на 10 (10, 20, 30, 40 МГц).
Максимально разрешённая частота тактирования: 42 МГц.
4 . Настраивается скорость интерфейса в регистре CCR, выбирается режим (обычный/быстрый).
Cмысл таков: Tsck = CCR * 2 * Tpckl1, т.е. период SCK пропорционален CCR (для быстрого режима всё несколько хитрее, но в RM расписано).
5 . Настраивается максимальное время нарастания фронта в регистре TRISE. Для стандартного режима это время 1 мкс. В регистр надо записать количество тактов шины, укладывающихся в это время, плюс один:
если такт Tpclk1 длится 125 нс, то записываем (1000 нс / 125 нс) + 1 = 8 + 1 = 9.
6 . По желанию разрешается генерация сигналов прерывания (ошибки, состояние и данных);
7 . Модуль включается: флаг PE в регистре CR1 переводится в 1.

Дальше модуль работает уже как надо. Надо только реализовать правильный порядок команд и проверки результатов. Например, запись регистра:
1 . Сначала нужно отправить START, установив флаг с таким именем в регистре CR1. Если всё ок, то спустя некоторое время выставится флаг SB в регистре SR1.
Хочу заметить один момент, - если нет подтяжки на линии (и они в 0), то этот флаг можно не дождаться вовсе.
2 . Если флаг-таки дождались, то отправляем адрес. Для семибитного адреса просто записываем его в DR прям в таком виде, как он будет на линии (7 бит адреса + бит направления). Для десятибитного более сложный алгоритм.
Если устройство ответит на адрес ACK"ом, то в регистре SR1 появится флаг ADDR. Если нет, то флаг AF (Acknowledge failure).
Если ADDR появился, надо прочитать регистр SR2. Можно ничего там и не смотреть, просто последовательное чтение SR1 и SR2 сбрасывает этот флаг. А пока флаг установлен, SCL удерживается мастером в низком состоянии, что полезно, если надо попросить удалённое устройство подождать с отправкой данных.
Если всё ок, то дальше модуль перейдёт в режим приёма или передачи данных в зависимости от младшего бита отправленного адреса. Для записи он должен быть нулём, для чтения - единицей.
но мы рассматриваем запись, потому примем, что там был ноль.
3 . Дальше отправляем адрес регистра, который нас интересует. Точно так же, записав его в DR. После передачи выставится флаг TXE (буфер передачи пуст) и BTF (передача завершена).
4 . Дальше идут данные, которые можно отправлять, пока устройство отвечает ACK. Если ответом будет NACK, то эти флаги не установятся.
5 . По завершении передачи (или в случае непредвиденного состояния) отправляем STOP: устанавливается одноимённый флаг в регистре CR1.

При чтении всё то же самое. Меняется только после записи адреса регистра.
Вместо записи данных идёт повторная отправка START (повторный старт) и отправка адреса с установленным младшим битом (признак чтения).
Модуль будет ждать данных от устройства. Чтобы поощрать его к отправке следующих байт, надо перед приёмом установить флаг ACK в CR1 (чтобы после приёма модуль посылал этот самый ACK).
Как надоест, флаг снимаем, устройство увидит NACK и замолчит. После чего шлём STOP обычным порядком и радуемся принятым данным.

Вот то же самое в виде кода:
// Инициализация модуля void i2c_Init(void) { uint32_t Clock = 16000000UL; // Частота тактирования модуля (system_stm32f4xx.c не используется) uint32_t Speed = 100000UL; // 100 кГц // Включить тактирование порта GPIOB RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN; // Настроим выводы PB6, PB9 // Open drain! GPIOB->OTYPER |= GPIO_OTYPER_OT_6 | GPIO_OTYPER_OT_9; // Подтяжка внешняя, потому тут не настраивается! // если надо, см. регистр GPIOB->PUPDR // Номер альтернативной функции GPIOB->AFR &= ~(0x0FUL << (6 * 4)); // 6 очистим GPIOB->AFR |= (0x04UL << (6 * 4)); // В 6 запишем 4 GPIOB->AFR &= ~(0x0FUL << ((9 - 8) * 4)); // 9 очистим GPIOB->AFR |= (0x04UL << ((9 - 8) * 4)); // В 9 запишем 4 // Режим: альтернативная функция GPIOB->MODER &= ~((0x03UL << (6 * 2)) | (0x03UL << (9 * 2))); // 6, 9 очистим GPIOB->MODER |= ((0x02UL << (6 * 2)) | (0x02UL << (9 * 2))); // В 6, 9 запишем 2 // Включить тактирование модуля I2C1 RCC->APB1ENR |= RCC_APB1ENR_I2C1EN; // На данный момент I2C должен быть выключен // Сбросим всё (SWRST == 1, сброс) I2C1->CR1 = I2C_CR1_SWRST; // PE == 0, это главное I2C1->CR1 = 0; // Считаем, что запущены от RC (16 МГц) // Предделителей в системе тактирования нет (все 1) // По-хорошему, надо бы вычислять это вс из // реальной частоты тактирования модуля I2C1->CR2 = Clock / 1000000UL; // 16 МГц // Настраиваем частоту { // Tclk = (1 / Fperiph); // Thigh = Tclk * CCR; // Tlow = Thigh; // Fi2c = 1 / CCR * 2; // CCR = Fperiph / (Fi2c * 2); uint16_t Value = (uint16_t)(Clock / (Speed * 2)); // Минимальное значение: 4 if(Value < 4) Value = 4; I2C1->CCR = Value; } // Задаём предельное время фронта // В стандартном режиме это время 1000 нс // Просто прибавляем к частоте, выраженной в МГц единицу (см. RM стр. 604). I2C1->TRISE = (Clock / 1000000UL) + 1; // Включим модуль I2C1->CR1 |= (I2C_CR1_PE); // Теперь можно что-нибудь делать } // Отправить байт bool i2c_SendByte(uint8_t Address, uint8_t Register, uint8_t Data) { if(!i2c_SendStart()) return false; // Адрес микросхемы if(!i2c_SendAddress(Address)) return i2c_SendStop(); // Адрес регистра if(!i2c_SendData(Register)) return i2c_SendStop(); // Данные if(!i2c_SendData(Data)) return i2c_SendStop(); // Стоп! i2c_SendStop(); return true; } // Получить байт bool i2c_ReceiveByte(uint8_t Address, uint8_t Register, uint8_t * Data) { if(!i2c_SendStart()) return false; // Адрес микросхемы if(!i2c_SendAddress(Address)) return i2c_SendStop(); // Адрес регистра if(!i2c_SendData(Register)) return i2c_SendStop(); // Повторный старт if(!i2c_SendStart()) return false; // Адрес микросхемы (чтение) if(!i2c_SendAddress(Address | 1)) return i2c_SendStop(); // Получим байт if(!i2c_ReceiveData(Data)) return i2c_SendStop(); // Стоп! i2c_SendStop(); return true; } Использование: { uint8_t ID = 0; i2c_Init(); // Считаем, что PD4 выставлен в высокий уровень и ЦАП работает (это надо сделать как-нибудь) // Отправка байта в устройство с адресом 0x94, в регистр 0x00 со значением 0x00. i2c_SendByte(0x94, 0x00, 0x00); // Приём байта из устройства с адресом 0x94 из регистра 0x01 (ID) в переменную buffer i2c_ReceiveByte(0x94, 0x01, &ID); }
Конечно, кроме как в учебном примере так делать нельзя. Ожидание окончания действия слишком уж долгое для такого быстрого контроллера.

Первые шаги с STM32 и компилятором mikroC для ARM архитектуры - Часть 4 - I2C, pcf8574 и подключение LCD на базе HD4478

Следующую статью я хочу посвятить работе с распространенным интерфейсом i2c, достаточно часто используемом в разнообразных микросхемах, подключаемых к микроконтроллеру.

I2C представляет собой шину работающую по двум физическим соединениям (помимо общего провода). Достаточно много о ней расписано в Интернете, неплохие статьи есть в Википедии . Кроме того алгоритм работы шины очень понятно описан . В вкратце, шина представят собой двухпроводную синхронную шину. На шине может одновременно находится до 127 устройств (адрес устройства 7-битный, к этому вернемся далее). Ниже приведена типичная схема подключения устройств к i2c шине, с МК в качестве ведущего устройства.

Для i2c все устройства (как мастер так и слейвы) используют open-drain выходы. Проще говоря они могут притягивать шину ТОЛЬКО К ЗЕМЛЕ. Высокий уровень ша шине обеспечивается подтягивающими резисторами. Номинал этих резисторов обычно выбирается в диапазоне от 4,7 до 10 кОм. i2c достаточна чувствительна к физическим линиям, соединяющим устройства, поэто если используется соединение с большой емкостью (например длинный тонкий или экранированный кабель), влияние этой емкости может «размыть» фронты сигналов и помешать нормальной работе шины. Чем меньше подтягивающий резистор, тем меньше влияет эта емкость на характеристику фронтов сигнала, но ТЕМ БОЛЬШЕ НАГРУЗКА на выходные транзисторы на интерфейсах i2c. Значение этих резисторов подбирается для каждой конкретной реализации, но они не должны быть меньше 2,2 кОмов, иначе можно просто спалить выходные транзисторы в устройствах, работающих с шиной.

Шина состоит из двух линий: SDA (линии данных) и SCL (тактирующего сигнала). Тактирует шину Мастер устройство , обычно наш МК. Когда на SCL высокий уровень информация считывается с шины данных. Изменять состояние SDA можно только при низком уровне тактирующего сигнала . При высоком уровне SCL сигнал на SDAизменяется при формировании сигналов START (при высоком уровне SCL сигнал на SDA изменяется высокого на низкий) и STOP - при высоком уровне SCL сигнал на SDA изменяется с низкого на высокий).

Отдельно следует сказать, что в i2c адрес задается 7-битным числом. 8 - младший бит указывает направление передачи данных 0 - означает что слейв будет передавать данные, 1 - принимать. . Вкратце алгоритм работы с i2c такой:

• Высокий уроень на SDA и SCL - шина свободна, можно начинать работу
• Мастер поднимает SCL в 1, и изменяет состояние SDA c 1 на 0 - притягивает его к земле - формируется сигнал START
• Мастер передает 7-битный адрес слейва с битом направления (данные на SDA выставляются когда SCL притянут к земле, и читаются слейвом когда он отпущен). Если слейв не успевает «схавать» предыдущий бит, он притягивает SCL к земле, давая понять мастеру что состаяние шинны данных не нужно менять: «еще читаю предыдущий». После того как мастер отпустил шину он проверяет, отпустил ли ее слейв .
• После передачи 8 бит адреса мастер генерирует 9-й такт и отпускает шину данных. Если слейв услышал и свой адрес и принял его то он прижмет SDA к земле . Так формируется сигнал ASK - принял, все ОК. Если слейв ничего не понял, или его просто там нет то некому будет прижать шину. мастер подождет таймаут и поймет что его не поняли.
• После передачи адреса, если у нас выставлено направление от мастера к слейву (8 бит адреса равен 1), то мастер передает данные в слейв, не забывая после передачи каждого байта проверять наличие ASK от слейва, ожидая обработки поступившей информации ведомым устройством.
• При приеме мастером данных от слейва, мастер сам формирует сигнал ASK после приема каждого байта, а слейв контролирует его наличие. Мастер может специально не послать ASK перед отправкой команды STOP , обычно, так давая понять ведомому, что больше предавать данные не нужно.
• Если после отправки данных мастером (режим записи) необходимо прочитать данные со слейва, то мастер формирует снова сигнал START , отправляя адрес слейва с флагом чтения. (еcли перед командой START не был передан STOP то формируется команда RESTART ). Это используется для смены направления общения мастре-слейв. Например мы передаем слейву адрес регистра, а потом читаем из него данные.)
• По окончанию работы со слейвом мастер формирует сигнал STOP - при высоком уровне тактирующего сигнала формирует переход шины данных с 0 в 1.

В STM 32 есть аппаратно реализованные приемопередатчики i2c шины. Таких модулей в МК может быть 2 или 3. Для их конфигурации используются специальные регистры, описанные в референсе к используемому МК.

В MicroC перед использованием i2c (как впрочем и любой периферии) ее необходимо должным образом проинициализировать. Для этого используем такую функцию (Иннициализация в качестве мастера):

I2Cn_Init_Advanced(unsigned long: I2C_ClockSpeed, const Module_Struct *module);

• n - номер используемого модуля, например I2C1 или I2C2 .
• I2C_ClockSpeed - скорость работы шины, 100000 (100 kbs, стандартный режим) или 400000 (400 kbs, быстрый режим). Второй в 4 раза быстрее, но его поддерживают не все устройства
• *module - указатель на периферийный модуль, например &_GPIO_MODULE_I2C1_PB67 , здесь не забываем что Code Assistant (ctrl-пробел ) очень помогает.

Для начала проверим свободность шины, для этого существует функция I2Cn_Is_Idle(); возвращающая 1 если шина свободна, и 0 если по ней идет обмен.

I2Cn_Start();
где n - номер используемого модуля i2c нашего микроконтроллера. Функция вернет 0 если на шине возникла ошибка и 1 если все ОК.

Для того чтоб передать данные слейву используем функцию:

I2Cn_Write(unsigned char slave_address, unsigned char *buf, unsigned long count, unsigned long END_mode);

• n - номер используемого модуля
• slave_address - 7-битный адрес слейва.
• *buf - указатель на наши данные - байт или массив байтов.
• count - количество передаваемых байт данных.
• END_mode - что делать после передачи данных слейву, END_MODE_STOP - передать сигнал STOP , либо END_MODE_RESTART снова отправить START , сформировав сигнал RESTART и дав понять ведомству, что сеанс работы с ним не окончен и с него сейчас будут читать данные.

Для чтения данных со слейва используется функция:

I2Cn_Read(char slave_address, char *ptrdata, unsigned long count, unsigned long END_mode);

• n - номер используемого модуля
• slave_address - 7-битный адрес слейва.
• *buf - указатель на переменную или массив в который мы принимаем данные, тип char или short int
• count - количество принимаемых байт данных.
• END_mode - что делать после приема данных от слейва - END_MODE_STOP - передать сигнал STOP , либо END_MODE_RESTART отправить сигнал RESTART .

Давайте попробуем что-то подключить к нашему МК. Для начала: распостраненную микросхему PCF8574(A) представляющего собой расширитель портов ввода вывода с управлением по шине i2c. Данная микросхема содержит всего один внутренний регистр, являющийся ее физическим портом ввода-вывода. Тоесть если ей передать байт, он тут-же выставится на ее выводы. Если считать с нее байт (Передать START адрес с флагом чтения, сигнал RESTERT, прочитать данные и в конце сформировать сигнал STOP ) то он отразит логические состояния на ее выводах. Подключим нашу микросхему в соответствии с даташитом:

Адрес микросхемы формируется из состояния выводов A0, А1, А2 . Для микросхемы PCF8574 адрес будет: 0100A0A1A2 . (Например у нас A0, А1, А2 имеют высокий уровень, соответственно адрес нашей микросхемы будет 0b0100111 = 0x27). Для PCF8574A - 0111A0A1A2 , что с нашей схемой подключения даст адрес 0b0111111 = 0x3F . Если, допустим A2 соединить с землей, то адрес для PCF8574A будет 0x3B . Итого на одну шину i2c можно одновременно повесить 16 микросхем, по 8 PCF8574A и PCF8574.

Давайте попробуем что-то передать иннициализировать i2c шину и что-то передать нашей PCF8574.

#define PCF8574A_ADDR 0x3F //Адреc нашей PCF8574 void I2C_PCF8574_WriteReg(unsigned char wData) { I2C1_Start(); // Формируем сигнал START I2C1_Write(PCF8574A_ADDR,&wData, 1, END_MODE_STOP); // Передаем 1 байт данных и формируем сигнал STOP } char PCF8574A_reg; // переменная которую мы пишем в PCF8574 void main () { I2C1_Init_Advanced(400000, &_GPIO_MODULE_I2C1_PB67); // Запускаем I2C delay_ms(25); // Немного подождем PCF8574A_reg.b0 = 0; //зажжем первый светодиод PCF8574A_reg.b1 = 1; // погасим второй светодиод while (1) { delay_ms(500); PCF8574A_reg.b0 = ~PCF8574A_reg.b0; PCF8574A_reg.b1 = ~PCF8574A_reg.b1; //инвертируем состояние светодиодов I2C_PCF8574_WriteReg (PCF8574A_reg); //передадим нашей PCF8574 данные } }
Компилируем и запускаем нашу программу и видим что наши светодиоды попеременно моргают.
Я не просто так подключил светодиоды катодом к нашей PCF8574. Все дело в том, что микросхема при подачи на выход логического 0 честно притягивает свой вывод к земле, а вот при подаче логической 1 подключает его к + питания через источник тока в 100 мкА. Тоесть «честной» логической 1 на выходе не получить. И светодиод от 100 мкА не зажечь. Сделано это для того, чтобы без дополнительных регистров настраивать вывод PCF8574 на вход. Мы просто пишем в выходной регистр 1 (фактически устанавливаем состояния ножки в Vdd) и можем просто коротить его на землю. Источник тока не даст «сгореть» выходному каскаду нашего расширителя ввода/вывода. Если ножка притянута к земле, то на ней потенциал земли, и читается логический 0. Если ножка притянута к +, то читается логическая 1. С одной стороны просто, но с другой, про это всегда нужно помнить, работая с данными микросхемами.

Давайте попробуем прочитать состояние выводов нашей микросхемы-расширителя.

#define PCF8574A_ADDR 0x3F //Адреc нашей PCF8574 void I2C_PCF8574_WriteReg(unsigned char wData) { I2C1_Start(); // Формируем сигнал START I2C1_Write(PCF8574A_ADDR, &wData, 1, END_MODE_STOP); // Передаем 1 байт данных и формируем сигнал STOP } void I2C_PCF8574_ReadReg(unsigned char rData) { I2C1_Start(); // Формируем сигнал START I2C1_Read(PCF8574A_ADDR, &rData, 1, END_MODE_STOP); // Читаем 1 байт данных и формируем сигнал STOP } char PCF8574A_reg; //переменная которую мы пишем в PCF8574 char PCF8574A_out; // переменная в которую мы читаем и PCF8574 char lad_state; //включен либо выключен наш светодиод void main () { I2C1_Init_Advanced(400000, &_GPIO_MODULE_I2C1_PB67); // Запускаем I2C delay_ms(25); // Немного подождем PCF8574A_reg.b0 = 0; // зажжем первый светодиод PCF8574A_reg.b1 = 1; // погасим второй светодиод PCF8574A_reg.b6 = 1; // Притяним выводы 6 и 7 к питанию. PCF8574A_reg.b7 = 1; while (1) { delay_ms(100); I2C_PCF8574_WriteReg (PCF8574A_reg); // пишем данные в РCF8574 I2C_PCF8574_ReadReg (PCF8574A_out); // читаем из РCF8574 if (~PCF8574A_out.b6) PCF8574A_reg.b0 = ~PCF8574A_reg.b0; // Если нажата 1 кнопка (6 бит прочитанного байта из РCF8574 равен 0, то включим/выключим наш светодиод) if (~PCF8574A_out.b7) PCF8574A_reg.b1 = ~PCF8574A_reg.b1; // аналогично для 2 кнопки и 2 светодиода } }
Теперь нажимая на кнопочки мы включаем или отключаем наш светодиод. У микросхемы есть еще вывод INT . На нем формируется импульс каждый раз, когда меняется состояние выводов нашего расширителя ввода/вывода. Подключив его в входу внешнего прерывания нашего МК (как настроить внешние прерывания и как с ними работать я расскажу в одной из следующих статей).

Давайте используя наш расширитель портов подключим через него символьный дисплей. Таких существует великое множество, но практически все они построены на базе чипа-контроллера HD44780 и его клонов. Например я использовал дисплей LCD2004.

Даташит на него и контроллер HD44780 можно с легкостью найти в Интернете. Подключим наш дисплей к РCF8574, а ее, соответственно к нашему STM32.

HD44780 использует параллельный стробируемый интерфейс. Данные передаются по 8 (за один такт) либо 4 (за 2 такта) стробирующего импульса на выводе E . (читаются контроллером дисплея по нисходящему фронту, переходу с 1 в 0). Вывод RS указывает передаем ли мы нашему дисплею данные (RS = 1 ) (символы которые он должен отобразить, фактически из ASCII коды) либо команды (RS = 0 ). RW указывает направление передачи данных, запись либо чтение. Обычно мы пишем данные в дисплей, поэтому (RW = 0 ). Резистор R6 управляет контрастностью дисплея. Просто подключать вход регулировке контрастности к земле или питанию нельзя, иначе ничего не увидите. . VT1 служит для включения и выключения подсветки дисплея по командам МК. В MicroC есть библиотека для работе с такими дисплеями по параллельному интерфейсу, но обычно, тратить на дисплей 8 ног накладно, поэтому я практически всегда использую РCF8574 для работы с такими экранчиками. (Если кому-то будет интересно, то напишу статью про работу с дисплеями на базе HD44780 встроенными в MicroC по параллельному интерфейсу.) Протокол обмена не особо сложный (мы будем использовать 4 линии данных и передавать информацию за 2 такта), его наглядно показывает следующая временная диаграмма:


Перед передачей данных на наш дисплей его надо проинициаллизировать, передав служебные команды. (описаны в даташите, здесь приведем только самые используемые)

• 0x28 - связь с индикатором по 4 линиям
• 0x0C - включаем вывод изображения, отключаем отображение курсора
• 0x0E - включаем вывод изображения, включаем отображение курсора
• 0x01 - очищаем индикатор
• 0x08 - отключаем вывод изображения
• 0x06 - после вывода символа курсор сдвигается на 1 знакоместо

Так как нам будет нужно достаточно часто работать с данным индикатором то создадим подключаемую библиотеку «i2c_lcd.h» . Для этого в Project Maneger Header Files и выберем Add New File . Создадим наш заголовочный файл.

#define PCF8574A_ADDR 0x3F //Адреc нашей PCF8574 #define DB4 b4 // Соответствие выводов PCF8574 и индикатора #define DB5 b5 #define DB6 b6 #define DB7 b7 #define EN b3 #define RW b2 #define RS b1 #define BL b0 //управление подсветкой #define displenth 20 // количество символов в строке нашего дисплея static unsigned char BL_status; // переменная хранящая состояние подсветки (вкл/выкл) void lcd_I2C_Init(void); // Функция иннициализации дисплея и PCF8574 void lcd_I2C_txt(char *pnt); // Выводит на экран строку текста, параметр - указатель на эту строку void lcd_I2C_int(int pnt); // Выводит на экран значение целочисленной переменной, параметр - выводимое значение void lcd_I2C_Goto(unsigned short row, unsigned short col); // перемещает курсор на указанную позицию, параметры row - строка (от 1 до 2 или 4 в зависимости от дисплея) и col - (от 1 до displenth)) void lcd_I2C_cls(); // Очищает экран void lcd_I2C_backlight (unsigned short int state); // Включает (при передаче 1 и отключает - при передаче 0 подсветку дисплея)
Теперь опишем наши фунции, снова идем в Project Maneger клацнем правой кнопкой по папке Sources и выберем Add New File . Создаем файл «i2c_lcd.с» .

#include "i2c_lcd.h" //инклудим наш хедер-файл char lcd_reg; //регистр временного хранения данных отправляемых в PCF8574 void I2C_PCF8574_WriteReg(unsigned char wData) //функция отпарвки данных по i2c в чип PCF8574 { I2C1_Start(); I2C1_Write(PCF8574A_ADDR,&wData, 1, END_MODE_STOP); } void LCD_COMMAND (char com) //функция отправки команды нашему дисплею { lcd_reg = 0; //пишем 0 во временный регистр lcd_reg.BL = BL_status.b0; //пин подсветки выставляем в соответстви со значением переменной, хранящей состояние подсветки lcd_reg.DB4 = com.b4; //выставляем на шину данных индикатора 4 старших бита нащей команды lcd_reg.DB5 = com.b5; lcd_reg.DB6 = com.b6; lcd_reg.DB7 = com.b7; lcd_reg.EN = 1; //ставим строб. вывод в 1 I2C_PCF8574_WriteReg (lcd_reg); //пишем в регистр PCF8574, фактически отправив данные на индикатор delay_us (300); //ждем тайммаут lcd_reg.EN = 0; //сбрасываем строб импульс в 0, индикатор читает данные I2C_PCF8574_WriteReg (lcd_reg); delay_us (300); lcd_reg = 0; lcd_reg.BL = BL_status.b0; lcd_reg.DB4 = com.b0; //то же самое для 4 младших бит lcd_reg.DB5 = com.b1; lcd_reg.DB6 = com.b2; lcd_reg.DB7 = com.b3; lcd_reg.EN = 1; I2C_PCF8574_WriteReg (lcd_reg); delay_us (300); lcd_reg.EN = 0; I2C_PCF8574_WriteReg (lcd_reg); delay_us (300); } void LCD_CHAR (unsigned char com) //отправка индикатору данных (ASCII кода символа) { lcd_reg = 0; lcd_reg.BL = BL_status.b0; lcd_reg.EN = 1; lcd_reg.RS = 1; //отправка символа отличается от отправки команды установкой в 1 бита RS lcd_reg.DB4 = com.b4; //выставляем на входах 4 старших бита lcd_reg.DB5 = com.b5; lcd_reg.DB6 = com.b6; lcd_reg.DB7 = com.b7; I2C_PCF8574_WriteReg (lcd_reg); delay_us (300); lcd_reg.EN = 0; //сбрасываем строб. импульс в 0, индикатор читает данные I2C_PCF8574_WriteReg (lcd_reg); delay_us (300); lcd_reg = 0; lcd_reg.BL = BL_status.b0; lcd_reg.EN = 1; lcd_reg.RS = 1; lcd_reg.DB4 = com.b0; //выставляем на входах 4 младших бита lcd_reg.DB5 = com.b1; lcd_reg.DB6 = com.b2; lcd_reg.DB7 = com.b3; I2C_PCF8574_WriteReg (lcd_reg); delay_us (300); lcd_reg.EN = 0; I2C_PCF8574_WriteReg (lcd_reg); delay_us (300); } void lcd_I2C_Init(void) { I2C1_Init_Advanced(400000, &_GPIO_MODULE_I2C1_PB67); //иннициализируем наш I2c модуль у МК delay_ms(200); lcd_Command(0x28); // Дисплей в режиме 4 бита за такт delay_ms (5); lcd_Command(0x08); //Отключаем вывод данных на дисплей delay_ms (5); lcd_Command(0x01); //Очищаем дисплей delay_ms (5); lcd_Command(0x06); //Включаем автоматический сдвиг курсора после вывода символа delay_ms (5); lcd_Command(0x0C); //Включаем отображение информации без отображения курсора delay_ms (25); } void lcd_I2C_txt(char *pnt) //Вывод строки символов на дисплей { unsigned short int i; //временная переменная индекса масисва символов char tmp_str; //временный массив символов, длиной на 1 больше длинны строки дисплея, так как строку нужно закончить сиv символом NULL ASCII 0x00 strncpy(tmp_str, pnt, displenth); //копируем в нашу временную строку не более displenth символов исходной строки for (i=0; i Теперь подключим только что созданную библиотеку у файлу с нашей главной функцией:

#include "i2c_lcd.h" //инклудим наш хедер-файл unsigned int i; //временная переменная счетчик void main() { lcd_I2C_Init(); //иннициализируем дисплей lcd_I2C_backlight (1); //включим подсветку lcd_I2C_txt ("Hellow habrahabr"); //выведем на дисплей стрроку while (1) { delay_ms(1000); lcd_I2C_Goto (2,1); //перейдем к 1 символу 2 строки lcd_i2c_int (i); //выведем значение на дисплей i++; // инкриментируем счетчик } }

Если все правильно собрано то мы должны увидеть на индикаторе текст и инкриметирующийся каждую секунду счетчик. В общем, ничего сложного:)

В следующей статье мы продолжем разбиратся с i2c протоколом и устройствами работающем с ним. Рассмотрим работу с EEPROM 24XX памятью и акселерометром/гироскопом MPU6050.