PIC32 sendet nur 0x00 über UART (MPLABX)

[RL (Gast)]

Hallo Zusammen

Bei meinem Code will einfach der Serielle Port nur 0x00 senden.
In meinem Terminal kommen daher leider nur "0" an
kann Leider bisher den Fehlr in der Initialisierung des UART nicht 
finden.

Gruß

RL

Code:

/******************************************************************************/
/*  Files to Include                                                          */
/******************************************************************************/
#ifdef __XC32
    #include <xc.h>          /* Defines special funciton registers, CP0 regs  */
#endif

#include <plib.h>           /* Include to use PIC32 peripheral libraries      */
#include <stdint.h>         /* For uint32_t definition                        */
#include <stdbool.h>        /* For true/false definition                      */

#include "system.h"         /* System funct/params, like osc/periph config    */
#include "user.h"           /* User funct/params, such as InitApp             */

/******************************************************************************/
/* Global Variable Declaration                                                */
/******************************************************************************/

/* i.e. uint32_t <variable_name>; */

/******************************************************************************/
/* Main Program                                                               */
/******************************************************************************/


/*
Jarvis Schultz and Jake Ware
2-3-2010

Stepper Motor Control Code

The primary purpose of this code is to drive a stepper motor.  The stepper
motor that we are working with is a 5V Bipolar stepper motor from Portescap
(26M048B1B).  The drive circuitry is basically one-half of an h-bridge attached
to each of the four leads of the motor.  Pins D0-D3 are used to control the
transistors of the h-bridge.  The motor driving is done with a timer interrupt
service routine, and a companion code was written in processing that allows
the user to communicate with the PIC and perform various motor control functions.
In processing, the user has the following capabilities:

  1) The ability to transmit some motor speed to the PIC, and the PIC will
    drive the motor at that speed until the user changes it (they
    can transmit a positive or a negative speed to change direction).
  2) The ability to transmit a motor speed and number of steps to the PIC,
    and the PIC will drive the motor at the desired speed until the desired
    number of steps has been reached
  3) The ability to send a command to stop the motor right where it is.
*/


/** Includes ***************************************************/
//#include "HardwareProfile.h"
#include "stdlib.h"
#include "string.h"
#include "stdio.h"

/** Global Variables ******************************************/
int mot_speed = 0;    // This variable is the current motor speed in steps/ second
int  number_steps = 0;  // This variable is used for tracking how many steps the motor has taken
int motor_phase = 0;  // This variable can be any integer between 0 and 3, and will be used for
          // switching the control wires in the correct order
char RS232_Out_Buffer[32];  // This array is used for temporarily storing data before sending
              // it to the PC; we will be sending current motor steps to the PC
char RS232_In_Buffer[20] = "zzzzzzzzzzzzzzzzzzzz";  //  This is an array that is initialized with
                          // useless data in it; it is used for temporary
                          // storage of data brought in from the PC on UART2
int max_steps = 0;  // This variable is used for position control, we initialize it at a random value
int i = 1;      // This is for marking the position in the RS232_In_Buffer that we are writing into.


/** Defines ***************************************************/
//#define phase_a
//#define phase_b
//#define phase_c
//#define phase_d
#define T3options  T3_ON | T3_PS_1_256 | T3_SOURCE_INT  // These are the setup options for timer three
#define BAUDRATE  19200  //This is the rate that we will communicate over RS232 at

//Outputs


 #define SLEEP LATEbits.LATE9                   // PIN  19   // SLEEP Driver PUT of Power  OFF when is "0": wait 1 ms for wake up
 #define STEP LATAbits.LATA10                  // PIN 29  RA10  // STEP PIN DRIVER
 #define DIR LATAbits.LATA9                  // PIN 28 RA9    // DIR PIN DRIVER

//Communikation Ports
                    // PIN 52 U1 RX (UC Side)       Pin 53 U1 TX (UC SIDE) // Serial Port 1 "ZIGBEE"
                    // Seriel Port 2 "MP3 PLAYER"

// Interface Ports
  #define ON_OFF LATBbits.LATB7                //RB7 PIN27 // ON/ OFF Button
  #define SETUP LATBbits.LATB12               // RB12 PIN 41// SETUP BUTTON
   #define RFID LATBbits.LATB6              // RB6 PIN 26// MOTher MODUL RFID ID Button

   #define ON_OFF_LED LATBbits.LATB15           // PIN 44 // ON/OFF Status LED
    #define AUTO_MODE_LED LATBbits.LATB14          // PIN 43 // MOTHER MODUL or Automatic Mode Status LED
    #define RFID_CHECK_LED LATBbits.LATB13         // PIN  42 //RFID CHECK LED


// Sensor Ports PUMP
  #define LOW_S LATEbits.LATE19                  //RE9 PIN 19// LOW Calibration Switch
  #define HIGH_S LATEbits.LATE8                  //RE8 PIN 18// High Calibration Switch
  #define Int_S_P LATAbits.LATA0                  //RA0 PIN 17// Interrupt Switch Pressure Sensor

// Heart Beat Output
  #define HEART LATBbits.LATB3                //RB3 PIN 22 // Output Port of the Heartbeat



// RFID Reader PIns // Soft uArt

#define SOFT_TX LATBbits.LATB2      //RB2//pin 23 TX
#define SOFT_RX LATBbits.LATB1      //RB1//pin24  RX



/** Function Declarations *************************************/

// MP3 Player UART

//Stepp Motor UART
void initUART1(int pbClk);  // Function for initializing UART1
int GetSteps(void);   // This function returns the current motor position in steps
void SetSteps(int set_steps);  // This function manually changes the number stored in the number of steps variable
void SetSpeed(int motor_speed);  // This function sets the motor speed at the desired speed and begins driving the motor
void sendDataRS232(void); // Used for sending the current motor position to the PC using UART2


