Usart verileri parçalı gönderiyor.

[baran123]

Usart ile string gönderiyorum fakat bazen parçalı geliyor ve  bilgisayar arayüzünde şu şekilde bir çıktı olup devam ediyor.

32
.56
32.56
32.56
32.56//böyle gelmesi lazım 
32.5 //ama bazen böyle oluyor:)
6
32.56
32.56
32.
56
32.56

Önce timer3 kurdum.Bundan kaynaklı olabilir mi diye systick ile yaptım.Yaklaşık 1.5 saniyelik ara ile gönderdiğim halde böyle oluyor.Sorun PC mi MCU tarafında mı olabilir ?

https://www.picproje.org/index.php/topic,59883.msg462745/topicseen.html#msg462745

Bu konudaki on iletimdeki gibi gönderme yapıyorum.

[esensoy]

Sale ae gibi bir lojik analizör lazım,

[memo333]

uart tx'i kapatıyor musun?

[baran123]

Lojik analizörüm yok hocam.
Hayır kapatmıyorum.

[memo333]

genelde stm32'de diğer işlemcilerde uart tx ile ilgili iki kontrol regiter flagi oluyor. birincisi transmit bufferın boş olduğunu (TXE) diğeri ise transmisyonun bittiğini(TC) kontrol ediyor. seri olarak veri göndermek için TXE kullanılıyor ancak son byte gönderilmesinde TC flagi kullanılmalı.

Diğer bir konuda PC tarafında kullanılan yazılımlar bazen iyi olmuyor ve USB-232 çeviriciler başarılı olmuyor. Kendi adıma bir tane digitus marka USB/232 çevirici alıncaya kadar rahat edemedim.. 

bunlarda sorunun parçası olabilir..

[z]

Gelen verileri ASCI değil de sayısal değerlerini hex olarak yazdır. Satır atlamaya neden olan data ne ona bir bakmak lazım.

[skara1214]

Gelen verileri ASCI değil de sayısal değerlerini hex olarak yazdır. Satır atlamaya neden olan data ne ona bir bakmak lazım.

hocam öyle olsa sürekli aynı şeyi yapması gerekmezmi?

[z]

Şüpheliyi bulmak için bir yerden başlamak lazım.

Baudrate tam oturmamıştır. İlk bir kaç karakter düzgün giderken baudratedeki sapmadan dolayı 4 karakter bozuluyordur. Ne bileyim olası her şeyi düşünmek lazım.

[skara1214]

Hocam bence haberleşme hızlı olabilir uart usb çevirici kullanıyorsa o arada yapıyor öyle şeyler

[z]

Stringin her bir byte'ını fasılalı olarak yollamayı dene. Sorun devam ediyorsa baudrate'de sapma fazla demektir.

[Klein]

PC tarafında. 
Eventler gerçek zamanlı gelmiyor. Bu sebeple  tamponda bir miktar birikiyor. Event geldiğinde  o an ne kadar  birikmişse siz o kadar veri alıyorsunuz.

[Tagli]

Ama bu durumda parçalı gelse bile yine de yanlış yerde alt satıra geçme olmamalı, tabi eğer bu bir seri port terminal programı çıktısı ise. Yok eğer bilgisayar tarafında bu çıktıyı üreten programı da Baran Ekrem yazmışsa, o zaman programı görmek gerek sağlıklı bir yorum yapabilmek için.

[muhittin_kaplan]

PC tarafındaki kodlarında datareceived eventini nasıl alıyorsun, PC tarafında timer felan mı kullandın ?

[z]

Evet bununla alakalı galiba. Şimdi hatırladım Delphide Buffer uzunluğu ve Timeout durumunda bufferdar alınacak veri sayısı ile ilgili tanımlamalar vardı.

Bufferdan 1 byte al gel şeklinde yapıya dönerse sorun hemencecik düzelecek gibi görünüyor.

[baran123]

Kendim uğraşayım dedim ama çözemedim. PC tarafını ben yazdım. Delegate datareceived event'i ile alıyorum.9600 ve 115200 Baud ile denedim sonuç aynı.

PC tarafı

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;

namespace SerialControl
{
    public partial class MainForm : Form
    {
        bool connectionState = true;
        string InputData = String.Empty;
        SerialPort SP = new SerialPort();

        internal delegate void SerialDataReceivedEventHandlerDelegate(object sender, SerialDataReceivedEventArgs e);

        delegate void SetTextCallback(string text);
        
        public MainForm()
        {
            InitializeComponent();
        }

        private void MainForm_Load(object sender, EventArgs e)
        {
            int[] baudRate = { 300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200 };

            List<String> portList = new List<String>();

            cmbPort.Items.Clear();
            cmbBaud.Items.Clear();

            foreach (string s in SerialPort.GetPortNames())
                portList.Add(s);
       
            cmbPort.Items.AddRange(portList.ToArray());
            cmbPort.SelectedIndex = 0;

            for (int i = 0; i < baudRate.Length; i++)
                cmbBaud.Items.Add(baudRate[i]);
            cmbBaud.SelectedIndex = 0;
        }

        private void SetText(string text)
        {
            this.txtDataRx.AppendText(text + "\r\n");
        }

