USB PIC and software

cipi-cips · May 26, 2013

Hello

I have one little problem if anyone can help

I have manage to find Firmware and Software to control PIC via USB.

Firmware is created in Microchips C18 Compiler, and software is created in C#.
In firmware and software I can set how many USB buffers will be and it is set to 65 (fromHostToDeviceBuffer[65]) for sending and 65 for receiving.

I have 6 servo motors on six ports of PIC (18F4550) and when I send signal for each servo I am using function

fromHostToDeviceBuffer[1] //send data in buffer 1 for 1 servo
fromHostToDeviceBuffer[2] //send data in buffer 2 for 2 servo
fromHostToDeviceBuffer[3] //send data in buffer 3 for 3 servo
fromHostToDeviceBuffer[4] //send data in buffer 4 for 4 servo
fromHostToDeviceBuffer[5] //send data in buffer 5 for 5 servo

And this all works fine I can control 5 servos, but problem comes when I add 1 more servo and one more function to call

fromHostToDeviceBuffer[6] //send data in buffer 6 for 6 servo

when I add this everything stops software blocks and I cant send anything, it is like when I added one more data in one more buffer USB is getting over stacked with data and it cant operate.
All data that I send for each servo are bytes.
Do I send to much data ? Do I need to put some delay between sending each data ?

jayanth.devarayanadurga · May 26, 2013

Data is sent 64 bytes at a time. If data is more than 64 bytes it is sent in second 64 bytes package. Post your full code both uC and C# Codes.

cipi-cips · May 26, 2013

This is from Microchips compiler

Code:

// USBMotorController.c

// includes ///////////////////////////////////////////////////////////////////////////////////////
#include<p18f4550.h>
#include"USBFunctions.h"
#include<timers.h>
#include<delays.h>
#include <stdio.h>

// chip config ////////////////////////////////////////////////////////////////////////////////////
					// clock options, see 18F4550 data sheet figure 2-1 "clock diagram" for explanation
#pragma config PLLDIV = 5				// 20 MHz external clock / PLL prescaler value of 5 = 4 MHz required input to PLL circuit
#pragma config CPUDIV = OSC1_PLL2		// non-PLL postscale / 1 OR PLL postscale / 2 for CPU clock speed, depending on FOSC setting below
#pragma config USBDIV = 2				// USB clock source = 96 MHz PLL source / 2, (full-speed USB mode)

						// if desired, could change this line to "FOSC = HS" & "oscillator postscaler" gate would be used 
						// (not the "PLL postscaler" gate), CPU speed would be 20MHz, USB circuitry would still receive 48Mhz clock
#pragma config FOSC = HSPLL_HS			// use high-speed external osc crystal, & use PLL postscaler gate to feed CPU (CPU speed = 48 MHz)

					// now the other less confusing options . . .
