PROGCONT.RU

Вход Регистрация
О САЙТЕ ГЛАВНАЯ
 

STM8S UART настройка и использование в SPL часть1.

 UART или по русски универсальный асинхронный приёмопередатчик, используется для сопряжение двух или более устройств. Универсальность этого интерфейса заключается в многочисленных вариантах использования от MASTER SPI до работы в небольшой сети с протоколом LIN и даже передачи информации через инфракрасный порт. Асинхронный означает отсутствие сигнала синхронизации передаваемых-принимаемых битов информации поэтому используется всего два вывода один на прием другой на передачу или же всего один двунаправленный.
 Для сопряжения множества UART устройств и осуществления организованной передачи информации между ними одно из них должно быть главным ( MASTER) а все остальные подчиненными ( SLAVE), MASTER инициирует общение SLAVE ожидают когда их выберут для общения.
 На рисунке ниже схема UART1 есть также UART2, UART3, UART4 во всех есть небольшие различия смотрите DATASHEET.

нет рисунка

 Для использования имеются следующие выводы:
UART1_TX-через этот вывод будут отсылаться данные.
UART1_RX-вывод для приема данных.
UART1_CK- вывод для тактирования в режимах SPI и Smart Card.


Описание функций SPL.

UART1_DeInit()-функция возвращает конфигурацию UART к начальным настройкам( по умолчанию) и выключает модуль.

UART1_Init( BaudRate, WordLength, StopBits, Parity, SyncMode, Mode)-функция настройки основных параметров.
Где:
BaudRate-скорость на которой будут передаваться данные, обычно применяют значение 9600 максимальное зависит от стабильности передач.
WordLength-от этого параметра зависит что мы передаем:
UART1_WORDLENGTH_8D-передаются 8 бит данных.
UART1_WORDLENGTH_9D-используется для передачи информации с использованием адреса, если установлен девятый бит в передачи то пришел адресс если нет данные.
StopBits-продолжительность стопового бита который устанавливается после передачи всех данных:
UART1_STOPBITS_1-соответствует продолжительности биту информации, установлен по умолчанию.
UART1_STOPBITS_1_5-продолжительность бит плюс половина, используется только для Smartcard.
UART1_STOPBITS_2-продолжительность два бита.
Parity-устанавливает проверку целостности принятых данных или отключает:
UART1_PARITY_NO-не контролировать целостность передачи данных.
UART1_PARITY_EVEN-включает проверку, если сумма отправленных битов единиц будет четным то бит PARITY равен нулю, нечетное количество PARITY равно единицы.
UART1_PARITY_ODD-тоже включает проверку целостности, если сумма отправленных битов единиц будет четным то бит PARITY равен единицы, нечетное количество PARITY равно нулю.
SyncMode-включение, отключение и настройка вывода UART1_CK, тактирование для устройств SLAVE:
UART1_SYNCMODE_CLOCK_DISABLE-отключаем тактирование.
UART1_SYNCMODE_CLOCK_ENABLE-включаем тактирование.

 Если вы будете использовать этот вывод то следующие параметры должны применяться накладыванием масок например

UART1_Init( 9600, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, (UART1_SyncMode_TypeDef)(UART1_SYNCMODE_CLOCK_ENABLE | UART1_SYNCMODE_CPOL_LOW |UART1_SYNCMODE_CPHA_MIDDLE |UART1_SYNCMODE_LASTBIT_ENABLE), UART1_MODE_TXRX_ENABLE);

my_SyncMode вставляем в функцию UART1_Init вместо стандартных параметров.
 Параметры для масок:
UART1_SYNCMODE_CPOL_LOW-в ожидании на выходе будет низкий уровень, тактовый сигнал высокий.
UART1_SYNCMODE_CPOL_HIGH-тут наоборот, в ожидании на выходе будет высокий уровень, тактовый сигнал низкий.
UART1_SYNCMODE_CPHA_MIDDLE-выборка происходит по первому краю тактового сигнала.
UART1_SYNCMODE_CPHA_BEGINING-выборка уже происходит по второму краю тактового сигнала.
UART1_SYNCMODE_LASTBIT_DISABLE-отключает тактирование последнего бита данных как UART1_WORDLENGTH_8D так и в UART1_WORDLENGTH_9D режиме.
UART1_SYNCMODE_LASTBIT_ENABLE-включает тактирование последнего бита данных, используйте для обычного подключения SPI.
Mode-как будет работать модуль, только на прием данных, на отправку или прием и отправка одновременно:
UART1_MODE_RX_ENABLE-UART только принимает данные.
UART1_MODE_RX_DISABLE-отключает прием.
UART1_MODE_TX_ENABLE-UART только отправляет данные.
UART1_MODE_TX_DISABLE-отключает отправку.
UART1_MODE_TXRX_ENABLE-UART принимает и отправляет данные.

