PIC32 sendet nur 0x00 über UART (MPLABX)

/******************************************************************************/

/*  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.

}