/** Main Function: ********************************************/
int main()
{

  char data;  // This variable is the current character in the RS232_In_Buffer
  char state; // This variable is the variable that determines which of the three cases the user has sent to the PIC
  char speedsign; // This variable determines which direction the motor should go
  int speed; // This is the speed of the motor that the user has sent to the PIC (in steps/ second)
  int steps; // If the user has sent a desired number of steps, this is the variable where it gets stored

  int dir; // This corresponds to the speedsign variable, but speedsign is a char, and this is an int
  int PbClk; // Frequency of the peripheral bus clock
  unsigned int count = 0; // This variable is for timing the sending of motor counts to PC
  int j = 1; // This is used for stepping through the RS232_In_Buffer array
  int imark; // This variable is for saving the location of a particular entry in the RS232_In_Buffer
        int n;
  // Let's set the integer pbClk to be the value of the frequency
  // of the peripheral bus clock
  PbClk = SYSTEMConfigPerformance(SYS_FREQ);

  // Let's set the pins D0-D3 to be low digital outputs:
  LATD |=  0b0000000000000000;
  TRISD &= 0b1111100111110000;

        LATA |=  0b0000000000000000;
  TRISA &= 0b1111111111110000;

        LATB |=  0b0000000000000000;
  TRISB &= 0b0000111111110100;

        LATE |=  0b0000000000000000;
  TRISE &= 0b1111110111110000;

        ON_OFF_LED = 1;
        AUTO_MODE_LED =1;
        RFID_CHECK_LED =1;



  // Initialize the LED's:
  //mInitAllLEDs();

  // Allow vector interrupts
    INTEnableSystemMultiVectoredInt();

  // Initialize UART Communication
  
        initUART1(PbClk);
       

  //putsUART2("Program Started\r\n");

        ON_OFF_LED = 0;
        AUTO_MODE_LED =0;
        RFID_CHECK_LED =0;


 


        
        

  while(1)
  {

            
            putsUART1("Run");
           
            ON_OFF_LED = 0;
        AUTO_MODE_LED =0;
        RFID_CHECK_LED =0;


    // This checks to see how many times we have gone through this while loop,
    // if it is a multiple of 1000, we transmit the current step count
    
                    ON_OFF_LED = 1;
        AUTO_MODE_LED =0;
        RFID_CHECK_LED =1;
}

}







/** User Called Functions ************************/
// Following function returns the number of
// steps that the motor has taken:
int GetSteps(void)
{
  return number_steps;
}


// Next function allows to user to re-set a "home" position by
// manually changing the number of steps:
void SetSteps(int set_steps)
{
  INTEnable(INT_T3, 0);
  number_steps = set_steps;
  INTEnable(INT_T3, 1);
}


// This function allows the user to specify the desired motor speed:
void SetSpeed(int motor_speed)  // motor speed in steps/s
{
  if (motor_speed == 0)
  {
  // Turn off timer if motor is stopped:
  T3CONbits.ON = 0;
  // Also, let's turn off all of the phases:
  //phase_a = 0;
  //phase_b = 0;
  //phase_c = 0;
  //phase_d = 0;
        STEP = 0;
  }
  else
  {
  mot_speed = motor_speed;
  int Per;
  Per = (80000000/abs(mot_speed))/256-1;  // set the value in the period register
  OpenTimer3(T3options, Per);
  mT3SetIntPriority( 7);   // set Timer3 Interrupt Priority
  mT3ClearIntFlag();     // clear interrupt flag
  mT3IntEnable( 1);    // enable timer3 interrupts
  }
}



// This function is used for sending the current number of steps
// that the motor has taken back to the PC:
void sendDataRS232()
{
  sprintf(RS232_Out_Buffer,"%d\n",number_steps);
  
  putsUART1(RS232_Out_Buffer);
}



void initUART1(int pbClk)
{
  // define setup Configuration 1 for OpenUARTx
    // Module Enable
    // Work in IDLE mode
    // Communication through usual pins
    // Disable wake-up
    // Loop back disabled
    // Input to Capture module from ICx pin
    // no parity 8 bit
    // 1 stop bit
    // IRDA encoder and decoder disabled
    // CTS and RTS pins are disabled
    // UxRX idle state is '1'
    // 16x baud clock - normal speed
  #define config1   UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

  // define setup Configuration 2 for OpenUARTx
    // IrDA encoded UxTX idle state is '0'
    // Enable UxRX pin
    // Enable UxTX pin
    // Interrupt on transfer of every character to TSR
    // Interrupt on every char received
    // Disable 9-bit address detect
    // Rx Buffer Over run status bit clear
  #define config2    UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

  // Open UART2 with config1 and config2
  OpenUART1( config1, config2, pbClk/16/BAUDRATE-1);  // calculate actual BAUD generate value.

  
}

[runtastic (Gast)]

Jetzt lädst Du den ganzen Schrott erst nochmal als Datei hoch!

[RL (Gast)]

ja coll, here you are

[Der Rächer der Transistormorde (Gast)]

RL schrieb:
> Bei meinem Code will einfach der Serielle Port nur 0x00 senden.
> In meinem Terminal kommen daher leider nur "0" an

Vergiss deinen Code und nimm erst einmal ein Ascii Zeichen. Bei  0x00 
weisst du z.B. nie ob du nur das Startbit mit einer anderen Baudrate 
siehst. 0x55 0xAA sind sinnvoll wenn du ein Scope hast (01010101 und 
10101010 Bitfolge).

[RL (Gast)]

... veilleicht habt ihr das jetz falsch verstanden, ich sende über UART

z.B: putsUART1("Run"); und am Terminal kommt 0x00 0x00 0x00 0x00... an