        private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (SP.IsOpen)
            {
                InputData = SP.ReadExisting();
                if (InputData != String.Empty)
                    this.BeginInvoke(new SetTextCallback(SetText), new object[] { InputData });
            }
            else
                MessageBox.Show("", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        private void CheckEnter(object sender, System.Windows.Forms.KeyPressEventArgs e)
        {
            if (e.KeyChar == (char)13)
            {
                if (SP.IsOpen && txtDataTx.Text != "" )
                {
                    SP.Write(Convert.ToString(txtDataTx.Text) + "\r");
                    txtDataTx.Clear();
                    txtDataTx.Focus();
                }
                else
                    MessageBox.Show("", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            if (SP.IsOpen && txtDataTx.Text != "")
            {
                SP.Write(Convert.ToString(txtDataTx.Text) + "\r");
                txtDataTx.Clear();
                txtDataTx.Focus();
            }
            else
                MessageBox.Show("", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);

        }
        private void btnConnection_Click(object sender, EventArgs e)
        {
            if (connectionState)
            {
                if (!SP.IsOpen)
                {
                    SP.BaudRate = Convert.ToInt32(cmbBaud.SelectedItem);
                    SP.PortName = Convert.ToString(cmbPort.SelectedItem);
                    SP.DataBits = 8;
                    SP.Parity = Parity.None;
                    SP.StopBits = StopBits.One;
                    SP.DataReceived += new SerialDataReceivedEventHandler(SerialPort_DataReceived);

                    SP.Open();
                    
                    connectionState = false;
                    btnConnection.Text = "Disconnect";
                }
                else
                    MessageBox.Show("", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                if (SP.IsOpen)
                    SP.Close();
                connectionState = true;
                btnConnection.Text = "Connect";
            }
        }

        private void btnInfo_Click(object sender, EventArgs e)
        {
        }

        private void btnExit_Click(object sender, EventArgs e)
        {
            if (result == DialogResult.Yes)
            {
                if (SP.IsOpen)
                    SP.Close();
                Environment.Exit(1);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (SP.IsOpen)
                SP.Close();
            Application.Exit();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            txtDataRx.Clear();
            txtDataTx.Focus();
        }
    }
}

ST

#include "stm32f0xx_conf.h"

static unsigned int LEDState = 0;
static void USART_SendString(USART_TypeDef* USARTx, char* _string);

void USART1_IRQHandler(void)
{
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        if((char)USART_ReceiveData(USART1) == '1')
            LEDState = 2;

        if((char)USART_ReceiveData(USART1) == '0')
            LEDState = 1;
    }
    USART_ClearITPendingBit(USART1, USART_IT_RXNE);
}

int main(void)
{
    GPIO_InitTypeDef    GPIO_InitStructure;
    USART_InitTypeDef   USART_InitStrutcure;
    NVIC_InitTypeDef    NVIC_InitStructure;

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOC, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

    GPIO_InitStructure.GPIO_Mode    = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_OType   = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_Pin     = GPIO_Pin_8;
    GPIO_InitStructure.GPIO_PuPd    = GPIO_PuPd_NOPULL;
    GPIO_InitStructure.GPIO_Speed   = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Mode    = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_OType   = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_Pin     = GPIO_Pin_9 | GPIO_Pin_10;
    GPIO_InitStructure.GPIO_PuPd    = GPIO_PuPd_UP;
    GPIO_InitStructure.GPIO_Speed   = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_PinAFConfig(GPIOA, GPIO_PinSource9,  GPIO_AF_1);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_1);

    USART_InitStrutcure.USART_BaudRate              = 115200;
    USART_InitStrutcure.USART_WordLength            = USART_WordLength_8b;
    USART_InitStrutcure.USART_Parity                = USART_Parity_No;
    USART_InitStrutcure.USART_StopBits              = USART_StopBits_1;
    USART_InitStrutcure.USART_HardwareFlowControl   = USART_HardwareFlowControl_None;
    USART_InitStrutcure.USART_Mode                  = USART_Mode_Tx | USART_Mode_Rx;

    USART_Init(USART1, &USART_InitStrutcure);
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    USART_Cmd(USART1, ENABLE);

    NVIC_InitStructure.NVIC_IRQChannel          = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd       = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPriority  = 0;
    NVIC_Init(&NVIC_InitStructure);

    while(1)
    {
        if(LEDState == 2) {
            GPIO_SetBits(GPIOC, GPIO_Pin_8);
            USART_SendString(USART1, "LED On\r\n");
            LEDState = 0;
        }
        if(LEDState == 1) {
            GPIO_ResetBits(GPIOC, GPIO_Pin_8);
            USART_SendString(USART1, "LED Off\r\n");
            LEDState = 0;
        }
    }
    return (0);
}

static void USART_SendString(USART_TypeDef* USARTx, char* s)
{
    while(*s)
    {
        while(!USART_GetFlagStatus(USARTx, USART_FLAG_TC));
        USART_SendData(USARTx, *s);
        s++;
	}
}

PL çipli seri çevirici kullanıyorum.
mesaj birleştirme:: 24 Haziran 2015, 19:33:18
Sanırım ReadExisting ile almaya çlaıştığım için.Byte byte alıp diziye atsam daha iyi olacak gibi ?