title: arm + serial + uart + monitor in visual c#
body: <p>**</p>
  
  <h2>SOLVED: I enabled the property DTR of the serial port component of visual studio. Now it is working fine. Thank you all.</h2>
  
  <h2>**</h2>
  
  <p>I need some help.</p>
  
  <p>I wrote a program in for my arm processor that sends the character 'a' through UART (USB). The frequency is 1 character/second.
  So, I wrote a program in Visual C# to receive this character and show in a text box. Just a very simple program.</p>
  
  <p>The configurations of the serial communications are OK (baud_rate, stopbit, parity, data_bits)</p>
  
  <p><strong>The problem: I cannot read the character sent by the arm processor.</strong></p>
  
  <p><strong>The facts:</strong></p>
  
  <p><strong>1 - the arm program is working correctly in Putty.</strong></p>
  
  <p><strong>2 - my visual c# program is working correctly with arduino board that has the same code that arm has.</strong></p>
  
  <p>Please guys, look my codes and if you can, help me.</p>
  
  <p>This is the code of ARM:</p>
  
  <pre><code>#include "inc/hw_ints.h"
  #include "inc/hw_memmap.h"
  #include "inc/hw_types.h"
  #include "driverlib/debug.h"
  #include "driverlib/gpio.h"
  #include "driverlib/interrupt.h"
  #include "driverlib/sysctl.h"
  #include "driverlib/uart.h"
  #include "drivers/rit128x96x4.h"
  
  //*****************************************************************************
  //
  //! \addtogroup example_list
  //! &lt;h1&gt;UART Echo (uart_echo)&lt;/h1&gt;
  //!
  //! This example application utilizes the UART to echo text.  The first UART
  //! (connected to the FTDI virtual serial port on the evaluation board) will be
  //! configured in 115,200 baud, 8-n-1 mode.  All characters received on the
  //! UART are transmitted back to the UART.
  //
  //*****************************************************************************
  
  //*****************************************************************************
  //
  // The error routine that is called if the driver library encounters an error.
  //
  //*****************************************************************************
  #ifdef DEBUG
  void
  __error__(char *pcFilename, unsigned long ulLine)
  {
  }
  #endif
  
  //*****************************************************************************
  //
  // The UART interrupt handler.
  //
  //*****************************************************************************
  void
  UARTIntHandler(void)
  {
      unsigned long ulStatus;
  
      //
      // Get the interrrupt status.
      //
      ulStatus = UARTIntStatus(UART0_BASE, true);
  
      //
      // Clear the asserted interrupts.
      //
      UARTIntClear(UART0_BASE, ulStatus);
  
      //
      // Loop while there are characters in the receive FIFO.
      //
      while(UARTCharsAvail(UART0_BASE))
      {
          //
          // Read the next character from the UART and write it back to the UART.
          //
          //UARTCharPutNonBlocking(UART0_BASE, UARTCharGetNonBlocking(UART0_BASE));
          UARTCharPutNonBlocking(UART0_BASE,'a');
  
          SysCtlDelay(16666666); //1.2 ms
  
  
      }
  }
  
  //*****************************************************************************
  //
  // Send a string to the UART.
  //
  //*****************************************************************************
  void
  UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)
  {
      //
      // Loop while there are more characters to send.
      //
      while(ulCount--)
      {
          //
          // Write the next character to the UART.
          //
          UARTCharPutNonBlocking(UART0_BASE, *pucBuffer++);
      }
  }
  
  //*****************************************************************************
  //
  // This example demonstrates how to send a string of data to the UART.
  //
  //*****************************************************************************
  int
  main(void)
  {
      //
      // Set the clocking to run directly from the crystal.
      //
      //SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
      SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
  
      //
      // Initialize the OLED display and write status.
      //
      RIT128x96x4Init(1000000);
      RIT128x96x4StringDraw("UART Echo",            36,  0, 15);
      RIT128x96x4StringDraw("Port:   Uart 0",       12, 16, 15);
      RIT128x96x4StringDraw("Baud:   115,200 bps",  12, 24, 15);
      RIT128x96x4StringDraw("Data:   8 Bit",        12, 32, 15);
      RIT128x96x4StringDraw("Parity: None",         12, 40, 15);
      RIT128x96x4StringDraw("Stop:   1 Bit",        12, 48, 15);
  
      //
      // Enable the peripherals used by this example.
      //
      SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
      SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
  
      //
      // Enable processor interrupts.
      //
      IntMasterEnable();
  
      //
      // Set GPIO A0 and A1 as UART pins.
      //
      GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
  
      //
      // Configure the UART for 115,200, 8-N-1 operation.
      //
      UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600,
                          (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
                           UART_CONFIG_PAR_NONE));
  
      //
      // Enable the UART interrupt.
      //
      IntEnable(INT_UART0);
      UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
  
      UARTFIFOEnable(UART0_BASE);
      UARTEnable(UART0_BASE);
  
      //
      // Prompt for text to be entered.
      //
      UARTSend((unsigned char *)"Enter text: ", 12);
  
      //
      // Loop forever echoing data through the UART.
      //
      while(1)
      {
  
      }
  }
  </code></pre>
  
  <p>This is the Visual C# code:</p>
  
  <pre><code>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 interfaceArduinoVS2013
  {
      public partial class Form1 : Form
      {
  
          string RxString;
  
          public Form1()
          {
              InitializeComponent();
              timerCOM.Enabled = true;
          }
  
          private void atualizaListaCOMs()
          {
              int i;
              bool quantDiferente;    //flag para sinalizar que a quantidade de portas mudou
  
              i = 0;
              quantDiferente = false;
  
              //se a quantidade de portas mudou
              if (comboBox1.Items.Count == SerialPort.GetPortNames().Length)
              {
                  foreach (string s in SerialPort.GetPortNames())
                  {
                      if (comboBox1.Items[i++].Equals(s) == false)
                      {
                          quantDiferente = true;
                      }
                  }
              }
              else
              {
                  quantDiferente = true;
              }
  
              //Se não foi detectado diferença
              if (quantDiferente == false)
              {
                  return;                     //retorna
              }
  
              //limpa comboBox
              comboBox1.Items.Clear();
  
              //adiciona todas as COM diponíveis na lista
              foreach (string s in SerialPort.GetPortNames())
              {
                  comboBox1.Items.Add(s);
              }
              //seleciona a primeira posição da lista
              comboBox1.SelectedIndex = 0;
          }
  
          private void timerCOM_Tick(object sender, EventArgs e)
          {
              atualizaListaCOMs();
          }
  
          private void btConectar_Click(object sender, EventArgs e)
          {
              if (serialPort1.IsOpen == false)
              {
                  try
                  {
                      serialPort1.PortName = comboBox1.Items[comboBox1.SelectedIndex].ToString();
                      serialPort1.Open();
  
                  }
                  catch
                  {
                      return;
  
                  }
                  if (serialPort1.IsOpen)
                  {
                      btConnect.Text = "Disconnect";
                      comboBox1.Enabled = false;
  
                  }
              }
              else
              {
  
                  try
                  {
                      serialPort1.Close();
                      comboBox1.Enabled = true;
                      btConnect.Text = "Connect";
                  }
                  catch
                  {
                      return;
                  }
  
              }
          }
  
          private void Form1_FormClosed(object sender, FormClosedEventArgs e)
          {
              if(serialPort1.IsOpen == true)  // if port opened
               serialPort1.Close();            //close the port
          }
  
          private void btEnviar_Click(object sender, EventArgs e)
          {
              if(serialPort1.IsOpen == true)         
              serialPort1.Write(textBoxSend.Text);  //send the text in the textbox
              RxString = serialPort1.ReadExisting();
              MessageBox.Show(RxString);
          }
  
          private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
          {
              RxString = serialPort1.ReadExisting(); //read data from serial port
              MessageBox.Show(RxString);
              this.Invoke(new EventHandler(trataDadoRecebido));   //call another thread to write the data on textbox
  
          }
  
          private void trataDadoRecebido(object sender, EventArgs e)
          {
  
              textBoxReceive.AppendText(RxString);
          }
      }
  }
  </code></pre>