void Usart1_send( uint8_t*data, uint16_t len)
{
 uint8_t i=0;
 
DMA2_Stream7-> CR &=~ DMA_SxCR_EN;         //wait transmit all data
 //DMA2->HIFCR |= DMA_HIFCR_CTCIF7;               //clear flag transmit
 for(i = 0; i < len; i++)

{
         txData[i]= *data++;
         //copy data to buff
       //  *data++;
        // i++;
        // i=len;
      }
 //
 DMA2_Stream7->NDTR = len;                      //Set len
 DMA2_Stream7->CR |= DMA_SxCR_EN;                 //enable DMA
}

////////////////////////////////////////////////////////////////////////////////
//
//      AbsTrans.h
//
////////////////////////////////////////////////////////////////////////////////

#pragma once

#ifndef __ABSTRACT_TRANSPORT_H__
#define __ABSTRACT_TRANSPORT_H__

#include "MyTypes.h"

////////////////////////////////////////////////////////////////////////////////

#define TRANSPORTS_NAME_LEGHT   16

////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

class AbstractTransport
{
    public:
   
        enum MODE
        {
            BLOCK     = 0,
            NON_BLOCK = 1
        };

        //----------
        //      В STM32 последовательный порт может работать как в терминальном
        // режиме, обрабатывая каждый принятый и отправленный символ, так и в
        // блочном режиме по Модбас-подобным протоколам, используя ДМА и обмен
        // блоками данных. Поэтому определяем как методы для посимвольного
        // ввода-вывода, так и методы для блочного. В наследника наполним их
        // смыслом, применительно к способу использования конкретного порта.

        //----------
        //      Очистка буферов приёмника и передатчика.
        virtual void purgeRxBuff( void ) = 0;
        virtual void purgeTxBuff( void ) = 0;

        //----------
        //      Копирует принятые байты из буфера приёмника физического порта
        // в буфер buff размером buffSize принятые байты. Возвращает число
        // скопированных байтов.
        //      В случае ошибки возвращает отрицательное число.
        virtual int16
        receive
        (
            void*   buff,
            int16   buffSize,
            MODE    mode        = NON_BLOCK
        )
        = 0;

        //----------
        //      Записывает в буфер передатчика физического порта из буфера
        // buff пользователя buffSize байт. Метод не проверяет наличие
        // в буфере передатчика не отправленных с прошлого вызова send байтов!
        // Метод не дожидается окончания отправки всех байтов из buff,
        // а возвращает управление в точку вызова сразу же, как только
        // последний байт из числа buffSize будет записан в буфер передатчика!
        virtual int16   
        send
        (
            void*   buff,
            int16   buffSize,
            MODE    mode    = NON_BLOCK
        )
        = 0;

        //----------
        //      Метод реализует отправку сообщения из буфера и приём ответа
        // в этот же буфер. Во время работы метода будут недоступны
        // и передатчик, и приёмник.
        //      Метод предназначен для реализации эффективного поллинга
        // по проотоколу Modbus и ему подобным протоколам типа ведущий-ведомый.
        virtual int16
        sendAndReceive
        (
                void*   buff,   // Рабочий буфер
                int16   tx_n,   // Количество байт для отправки.
                int16   rx_n,   // Количество байт для приёма.
                int16   timeout // Таймаут для приёма ответа
        )
        { return( 0 ); };

        //----------
        //      Возвращает количество оставшихся в буфере физического
        // передатчика неотправленных байт.
        //      Реализация наследников должна обеспечивать правильную работу
        // следующей конструкции:
        //
        //  if( getAvailableTxBytes() == 0 )
        //      send( buff, buffSize );
        //
        virtual int16 getAvailableTxBytes( void ) = 0;

        //----------
        //      Возвращают количество байт в буфере приёмника.

        virtual int16 getAvailableRxBytes( void ) = 0;

        //----------
        //      Методы-заглушки для поддержки посимвольного ввода-вывода.

        virtual int16 putChar( int16 c ) = 0;
        virtual int16 getChar( void ) = 0;
        virtual bool  peekChar( int16* c ){ return( false ); }

        virtual int16 putString( const char* str ) = 0;

        //----------
        //

        virtual void enableReceiving( void ){};
        virtual void disableReceiving( void ){};

        //----------
        //      Печать диагностической информации об объекте.
       
        virtual ostream& print( ostream& os );
       
        friend ostream& operator << ( ostream& os, AbstractTransport& );
       
        //----------
       
    protected:

        AbstractTransport( const char* name );
        virtual ~AbstractTransport( void );

        char name[ TRANSPORTS_NAME_LEGHT ];
};

////////////////////////////////////////////////////////////////////////////////
#endif  // __ABSTRACT_TRANSPORT__
////////////////////////////////////////////////////////////////////////////////

void Usart1_send( uint8_t*data, uint16_t len)

int _write(int file, char *ptr, int len)
{
   Send_USART1_DMA(ptr, len);
   return len;
}

printf("Hello, world!\r\n")

void usart_send_str(const char* str)
{
    while(*str) {
    while ((USART1->SR & USART_SR_TXE) == 0) {}
       USART1->DR = *str++;
    }
}


void Send_str_USART1_DMA(const char *adr)
{
  DMA1_Channel4->CCR &= ~DMA_CCR1_EN;
  DMA1_Channel4->CMAR = (uint32_t) adr;
  char *p = (char *)adr;
  while(*p) p++;
  DMA1_Channel4->CNDTR = p-adr;
  DMA1_Channel4->CCR |= DMA_CCR1_EN;
}

void Send_USART1_DMA(const char *adr, uint32_t len)
{
   DMA1_Channel4->CCR &= ~DMA_CCR1_EN;
   DMA1_Channel4->CMAR = (uint32_t) adr;
   DMA1_Channel4->CNDTR = len;
   DMA1_Channel4->CCR |= DMA_CCR1_EN;
}

void console_put(const char *text) {
   while(*text) {
      // Пока не нуль-терминатор
      tty0_TX_BUF[tty0_WR_POS] = *text;      // Копируем данные в буфер
      text++;                  // Сдвигаем указатель текста.
      tty0_WR_POS++;               // Сдвигаем указатель на 1 байт дальше.
      if (tty0_WR_POS >= sizeof(tty0_TX_BUF)) tty0_WR_POS = 0;   // Указатель должен быть в пределах допустимых значений.
   };
   // Запускаем.
   tty0_ActivateDMA();
};

//#define SEND(str) usart_send_str(str)
//#define SEND(str) console_put(str)
//#define SEND(str) Send_str_USART1_DMA(str)
//#define SEND_l(str,len) Send_USART1_DMA(str,len)

SEND("\r\n STM32F100RB USART DMA-tx !!! 31");
SEND("\r\n");

printf("Hello, world!\r\n");

      case 1:
        //LCD_Clear();
        sprintf(buf, " a= %4d", a);
        LCD_SetPos(0, 0);
        LCD_String(buf);
        // delay_ms(5);
        break;

sprintf(buf, " a= %4d \r\n", a);
SEND(buf);

sprintf(buf, " a= %4lu \r\n", ms_tick);
SEND(buf);

uint8_t len = sprintf(buf, " a= %4lu \r\n", ms_tick);
Send_USART1_DMA(buf,len); // SEND_l(buf,len);

printf(" a= %4lu \r\n", ms_tick);