UART1_Cmd( NewState)-функция если NewState буде ENABLE включает UART1, DISABLE соответственно отключает.

UART1_SendData8( Data)-функция отправляет 8 бит данных.

UART1_SendData9( Data)-функция принимает 16 бит( старший и младший байт), если в старшем байте нулевой бит равен 1 то отправляем адрес который будет в младшем байте и должен быть в пределах от 1 до 15 или в старшем байте нулевой бит равен 0 отправляем в младшем байте данные.

UART1_ReceiveData8()-функция вернет из буфера приема байт данных, для проверки наличия данных используйте проверку флага UART1_FLAG_RXNE или используйте соответствующее прерывание.

UART1_ReceiveData9()-возвращает шестнадцатеричный результат младшие 8 бит адрес или данные в зависимости от состояния девятого бита, если установлен то адрес в другом случае данные.

UART1_HalfDuplexCmd( NewState)-NewState ENABLE включает передачу, прием данных через один вывод TX, RX линия не используется, DISABLE отключает и обмен данными будет по TX, RX линиям.

UART1_ITConfig( UART1_IT, NewState)-функция включает и выключает нужные прерывания, список ниже и описание ниже.
 Обработчик прерывания для двух прерываний ниже будет INTERRUPT_HANDLER(UART1_TX_IRQHandler, 17){}
UART1_IT_TXE-сработает когда передающий буфер пуст, можно записывать данные, используйте для не прерывной отправки данных( FRAME).
UART1_IT_TC-сработает когда уходит полностью посылка данных( FRAME).

 Обработчик прерывания для прерываний ниже будет INTERRUPT_HANDLER(UART1_RX_IRQHandler, 18){}
UART1_IT_RXNE_OR-сработает если приемный буфер полон, пришли данные или из за переполнения.
UART1_IT_IDLE-сработает когда UART не принимает и не отправляет данные.
UART1_IT_PE-прерывание ошибки четности или нечетности.
UART1_IT_LBDF-возникнет если будет обнаружено разрыв комбинация, используется в LIN режиме.
UART3_IT_LHDF-прерывание обнаружения Header байта, используется в LIN режиме, применимо в UART2-UART4.

UART1_GetITStatus( UART1_IT)-функция проверяет состояние прерывания включено или выключено.

UART1_ClearITPendingBit( UART1_IT)-функция может сбрасывать только флаги двух прерываний UART1_IT_RXNE и UART1_IT_LBDF.

UART1_GetFlagStatus( UART1_FLAG)-функция проверяет состояние флагов прерывания, описание UART1_FLAG ниже.
UART1_FLAG_TXE-если флаг равен 1 то передающий буфер свободен, сбрасывается пока в нем есть данные.
UART1_FLAG_TC-флаг будет 1 когда отошлется посылка данных( FRAME), сбрасывается программно.
UART1_FLAG_RXNE-если равен 1 то в приемный буфер пришли данные, сбрасывается чтением данных или программно.
UART1_FLAG_IDLE-устанавливается 1 когда UART в ожидании, сбрасывается контроллером когда идет отсылка или прием данных.
UART1_FLAG_OR-если флаг будет 1, значит произошло переполнение приемного буфера, сбрасывается чтением данных.
UART1_FLAG_NF-если во время получения посылки данных на линии были шумы будет установлен 1, используется для проверки целостности данных, сбрасывается контроллером после начала следующего приема.
UART1_FLAG_FE-если при приеме посылки данных был разрыв связи, рассинхронизация или большой шум на приемной линии то будет установлен 1, сбрасывается следующей посылкой.
UART1_FLAG_PE-бит четности, установится 1 если была нарушена целостность данных, сбрасывается следующими данными.
UART1_FLAG_SBK-используется для разрыва отправки данных, устанавливается и сбрасывается программно.
UART1_FLAG_LBDF-устанавливается если на линии связи обнаружена Break комбинация, используется в протоколе LIN, сбрасывается программно.
UART3_FLAG_LHDF-устанавливается после приема Header байта, используется в протоколе LIN, сбрасывается программно.