#pragma config FCMEN = OFF				// fail-safe clock monitor disabled
#pragma config IESO = OFF				// internal / external osc switchover bit disabled
#pragma config PWRT = OFF				// power-up timer disabled
#pragma config BOR = OFF				// brown-out reset disabled in hardware & software
#pragma config BORV = 3					// brown-out reset voltage bits, does not matter since brown-out is disabled 
#pragma config VREGEN = ON				// USB voltage regulator enabled (If using USB, capacitor goes on pin 18 (VUSB))
#pragma config WDT = OFF				// watchdog timer disabled
#pragma config WDTPS = 32768			// watchdog timer postscale, does not matter since watchdog timer is disabled
#pragma config CCP2MX = ON				// use RC1 (pin #16) as CCP2 MUX (this is the default pin for CCP2 MUX)
#pragma config PBADEN = OFF				// RB0, RB1, RB2, RB3, & RB4 are configured as digital I/O on reset
#pragma config LPT1OSC = OFF			// disable low-power option for timer 1 (timer 1 in regular mode)
#pragma config MCLRE = OFF				// master clear disabled, pin #1 is for VPP and / or RE3 use
#pragma config STVREN = ON				// stack full/underflow will cause reset
#pragma config LVP = OFF				// single-supply ICSP disabled
#pragma config ICPRT = OFF				// in-circuit debug/programming port (ICPORT) disabled, this feature is not available on 40 pin DIP package
#pragma config XINST = OFF				// instruction set extension and indexed addressing mode disabled (this is the default setting)
#pragma config DEBUG = OFF				// background debugger disabled, RA6 & RB7 configured as general purpose I/O pins
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF			// code protection bits off
#pragma config CPB = OFF				// boot block code protection off
#pragma config CPD = OFF				// data EEPROM code protection off
#pragma config WRT0 = OFF, WRT1 = OFF, WRT2 = OFF, WRT3 = OFF		// write protection bits off
#pragma config WRTC = OFF				// config registers write protection off
#pragma config WRTB = OFF				// boot block is not write protected
#pragma config WRTD = OFF				// data EEPROM is not write protected
#pragma config EBTR0 = OFF, EBTR1 = OFF, EBTR2 = OFF, EBTR3 = OFF	// table read protection bits off
#pragma config EBTRB = OFF				// boot block table read protection off

// #defines ///////////////////////////////////////////////////////////////////////////////////////
#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS	0x1008			// these are necessary to accommodate the special linker file,
#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS	0x1018			// do not change these !!

#define PWM1 PORTDbits.RD7
#define PWM2 PORTDbits.RD6				// output pins
#define PWM3 PORTDbits.RD5
#define PWM4 PORTDbits.RD4
#define PWM5 PORTCbits.RC7
#define PWM6 PORTCbits.RC6



// global variables ///////////////////////////////////////////////////////////////////////////////
extern BYTE g_USBDeviceState;
extern BYTE g_fromHostToDeviceBuffer[65];
extern BYTE g_fromDeviceToHostBuffer[65];

		// format for g_fromHostToDeviceBuffer[]
		// 
		// byte - purpose
		// -------------------------------------
		//	0 - do NOT use this for data, this is initialized to zero in USBstuff.c, leave as is (part of USB protocol)
		//	1 - servo position in degrees, valid range is 0 deg. - 180 deg.
		//	2 - left DC motor, 0x00 => coast, 0x01 => forward, 0x02 => reverse, 0x03 => brake
		//	3 - right DC motor, 0x00 => coast, 0x01 => forward, 0x02 => reverse, 0x03 => brake
		//	4 - stepper direction, 0x00 => hold position, 0x01 => step clockwise, 0x02 => step counterclockwise
		//	5 - unused
		//	6 - unused
		//	7 - unused
		//	8 - usused
		//	9 - unused
		// 10 - unused
		// 11 - unused
		// 12 - unused
		// 13 - unused
		// 14 - usused
		// 15 - unused
		// 16 - unused
		// 17 - unused
		// 18 - unused
		// 19 - unused
		// 20 - usused
		// 21 - unused
		// 22 - unused
		// 23 - unused
		// 24 - unused
		// 25 - unused
		// 26 - usused
		// 27 - unused
		// 28 - unused
		// 29 - unused
		// 30 - unused
		// 31 - usused
		// 32 - unused
		// 33 - unused
		// 34 - unused
		// 35 - unused
		// 36 - unused
		// 37 - usused
		// 38 - unused
		// 39 - unused
		// 40 - unused
		// 41 - unused
		// 42 - unused
		// 43 - usused
		// 44 - unused
		// 45 - unused
		// 46 - unused
		// 47 - unused
		// 48 - unused
		// 49 - usused
		// 50 - unused
		// 51 - unused
		// 52 - unused
		// 53 - unused
		// 54 - unused
		// 55 - usused
		// 56 - unused
		// 57 - unused
		// 58 - unused
		// 59 - unused
		// 60 - unused
		// 61 - usused
		// 62 - unused
		// 63 - unused
		// 64 - unused
		
		// format for g_fromDeviceToHostBuffer[]
		// 
		// byte - purpose
		// -------------------------------------
		//	0 - do NOT use this for data, this is initialized to zero in USBstuff.c, leave as is (part of USB protocol)
		//	1 - unused
		//	2 - unused
		//	3 - unused
		//	4 - unused
		//	5 - unused
		//	6 - unused
		//	7 - unused
		//	8 - usused
		//	9 - unused
		// 10 - unused
		// 11 - unused
		// 12 - unused
		// 13 - unused
		// 14 - usused
		// 15 - unused
		// 16 - unused
		// 17 - unused
		// 18 - unused
		// 19 - unused
		// 20 - usused
		// 21 - unused
		// 22 - unused
		// 23 - unused
		// 24 - unused
		// 25 - unused
		// 26 - usused
		// 27 - unused
		// 28 - unused
		// 29 - unused
		// 30 - unused
		// 31 - usused
		// 32 - unused
		// 33 - unused
		// 34 - unused
		// 35 - unused
		// 36 - unused
		// 37 - usused
		// 38 - unused
		// 39 - unused
		// 40 - unused
		// 41 - unused
		// 42 - unused
		// 43 - usused
		// 44 - unused
		// 45 - unused
		// 46 - unused
		// 47 - unused
		// 48 - unused
		// 49 - usused
		// 50 - unused
		// 51 - unused
		// 52 - unused
		// 53 - unused
		// 54 - unused
		// 55 - usused
		// 56 - unused
		// 57 - unused
		// 58 - unused
		// 59 - unused
		// 60 - unused
		// 61 - usused
		// 62 - unused
		// 63 - unused
		// 64 - unused