UART1_GetFlagStatus( UART1_FLAG)-функция возвращает состояние выше перечисленных флагов.

UART1_ClearFlag( UART1_FLAG)-функция сбрасывает флаги прерываний.

UART1_IrDACmd( NewState)-NewState ENABLE включает интерфейс( IrDA) инфракрасного порта, DISABLE отключает.

UART1_IrDAConfig( UART1_IrDAMode)-с помощью этой функции можем выбрать режим работы IrDA, где UART1_IrDAMode будет:
UART1_IRDAMODE_NORMAL-IrDA нормальный режим.
UART1_IRDAMODE_LOWPOWER-режим пониженного потребления.

UART1_LINCmd( NewState)-NewState ENABLE включает UART для работы в небольшой локальной сети LIN, DISABLE отключает.

UART1_LINBreakDetectionConfig( UART1_LINBreakDetectionLength)-функция устанавливает продолжительность сигнала разрыва связи, после его отправки все SLAVE будут в ожидании приема данных.
UART1_LINBreakDetectionLength:
UART1_LINBREAKDETECTIONLENGTH_10BITS-сигнал длиной 10 бит данных.
UART1_LINBREAKDETECTIONLENGTH_11BITS-сигнал длиной 11 бит данных.

UART1_SendBreak()-отсылаем Break сигнал, используется в LIN.

UART3_LINConfig( UART3_Mode, UART3_Autosync, UART3_DivUp)-функция применима для UART2, UART3, UART4 в которой дополнительные настройки выбора MASTER или SLAVE, включение синхронизации или отключение и как будет записываться результат из UART3_BRR1 и UART3_BRR2 в делитель частоты UART, пример на UART3.
UART3_Mode:
UART3_LIN_MODE_MASTER-модуль будет главным( MASTER).
UART3_LIN_MODE_SLAVE-модуль будет подчиненным( SLAVE).
UART3_Autosync:
UART3_LIN_AUTOSYNC_DISABLE-отключаем синхронизацию.
UART3_LIN_AUTOSYNC_ENABLE-включаем синхронизацию.
UART3_DivUp:
UART3_LIN_DIVUP_LBRR1-запись в регистры UART3_BRR1 и UART3_BRR2 данные сразу переносятся в делитель UART.
UART3_LIN_DIVUP_NEXTRXNE-результат из UART3_BRR1 и UART3_BRR2 перенесется в делитель UART после приема байта данных.

UART1_SmartCardCmd( NewState)-NewState ENABLE включает интерфейс для работы с смарт-картой, DISABLE отключает.

UART1_SmartCardNACKCmd( NewState)-NewState ENABLE включает подтверждение принимающим устройством целостности принятых данных выставлением ACK или NACK на линии данных, DISABLE отключает.

UART1_SetGuardTime( UART1_GuardTime)-функция устанавливает защитный интервал времени в течение которого отправляющая сторона ждет ответа о правильном принятии данных, если принимающая сторона в интервал этого времени опустила до земли линию I/O то значит данные повреждены, UART1_GuardTime значение от 0 до 255 умноженное на время одного бита, флаг UART1_FLAG_TC установится после интервала этого времени.

UART1_ReceiverWakeUpCmd( NewState)-NewState ENABLE включает автоматическое пробуждение или выход из сна UART.

UART1_WakeUpConfig( UART1_WakeUp)-функция определяет от чего будет выходить из сна UART, UART1_WakeUp:
UART1_WAKEUP_IDLELINE-выйдет из сна если линия будет в ожидании, например если к линии подключены несколько устройств и пока MASTER( главное) общается с нужным SLAVE( подчиненным) все остальные SLAVE должны не работать или спать.
UART1_WAKEUP_ADDRESSMARK-произойдет пробуждение после получения бита адреса или 9 бит данных.

UART1_SetPrescaler( UART1_Prescaler)-функция устанавливает значение делителя для IrDA и Smartcard mode. Для IrDA записанное значение должно быть от 0 до 65535 в Smartcard mode используется только пять младших битов делителя поэтому можно записать до 31 а реальное будет умноженное на два то есть если записали 3 умножаем на 2 получаем 6.


 Внимание! Выводы контроллера для UART нет необходимости конфигурировать в режиме Full duplex( передача по двум линиям RX и TX) по умолчанию вывод RX будет Float( болтающийся) другое устройство должно обеспечить нужное напряжение, а вывод с линией TX после настройки модуля на передачу будет Push-pull подключен к питанию или земле, использовать как обычный или переконфигурировать вывод можно после отмены настройки UART на отправку. Режим Half duplex( передача по одной линии, перенастраиваемая в RX или TX) тут если используется как RX будет Float( болтающийся) а если TX то будет Open drain подключатся только к земле поэтому нужен внешний подтягивающий резистор.

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


Full duplex режим, одновременно отправка и прием данных.

 О теории передачи информации через UART мы разговаривать не будем так как полно информации в интернете. Для сопряжения устройств возможны три метода подключения это стандартный( используется две линии для передачи и приема, плюс общая земля GND), по одной линии( одна передача-прием плюс земля GND) и с использование вывода для тактирования( используется три линии для передачи, приема и тактирования, плюс общая земля GND), ниже в описаниях использования различных интерфейсах будет показано как подключаются устройства. Да и рекомендую приобрести переходник USB UART для тестирования подключения или использования в дальнейшем как помощника для отладки собственного кода.
 Начнем с обычного интерфейса или стандартное подключение которое мы часто встречаем где используется всего два устройства.

нет рисунка

 Тут все просто RX UART1 к TX UART2 и TX UART1 к RX UART2, теперь пример использования для принятия и отправки данных( Full Duplex), для проверки работы примера соедините вмести RX и TX контроллера и если все правильно будет вывод PD0 менять состояние или если используете как у меня отладочную плату STM8 Value line discovery мигать светодиод.

#include "stm8s.h"
void pause( uint32_t i){for( uint32_t a=0; a<i; a++);}
int main( void )
{
//Настраиваем вывод для светодиода.
GPIO_Init( GPIOD, GPIO_PIN_0, GPIO_MODE_OUT_PP_LOW_FAST);
//Конфигурация UART на отправку 8 бит данных без контроля PARITY, модуль будет работать на прием и отправку.
UART1_Init( 9600, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE);
//Включаем UART.
UART1_Cmd( ENABLE);
while(1){
//Отправляем байт со значение 100.
UART1_SendData8(100);
//Выставляем высокий уровень на ноге светодиода.
GPIO_WriteHigh( GPIOD, GPIO_PIN_0);
pause(50000);
//Проверяем пришли данные.
if(UART1_GetFlagStatus( UART1_FLAG_RXNE)){
//Если пришли, проверяем принятый байт, если равен 100 устанавливаем низкий уровень на светодиоде.
if( UART1_ReceiveData8()==100){
GPIO_WriteLow( GPIOD, GPIO_PIN_0);
pause(50000);
}
}
}
return 0;
}
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t* file, uint32_t line)
{
while (1){}
}
#endif


Непрерывная отправка данных или фреймы.

 Теперь пример для тех кто не знает как отправлять и получать непрерывно Фреймы( данные), тут всю отправку и прием должны делать в прерываниях. В примере отправляем, принимаем массив данных, проверяем одну ячейку массива и если все нормально то вывод PD0 должен менять состояние. Для проверки работы примера соедините вмести RX и TX контроллера.