// function prototypes ////////////////////////////////////////////////////////////////////////////
void highISR(void);							// interrupt prototypes
void remappedHighISR(void);					//
void yourHighPriorityISRCode(void);			//
											//
void lowISR(void);							//
void remappedLowISR(void);					//
void yourLowPriorityISRCode(void);			//
											//
extern void _startup(void);					//

void yourInit(void);
void yourTasks(void);

void servoControl(void);
void commandServoToAngle2(BYTE angle);
void commandServoToAngle3(BYTE angle);
void commandServoToAngle4(BYTE angle);
void commandServoToAngle5(BYTE angle);
void commandServoToAngle6(BYTE angle);
void commandServoToAngle1(BYTE angle);

///////////////////////////////////////////////////////////////////////////////////////////////////
#pragma code HIGH_INTERRUPT_VECTOR = 0x08
void highISR(void) {
	_asm goto REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS _endasm
}
#pragma code

///////////////////////////////////////////////////////////////////////////////////////////////////
#pragma code REMAPPED_HIGH_INTERRUPT_VECTOR = REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS
void remappedHighISR(void) {
	_asm goto yourHighPriorityISRCode _endasm
}
#pragma code

///////////////////////////////////////////////////////////////////////////////////////////////////
#pragma interrupt yourHighPriorityISRCode
void yourHighPriorityISRCode(void) {
	
	if(PIR1bits.TMR1IF == 1) {						// if timer 1 interrupt occurred . . .
		PIR1bits.TMR1IF = 0;
		servoControl();
	}
	
} // return will be a "retfie fast"
#pragma code

///////////////////////////////////////////////////////////////////////////////////////////////////
#pragma code LOW_INTERRUPT_VECTOR = 0x18
void lowISR(void) {
	_asm goto REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS _endasm
}
#pragma code

///////////////////////////////////////////////////////////////////////////////////////////////////
#pragma code REMAPPED_LOW_INTERRUPT_VECTOR = REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS
void remappedLowISR(void) {
	_asm goto yourLowPriorityISRCode _endasm
}
#pragma code