#include "stm8s.h"
void pause( uint32_t i){ for( uint32_t a=0; a<i; a++);} //Массив для отправки.
uint8_t send_array[5]={ 11,12,13,14,15};
//Массив куда будем принимать данные.
uint8_t rec_array[5];
//Счетчик отправляемых данных.
uint8_t count_send=0;
//Счетчик принимаемых данных.
uint8_t count_rec=0;
int main( void )
{
//Настраиваем вывод для светодиода.
GPIO_Init( GPIOD, GPIO_PIN_0, GPIO_MODE_OUT_PP_LOW_FAST);
//Конфигурация UART на отправку 8 бит данных без контроля PARITY, модуль будет работать на прием и отправку.
UART1_Init( 9600, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE);
//Включаем прерывание от приема данных.
UART1_ITConfig( UART1_IT_RXNE_OR, ENABLE);
//Включаем все прерывания.
enableInterrupts();
//Включаем UART.
UART1_Cmd( ENABLE);
while(1){
//Включаем прерывания если TX буфер свободен и начинаем отправлять данные.
UART1_ITConfig( UART1_IT_TXE, ENABLE);
//Выставляем высокий уровень на ноге светодиода.
GPIO_WriteHigh( GPIOD, GPIO_PIN_0);
//Ожидаем когда передадутся данные.
pause(50000);
//Сравниваем один результата переданных данных, если все нормально выставляем низкий уровень.
if( send_array[2]==rec_array[2]){ GPIO_WriteLow( GPIOD, GPIO_PIN_0);pause(50000);}
}
return 0;
}
//Обработчик для приема данных.
INTERRUPT_HANDLER( UART1_RX_IRQHandler, 18)
{
if(UART1_GetFlagStatus( UART1_FLAG_RXNE)){
//Копируем данные в массив.
rec_array[count_rec]= UART1_ReceiveData8();
//Прибавляем счетчик принятых данных.
count_rec++;
//Если счетчик равен 5 то приняли все данные, сбрасываем его.
if( count_rec==5){count_rec=0;}
}
}
//Обработчик для отсылки данных.
INTERRUPT_HANDLER( UART1_TX_IRQHandler, 17)
{
//Отсылаем данные.
UART1_SendData8( send_array[count_send]);
//Прибавляем счетчик отправленных данных.
count_send++;
//Если счетчик равен 5 то отослали все данные, сбрасываем его и отключаем прерывание TX буфер свободен.
if( count_send==5){
count_send=0;
UART1_ITConfig( UART1_IT_TXE, DISABLE);
}
}

#ifdef USE_FULL_ASSERT
void assert_failed( uint8_t* file, uint32_t line)
{
while (1){}
}
#endif


Подключение с использованием одной линии связи, Half duplex режим.

нет рисунка

 Тут обмен данными будет происходить по одной линии связи и поэтому одно из устройств должно быть MASTER( главный) другой или другие SLAVE( подчиненные), устройство не может одновременно отправлять или принимать данные, что то одно меняя направления UART.
 Разработчики SPL почему то не позаботились о функции которая будет менять направление, поэтому предлагаю свои варианты.

//Так отключается прием и включается отправка данных.
UART1->CR2 &= (uint8_t)(~UART1_CR2_REN);
UART1->CR2 |= (uint8_t)UART1_CR2_TEN;
//Тут наоборот выключаем отправку и включаем прием.
UART1->CR2 &= (uint8_t)(~UART1_CR2_TEN);
UART1->CR2 |= (uint8_t)UART1_CR2_REN;

 Пример кода применим как для MASTER так и для SLAVE устройств, только не забывайте менять направление данных.

#include "stm8s.h"
uint8_t data;
int main( void )
{
//Настраиваем вывод для светодиода.
GPIO_Init( GPIOD, GPIO_PIN_0, GPIO_MODE_OUT_PP_LOW_FAST);
//Конфигурация UART на отправку 8 бит данных без контроля PARITY, модуль будет работать на отправку.
UART1_Init( 9600, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TX_ENABLE);
//Включаем Half duplex режим.
UART1_HalfDuplexCmd( ENABLE);
//Включаем UART.
UART1_Cmd( ENABLE);
while(1){
//Включаем отправку данных.
UART1->CR2 &= (uint8_t)(~UART1_CR2_REN);
UART1->CR2 |= (uint8_t)UART1_CR2_TEN;
//Отправляем данные.
UART1_SendData8(111);
//Ожидаем когда данные уйдут.
while( !UART1_GetFlagStatus( UART1_FLAG_TXE));
while( !UART1_GetFlagStatus( UART1_FLAG_TC));
//Перенастраиваем на прием.
UART1->CR2 &= (uint8_t)(~UART1_CR2_TEN);
UART1->CR2 |= (uint8_t)UART1_CR2_REN;
//Ожидаем когда данные прийдут.
while( !UART1_GetFlagStatus( UART1_FLAG_RXNE));
//Пришли данные, читаем их.
data=UART1_ReceiveData8();
//Меняем состояние светодиода или вывод PD0.
GPIO_WriteReverse( GPIOD, GPIO_PIN_0);
}
return 0;
}
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t* file, uint32_t line)
{
while (1){}
}
#endif

 Другое устройство должно работать аналогично только направление данных должно быть разным.


Передачи с использование адреса или Multiprocessor communication.

 Это описание отправки данных с использованием адреса устройства или UART1_WORDLENGTH_9D режима, рационально применять такой тип обмена информацией в системах где используется более двух устройств из которых одно должно быть MASTER( главный) все остальные SLAVE( подчиненные). Принцип работы следующий все SLAVE находятся во сне, MASTER по общей линии отсылает адрес устройства с которым он хочет общаться тот SLAVE после обнаружения своего адреса пробуждается и начинает работать в обычном режиме, уйти опять в сон сможет когда MASTER отошлет адрес другого SLAVE или программно. Что бы SLAVE отослать MASTER данные он тоже должен использовать его адрес.

нет рисунка

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

//Адрес нужного устройства равен 1.
uint8 address=1;
//Маска 256( биты 0000 0001 0000 0000) определяющая что будет передан адрес.
uint16 mask=256;
//То что отправим.
uint16_t Data=mask|address
UART1_SendData9( Data);

 Данные передаются также только без бита адреса, Data может быть 8 бит или 16 бит, значение в пределах 0-255. Адрес как и данные вы должны обязательно прочесть из RX буфера принимающего UART иначе произойдет переполнение.
 В примере( соединение Full duplex) контроллер сам себе( соедините вместе RX и TX вывод) по своему адресу который равен 1 будет отправлять байт со значением 111, если все нормально то вывод PD0 или светодиод будут менять свое состояние( мигать), для проверки измените в коде программы значение адреса или передаваемого байта тогда PD0 будет в одном состоянии.

#include "stm8s.h"
void pause( uint32_t i){for( uint32_t a=0; a<i; a++);}
int main( void )
{
//Настраиваем вывод для светодиода.
GPIO_Init( GPIOD, GPIO_PIN_0, GPIO_MODE_OUT_PP_LOW_FAST);
//Конфигурация UART на отправку 9 бит данных без контроля PARITY, модуль будет работать на прием и отправку.
UART1_Init( 9600, UART1_WORDLENGTH_9D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE);
//Устанавливаем адрес нашему устройству.
UART1_SetAddress(1);
//Конфигурируем UART просыпаться при обнаружении своего адреса.
UART1_WakeUpConfig( UART1_WAKEUP_ADDRESSMARK);
//Уводим наше устройство в сон.
UART1_ReceiverWakeUpCmd( ENABLE);
//Включаем прерывание от приема данных.
UART1_ITConfig( UART1_IT_RXNE_OR, ENABLE);
//Включаем все прерывания.
enableInterrupts();
//Включаем UART.
UART1_Cmd( ENABLE);
while(1){
//Назначаем адрес.
uint8_t address=1;
//Назначаем маску адреса.
uint16_t mask=256;
//Устанавливаем адрес и бит указывающий на него.
uint16_t Data=address|mask;
//Отправляем адрес.
UART1_SendData9( Data);
while(!UART1_GetFlagStatus( UART1_FLAG_TXE));
//Назначаем байт данных.
Data=111;
//Отправляем байт данных.
UART1_SendData9( Data);
while(!UART1_GetFlagStatus( UART1_FLAG_TXE));
pause(25000);
}
return 0;
}
//Если адрес соответствует значит попадем в этот обработчик прерывания.
INTERRUPT_HANDLER( UART1_RX_IRQHandler, 18){
//Проверяем пришли данные.
if( UART1_GetFlagStatus( UART1_FLAG_RXNE)){
//Байт для чтения из RX буфера.
uint8_t data_rec;
//Эта функция читает адрес и данные.
data_rec= UART1_ReceiveData9();
//Если пришел байт данных 111 то меняем состояние PD0.
if( data_rec==111){ GPIO_WriteReverse( GPIOD, GPIO_PIN_0);}
}
}
#ifdef USE_FULL_ASSERT
void assert_failed( uint8_t* file, uint32_t line)
{
while (1){}
}
#endif

 Так же можете использовать подключение с использованием одной линии связи( Half duplex), настройка и пример изменения направлений данных в <<Подключение с использованием одной линии связи, Half duplex режим.>>.

Статья №25 Дата:17/04/2018

Комментарии.