///////////////////////////////////////////////////////////////////////////////////////////////////
#pragma interruptlow yourLowPriorityISRCode
void yourLowPriorityISRCode(void) {
	// check which int flag is set
	// service int
	// clear int flag
	// etc.
} // return will be a "retfie"
#pragma code

///////////////////////////////////////////////////////////////////////////////////////////////////
#pragma code REMAPPED_RESET_VECTOR = 0x1000
void _reset(void) {
	_asm goto _startup _endasm
}
#pragma code

///////////////////////////////////////////////////////////////////////////////////////////////////
void main(void) {
	USBInit();				// in USBFunctions.c
	yourInit();				// in this file
	while(1) {

		USBTasks();			// in USBFunctions.c
		yourTasks();		// in this file
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////
void yourInit(void) {
								// until we have configured timers and related functionality, turn timers off

	T1CONbits.TMR1ON = 0;			// timer 1 off

	

	
		// config output pins, pin #
	TRISDbits.TRISD7 = 0;
	TRISDbits.TRISD6 = 0;		// 10
	TRISDbits.TRISD5 = 0;
	TRISDbits.TRISD4 = 0;		// 10
	TRISCbits.TRISC7 = 0;
	TRISCbits.TRISC6 = 0;		// 10


	PWM1 = 0;	
	PWM2 = 0;
	PWM3 = 0;
	PWM4 = 0;
	PWM5 = 0;
	PWM6 = 0;
	

	
	RCONbits.IPEN = 1;				// enable priority level on interrupts
	INTCONbits.GIE = 1;		// enable high-priority interrupts
	
								// timer 1 config
	PIE1bits.TMR1IE = 1;			// enable timer 1 overflow interrupt
	IPR1bits.TMR1IP = 1;			// timer 1 overflow interrupt priority set to high
	
	T1CONbits.T1CKPS1 = 0;			// timer 1 prescale 1:2
	T1CONbits.T1CKPS0 = 1;			//
	
	T1CONbits.T1OSCEN = 0;			// turn off separate oscillator that is internal to timer 1
	T1CONbits.TMR1CS = 0;			// use internal clock to increment timer 1
								// end timer 1 config
	
	T1CONbits.TMR1ON = 1;			// timer 1 on
	
}

void yourTasks(void) {

	if(g_USBDeviceState == CONFIGURED_STATE) {
		
		receiveViaUSB();											// read into input buffer
		
		// process inputs here (check g_fromHostToDeviceBuffer[x])
		// set outputs here (set g_fromDeviceToHostBuffer[x])
		//		sendViaUSB();
										// we call the DC motor function directly,
									// note that the interrupts will call the servo and stepper functions
	}		
}

void servoControl(void) {
	
	
	if(g_USBDeviceState == CONFIGURED_STATE) {					// if USB connection . . .
		
		commandServoToAngle2(g_fromHostToDeviceBuffer[1]);		// command servo to angle specified by USB input buffer		
		commandServoToAngle3(g_fromHostToDeviceBuffer[2]);
		commandServoToAngle4(g_fromHostToDeviceBuffer[3]);
		commandServoToAngle5(g_fromHostToDeviceBuffer[4]);	
		commandServoToAngle6(g_fromHostToDeviceBuffer[5]);		
		commandServoToAngle1(g_fromHostToDeviceBuffer[6]);	
		
	} else {									// else if no USB connection . . .
											// command servo to angle specified by input pot
	}
}

void commandServoToAngle2(BYTE angle) {
	int i;
	int servo_delay;
	
	servo_delay = ((int)((float)angle*4.71));
	
							// now we begin servo pulse high, pulse times are:
							// 1.0 ms => servo at   0 deg
							// 1.5 ms => servo at  90 deg
							// 2.0 ms => servo at 180 deg

	PWM2 = 1;
			// turn RB4 on, begin pulse high
	
	for(i=-120; i<servo_delay; i++) {
		Delay10TCY();			// note TCY = 0.083333us, this call will delay 0.083333us * 10 = 0.83333us
	}
	

	PWM2 = 0;
			// turn RB4 off, end pulse high
	
}

void commandServoToAngle3(BYTE angle) {
	int i;
	int servo_delay;
	
	servo_delay = ((int)((float)angle*37.68));
	
							// now we begin servo pulse high, pulse times are:
							// 1.0 ms => servo at   0 deg
							// 1.5 ms => servo at  90 deg
							// 2.0 ms => servo at 180 deg

	PWM3 = 1;
			// turn RB4 on, begin pulse high
	
	for(i=-120; i<servo_delay; i++) {
		Delay10TCY();			// note TCY = 0.083333us, this call will delay 0.083333us * 10 = 0.83333us
	}
	

	PWM3 = 0;
			// turn RB4 off, end pulse high
	
}

void commandServoToAngle4(BYTE angle) {
	int i;
	int servo_delay;
	
	servo_delay = ((int)((float)angle*4.71));
	
							// now we begin servo pulse high, pulse times are:
							// 1.0 ms => servo at   0 deg
							// 1.5 ms => servo at  90 deg
							// 2.0 ms => servo at 180 deg

	PWM4 = 1;
			// turn RB4 on, begin pulse high
	
	for(i=-120; i<servo_delay; i++) {
		Delay10TCY();			// note TCY = 0.083333us, this call will delay 0.083333us * 10 = 0.83333us
	}
	PWM4 = 0;
			// turn RB4 off, end pulse high
	
}

void commandServoToAngle5(BYTE angle) {
	int i;
	int servo_delay;
	
	servo_delay = ((int)((float)angle*4.71));
	
							// now we begin servo pulse high, pulse times are:
							// 1.0 ms => servo at   0 deg
							// 1.5 ms => servo at  90 deg
							// 2.0 ms => servo at 180 deg

	PWM5 = 1;
			// turn RB4 on, begin pulse high
	
	for(i=-120; i<servo_delay; i++) {
		Delay10TCY();			// note TCY = 0.083333us, this call will delay 0.083333us * 10 = 0.83333us
	}
	PWM5 = 0;
			// turn RB4 off, end pulse high
	
}

void commandServoToAngle6(BYTE angle) {
	int i;
	int servo_delay;
	
	servo_delay = ((int)((float)angle*4.71));
	
							// now we begin servo pulse high, pulse times are:
							// 1.0 ms => servo at   0 deg
							// 1.5 ms => servo at  90 deg
							// 2.0 ms => servo at 180 deg

	PWM6 = 1;
			// turn RB4 on, begin pulse high
	
	for(i=-120; i<servo_delay; i++) {
		Delay10TCY();			// note TCY = 0.083333us, this call will delay 0.083333us * 10 = 0.83333us
	}
	PWM6 = 0;
			// turn RB4 off, end pulse high
	
}
void commandServoToAngle1(BYTE angle) {
	int i;
	int servo_delay;
	
	servo_delay = ((int)((float)angle*4.71));
	
							// now we begin servo pulse high, pulse times are:
							// 1.0 ms => servo at   0 deg
							// 1.5 ms => servo at  90 deg
							// 2.0 ms => servo at 180 deg

	PWM1 = 1;
			// turn RB4 on, begin pulse high
	
	for(i=-120; i<servo_delay; i++) {
		Delay10TCY();			// note TCY = 0.083333us, this call will delay 0.083333us * 10 = 0.83333us
	}
	PWM1 = 0;
			// turn RB4 off, end pulse high	
}

This is from C#

Code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;


///////////////////////////////////////////////////////////////////////////////////////////////////
namespace USBMotorController {

	/////////////////////////////////////////////////////////////////////////////////////////////////
	public partial class Form1 : Form {

		// constants //////////////////////////////////////////////////////////////////////////////////
		// member variables ///////////////////////////////////////////////////////////////////////////
		public USBClass USBObject;
        int p = 0;

		///////////////////////////////////////////////////////////////////////////////////////////////
		public Form1() {
			InitializeComponent();
			USBObject = new USBClass();
            
		}

		///////////////////////////////////////////////////////////////////////////////////////////////
		private void Form1_Load(object sender, EventArgs e) {
			attemptUSBConnectionFrontEnd();						// attempt USB connection
		}

		///////////////////////////////////////////////////////////////////////////////////////////////
		private void lblInfo_Click(object sender, EventArgs e) {
			if (USBObject.connectionState == USBClass.CONNECTION_NOT_SUCCESSFUL)
			{				// verify not already connected . . .
				attemptUSBConnectionFrontEnd();														// then attempt to connect again
			}
		}

		///////////////////////////////////////////////////////////////////////////////////////////////////
		void attemptUSBConnectionFrontEnd()
		{
			lblInfo.Text = "connecting . . . ";

			USBObject.connectionState = USBObject.attemptUSBConnection();												// attempt to connect to USB board

			if (USBObject.connectionState == USBClass.CONNECTION_SUCCESSFUL)
			{								// if connection was successful
				lblInfo.BackColor = System.Drawing.Color.LimeGreen;
				lblInfo.Text = "connection successful";
				tmrUSB.Enabled = true;
			}
			else if (USBObject.connectionState == USBClass.CONNECTION_NOT_SUCCESSFUL)
			{		// else if connection was not successful
				lblInfo.BackColor = System.Drawing.Color.Red;
				lblInfo.Text = "connection not successful, click here to try again";
			}
		}

		///////////////////////////////////////////////////////////////////////////////////////////////
		private void tmrUSB_Tick(object sender, EventArgs e) {

			//			USBObject.receiveViaUSB();

            USBObject.fromHostToDeviceBuffer[1] = (byte)tbServo.Value;
            USBObject.fromHostToDeviceBuffer[2] = (byte)trackBar1.Value;
            USBObject.fromHostToDeviceBuffer[3] = (byte)trackBar2.Value;
            USBObject.fromHostToDeviceBuffer[4] = (byte)trackBar3.Value;
            USBObject.fromHostToDeviceBuffer[5] = (byte)trackBar4.Value;
            USBObject.fromHostToDeviceBuffer[6] = (byte)trackBar5.Value;

			USBObject.sendViaUSB();
		}

        private void label1_Click(object sender, EventArgs e)
        {
            label1.Text = USBObject.fromHostToDeviceBuffer[1].ToString();
        }

        private void button1_Click(object sender, EventArgs e)
        {

        }

        private void button2_Click(object sender, EventArgs e)
        {

        }

	}		// end class
}		// end namespace

FvM · May 26, 2013

Is it true that adding one more data byte stops USB device operation? I rather guess it's the call to commandServoToAngle1(), that further increases software latency and possibly exceeds the maximum allowed delay to service the USB.

The delay loops are a "rusty" method to generate servo pulses, you should better think of a solution based on hardware timers and timer interrupts. Unfortunately PIC18 hasn't 6 independent hardware PWM outputs.

cipi-cips · May 26, 2013

thx for answer
I have made some experiments and I came out for this conclusion, maybe you will know better how to fix them.

if I send bytes like this

fromHostToDeviceBuffer[1]=255;
fromHostToDeviceBuffer[2]=255;
fromHostToDeviceBuffer[3]=105;

everything blocks just with these 3 buffers, so It seams I cant send more then 615

Welcome to EDAboard.com

USB PIC and software

cipi-cips

Member level 4

jayanth.devarayanadurga

Banned

cipi-cips

Member level 4

FvM

Super Moderator

tpetar

cipi-cips

Member level 4

Similar threads

Part and Inventory Search

Welcome to EDABoard.com

Sponsor

Connect with us

Online statistics

Forum statistics