void setup_ports (void)
{
	if( _UART_JE_ == 1 ) //UART connected to JE pins
	{
	// UART JE port pins -
	/* JE-01 CN20/U1CTS/RD14 		RD14
	  JE-02 U1RTS/BCLK1/CN21/RD15  RD15
	  JE-03 U1RX/RF2 				RF2
	  JE-04 U1TX/RF8 				RF8 */


	PORTSetPinsDigitalIn (IOPORT_F, BIT_2);
	PORTSetPinsDigitalOut (IOPORT_F, BIT_8);
	}
	
	if( _UART_JH_ == 1 ) //UART connected to JH pins
	{ 
	// UART JH port pins - 
	/* JH-01 U2CTS/RF12 			RF12
   	  JH-02 U2RTS/BCLK2/RF13 		RF13
       JH-03 PMA9/U2RX/CN17/RF4 	RF4
	  JH-04 PMA8/U2TX/CN18/RF5 	RF5 */
	
	PORTSetPinsDigitalIn (IOPORT_F, BIT_4);
	PORTSetPinsDigitalOut (IOPORT_F, BIT_5);
	}
}
void PmodHB5_INIT(UART_MODULE uartID)
{
	PORTSetPinsDigitalOut(IOPORT_D, BIT_7); //HB5 Direction
	PORTSetPinsDigitalOut(IOPORT_D, BIT_1); //HB5 Enable
	PORTSetPinsDigitalIn(IOPORT_D, BIT_9);  //HB5 Sensor A
	PORTSetPinsDigitalIn(IOPORT_C, BIT_1);  //HB5 Sensor B

	hBridge.sensorAport = IOPORT_D;
	hBridge.sensorAportBit = BIT_9;
	hBridge.sensorBport = IOPORT_C;
	hBridge.sensorBportBit = BIT_1;
	hBridge.directionPort = IOPORT_D;
	hBridge.directionPortBit = BIT_7;
	hBridge.currentDirection = PMOD_HB5_DIR_CW;
	hBridge.newDirection = PMOD_HB5_DIR_CW;
	hBridge.ocChannel = 2;
	

    OpenOC2(OC_ON | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0, 0);
    OpenTimer2(T2_ON | T2_PS_1_256, SYSTEM_CLOCK/PB_DIV/PRESCALE/(TOGGLES_PER_SEC/2));
    
	OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_256, T1_TICK);
    ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_2);
	INTEnableSystemMultiVectoredInt();
	
	UARTPutS("\r\nPmodHB5 init complete\r\n",uartID);

}
Exemple #3
0
/*
 * Intializes hbridges for the motors
 */
static void init_hbridge_data()
{
   memset(&Motors[LEFT_MOTOR], 0, sizeof(struct hbridge_info));
   memset(&Motors[RIGHT_MOTOR], 0, sizeof(struct hbridge_info));

   // Enable reading value of sensor A
   PORTSetPinsDigitalIn(HBRIDGE_LEFT_SA_PORT, HBRIDGE_LEFT_SA_BIT);
   PORTSetPinsDigitalIn(HBRIDGE_LEFT_SB_PORT, HBRIDGE_LEFT_SB_BIT);
   PORTSetPinsDigitalIn(HBRIDGE_RIGHT_SA_PORT, HBRIDGE_RIGHT_SA_BIT);
   PORTSetPinsDigitalIn(HBRIDGE_RIGHT_SB_PORT, HBRIDGE_RIGHT_SB_BIT);

   // Enable writing direction pin
   PORTSetPinsDigitalOut(HBRIDGE_LEFT_DIR_PORT, HBRIDGE_LEFT_DIR_BIT);
   PORTSetPinsDigitalOut(HBRIDGE_RIGHT_DIR_PORT, HBRIDGE_RIGHT_DIR_BIT);

   // Setup left motor
   Motors[LEFT_MOTOR].state.hbridge_id = LEFT_MOTOR;
   Motors[LEFT_MOTOR].sensor_bit_pos[PMOD_HB_SENSOR_A] = HBRIDGE_LEFT_SA_BIT;
   Motors[LEFT_MOTOR].sensor_port[PMOD_HB_SENSOR_A] = HBRIDGE_LEFT_SA_PORT;
   Motors[LEFT_MOTOR].sensor_bit_pos[PMOD_HB_SENSOR_B] = HBRIDGE_LEFT_SB_BIT;
   Motors[LEFT_MOTOR].sensor_port[PMOD_HB_SENSOR_B] = HBRIDGE_LEFT_SB_PORT;
   Motors[LEFT_MOTOR].dir_port = HBRIDGE_LEFT_DIR_PORT;
   Motors[LEFT_MOTOR].dir_bit = HBRIDGE_LEFT_DIR_BIT;
   Motors[LEFT_MOTOR].ocn = HBRIDGE_LEFT_OC;
   Motors[LEFT_MOTOR].tmrn = HBRIDGE_LEFT_TMR;

   // Setup right motor
   Motors[RIGHT_MOTOR].state.hbridge_id = RIGHT_MOTOR;
   Motors[RIGHT_MOTOR].sensor_bit_pos[PMOD_HB_SENSOR_A] = HBRIDGE_RIGHT_SA_BIT;
   Motors[RIGHT_MOTOR].sensor_port[PMOD_HB_SENSOR_A] = HBRIDGE_RIGHT_SA_PORT;
   Motors[RIGHT_MOTOR].sensor_bit_pos[PMOD_HB_SENSOR_B] = HBRIDGE_RIGHT_SB_BIT;
   Motors[RIGHT_MOTOR].sensor_port[PMOD_HB_SENSOR_B] = HBRIDGE_RIGHT_SB_PORT;
   Motors[RIGHT_MOTOR].dir_port = HBRIDGE_RIGHT_DIR_PORT;
   Motors[RIGHT_MOTOR].dir_bit = HBRIDGE_RIGHT_DIR_BIT;
   Motors[RIGHT_MOTOR].ocn = HBRIDGE_RIGHT_OC;
   Motors[RIGHT_MOTOR].tmrn = HBRIDGE_RIGHT_TMR;

   // Setup function pointers
   Motors[LEFT_MOTOR].state.read_sensor_state = &read_sensor_state;
   Motors[RIGHT_MOTOR].state.read_sensor_state = &read_sensor_state;
   Motors[LEFT_MOTOR].state.set_direction = &set_direction;
   Motors[RIGHT_MOTOR].state.set_direction = &set_direction;
   Motors[LEFT_MOTOR].state.clear_direction = &clear_direction;
   Motors[RIGHT_MOTOR].state.clear_direction = &clear_direction;
   Motors[LEFT_MOTOR].state.set_speed = &set_speed;
   Motors[RIGHT_MOTOR].state.set_speed = &set_speed;
   Motors[LEFT_MOTOR].state.get_speed = &get_speed;
   Motors[RIGHT_MOTOR].state.get_speed = &get_speed;

   // Intialize direction
   set_hbridge_direction(&(Motors[LEFT_MOTOR].state), PMOD_HB_CCW);
   set_hbridge_direction(&(Motors[RIGHT_MOTOR].state), PMOD_HB_CW);

   // Intialize speed
   set_hbridge_speed(&(Motors[LEFT_MOTOR].state), 0);
   set_hbridge_speed(&(Motors[LEFT_MOTOR].state), 0);
   set_target_speed(LEFT_MOTOR, 0);
   set_target_speed(RIGHT_MOTOR, 0);
}
int setup(void) {
    // Optimize system timings
    SYSTEMConfig(SYSCLK, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
    // Setup interrupts
    //INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
    //INTEnableInterrupts();
    // Setup LEDs, these pins need to be outputs
    TRISEbits.TRISE0 = 0;
    TRISEbits.TRISE1 = 0;
    TRISEbits.TRISE2 = 0;
    TRISEbits.TRISE3 = 0;
    // Set all analog pins to be digital I/O
    AD1PCFG = 0xFFFF;
    //Configure SPI
    SpiChnOpen(1, SPI_CON_MSTEN | SPICON_CKE | SPI_CON_MODE8 | SPI_CON_ON, 200);
    PORTSetPinsDigitalIn(IOPORT_E, BIT_4);
    //PORTSetPinsDigitalIn(IOPORT_D, BIT_10);
    //PORTSetPinsDigitalIn(IOPORT_D, BIT_0);
    //PORTSetPinsDigitalIn(IOPORT_C, BIT_4);
    int rData = SPI1BUF;    //Clears receive buffer
    IFS0CLR = 0x03800000;   //Clears any existing event (rx / tx/ fault interrupt)
    SPI1STATCLR = 0x40;      //Clears overflow
    ad7466_cs = 1;          //Make sure CS pin is high

    YLED = 1;  //1 is off, 0 is on
    RLED = 1;
    WLED = 1;
    GLED = 1;
    setupSerial();
    SendDataBuffer("Radiometer Configuration Complete.\n\r", sizeof("Radiometer Configuration Complete.\n\r"));
    return 0;
}
Exemple #5
0
void SERIAL_Init(void) {
    transmitBuffer = (struct CircBuffer*) &outgoingUart; //set up buffer for receive
    newCircBuffer(transmitBuffer);

    receiveBuffer = (struct CircBuffer*) &incomingUart; //set up buffer for transmit
    newCircBuffer(receiveBuffer);

    UARTConfigure(UART1, 0x00);
    UARTSetDataRate(UART1, F_PB, 115200);
    UARTSetFifoMode(UART1, UART_INTERRUPT_ON_RX_NOT_EMPTY | UART_INTERRUPT_ON_TX_BUFFER_EMPTY);

    INTSetVectorPriority(INT_UART_1_VECTOR, INT_PRIORITY_LEVEL_4); //set the interrupt priority

    //RPC5R = 1;
    PPSOutput(1, RPC5, U1TX);
    PORTSetPinsDigitalIn(IOPORT_C, BIT_3);
    //U1RXRbits.U1RXR = 0b111;
    PPSInput(3, U1RX, RPC3);

    UARTEnable(UART1, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
    INTEnable(INT_U1RX, INT_ENABLED);
    //INTSetFlag(INT_U1RX);
    //INTEnable(INT_U1TX, INT_ENABLED);
    //PutChar('z');
}
Exemple #6
0
//////////////////////////////////////////////////////////////////////////////////
/// name: initialization
/// params: none
/// return: void
/// desc: contains the configuration of hardware and clock, as well as
///       the initialization of variables
void intialization(void)
{
    // button input pin
    PORTSetPinsDigitalIn(IOPORT_E, BUTTON); 
    // LED output pin
    PORTSetPinsDigitalOut(IOPORT_E, LED_1); 
    // motor direction pin
    PORTSetPinsDigitalOut(IOPORT_B, DC_MOTOR_1);  
	

    // configuring timer  
    OpenTimer2(T2_ON | T2_PS_1_1, TERMINAL_COUNT);
    OpenOC4(OC_ON | OC_TIMER_MODE16 | OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE, 0x80, 0x60); 
  
    // start these values at 0
    _risetime = 0;
    _falltime = 0;
    _hitime = 0;
  
    // motor starts stationary
    _motorState = STOP;	
    _motorGo = 0;
  
    // start arm fully retracted
    _faketach = 0;
  
    // set these values to 1, as they should start out not
    // equal to _risetime and _falltime for initial pwm read
    _store = 1;
    _ftore = 1;
  
}
Exemple #7
0
void START_Init (void)
{
#ifdef _TARGET_440H
#else
	PORTSetPinsDigitalIn(IO_START);
#endif
}
Exemple #8
0
void InitCRModule(void){
    WORD TiempoT4 = 1; //En mseg;
    WORD Prescaler = 32; //Selecciono el prescaler, si lo
                                   //cambio revisar opentimer.
    WORD CuentaT4 = (TiempoT4)*(CLOCK_FREQ/((1<<mOSCGetPBDIV())*Prescaler*1000));

    OpenTimer4(T4_ON | T1_IDLE_CON | T4_GATE_OFF | T4_PS_1_32 | T4_32BIT_MODE_OFF | T4_SOURCE_INT, CuentaT4);
    /*Pongo la int de nivel 3 porque de nivel 4 fastidia las interrupciones del transceptor. Dentro de nivel 3
    le doy maxima subprioridad.*/
    ConfigIntTimer4(T4_INT_ON | T4_INT_PRIOR_3 | T4_INT_SUB_PRIOR_3);

    mCNOpen(CN_ON | CN_IDLE_CON, CN14_ENABLE, CN_PULLUP_DISABLE_ALL);
    PORTSetPinsDigitalIn(IOPORT_D, BIT_5);
    mPORTDRead();
    ConfigIntCN(CHANGE_INT_ON | CHANGE_INT_PRI_3);//6);

    CRM_Optm_Init();
    CRM_Poli_Init();
    CRM_AccCtrl_Init();
    //Creamos una entrada en la tabla de permisos.
    ACCCTRL_MSSG_RCVD PeticionCrearEntrada;
    PeticionCrearEntrada.Action = ActAddEntry;
    #if defined NODE_1
        //BYTE EUI_Permiso[] = {0x01, EUI_1, EUI_2, EUI_3, EUI_4, EUI_5, EUI_6, EUI_7};
        BYTE EUI_Permiso[] = {EUI_0, EUI_1, EUI_2, EUI_3, EUI_4, EUI_5, EUI_6, 0x22};
    #elif defined NODE_2
        //BYTE EUI_Permiso[] = {0x05, EUI_1, EUI_2, EUI_3, EUI_4, EUI_5, EUI_6, EUI_7};
        BYTE EUI_Permiso[] = {EUI_0, EUI_1, EUI_2, EUI_3, EUI_4, EUI_5, EUI_6, 0x11};
    #endif
    PeticionCrearEntrada.DirecOrigen = EUI_Permiso;
    CRM_Message(NMM, SubM_AccCtrl, &PeticionCrearEntrada);
    //Fin de la creacion de entrada de la tabal de permisos.
    NodoCerrado = FALSE; //Para que pueda aceptar peticiones de acciones de otros nodos.
    CRM_Repo_Init();
}
Exemple #9
0
void COLOR_Init (void)
{
#ifdef _TARGET_440H
#else
	PORTSetPinsDigitalIn(IO_COLOR);
#endif
}
Exemple #10
0
void InitializeSystem()
{
	SYSTEMConfigWaitStatesAndPB(CLOCK_FREQ);
	mOSCSetPBDIV(OSC_PB_DIV_4);  // Set to get 20MHz PB clock
  //mOSCSetPBDIV(OSC_PB_DIV_2);
	CheKseg0CacheOn();
	mJTAGPortEnable(0);

	// Initialize the pins to all digital output and driven to ground.
	// Exception is RE7 and RE6 which are switch inputs
	PORTSetPinsDigitalIn(IOPORT_E, BIT_6);
	PORTSetPinsDigitalIn(IOPORT_E, BIT_7);

	mPORTASetPinsDigitalOut(0xFFFF);
	mPORTBSetPinsDigitalOut(0xFFFF);
	mPORTCSetPinsDigitalOut(0xFFFF);
	mPORTDSetPinsDigitalOut(0xFFFF);
	mPORTESetPinsDigitalOut(0xFF3F);
	mPORTFSetPinsDigitalOut(0xFFFF);
	mPORTGSetPinsDigitalOut(0xFFFF);

	mPORTAClearBits(0xFFFF);
	mPORTBClearBits(0xFFFF);
	mPORTCClearBits(0xFFFF);
	mPORTDClearBits(0xFFFF);
	mPORTEClearBits(0xFF3F);
	mPORTESetBits(0x000F);		// LED latches need to be set high for off
	mPORTFClearBits(0xFFFF);
	mPORTGClearBits(0xFFFF);

	INTEnableSystemMultiVectoredInt();

  #ifdef SANITY_CHECK
  mLED_Green_On();
  #endif
	
	//LCD_Initialize();
	//WIFI_Initialize();
	//SPRINKLER_Initialize();
	//RTCC_Initialize(); 
  //SERIALUSB_Initialize();
	SDCARD_Initialize();

  TCPIP_Initialize();
}
Exemple #11
0
void Setup_ports(void)
{
    //Setup ESC pins for PWM output
    PORTSetPinsDigitalOut(IOPORT_D, BIT_0); //PWM1-OC1 digital pin 3
    PORTSetPinsDigitalOut(IOPORT_D, BIT_1); //PWM2-OC2 digital pin 5
    PORTSetPinsDigitalOut(IOPORT_D, BIT_2); //PWM3-OC3 digital pin 6
    PORTSetPinsDigitalOut(IOPORT_D, BIT_3); //PWM4-OC4 digital pin 9

    //Setup Input Capture pins
    PORTSetPinsDigitalIn(IOPORT_D, BIT_8);  //IC1 digital pin 2  (THRO)
    PORTSetPinsDigitalIn(IOPORT_D, BIT_9);  //IC2 digital pin 7  (AILE)
    PORTSetPinsDigitalIn(IOPORT_D, BIT_10); //IC3 digital pin 8  (ELEV)
    PORTSetPinsDigitalIn(IOPORT_D, BIT_11); //IC4 digital pin 35 (RUDD)
    PORTSetPinsDigitalIn(IOPORT_D, BIT_12); //IC5 digital pin 10 (GEAR)

    //Toggle pin for Timer 5
    //PORTSetPinsDigitalOut(IOPORT_F, BIT_1); //pin 4
}
Exemple #12
0
void DeviceInit()
{
	// Configure left motor direction pin and set default direction.
	trisMtrLeftDirSet	= ( 1 << bnMtrLeftDir );
	prtMtrLeftDirSet	= ( 1 << bnMtrLeftDir );	// forward
	
	// Configure right motor diretion pin and set default direction.
	trisMtrRightDirClr	= ( 1 << bnMtrRightDir );	//modify for JD
	prtMtrRightDirClr	= ( 1 << bnMtrRightDir );	// forward

	// Configure Output Compare 2 to drive the left motor.
	OC2CON	= ( 1 << 2 ) | ( 1 << 1 );	// pwm
	OC2R	= dtcMtrStopped;
	OC2RS	= dtcMtrStopped;

	// Configure Output Compare 3.
	OC3CON = ( 1 << 3 ) | ( 1 << 2 ) | ( 1 << 1 );	// pwm
	OC3R	= dtcMtrStopped;
	OC3RS	= dtcMtrStopped;

	// Configure Timer 2.
	TMR2	= 0;		// clear timer 2 count
	PR2		= 9999;

	// Configure Timer 3.
	TMR3	= 0;
	PR3		= 9999;

	// Start timers and output compare units.
	T2CON		= ( 1 << 15 ) | ( 1 << TCKPS20 )|(1 << TCKPS21);	// timer 2 prescale = 8
	OC2CONSET	= ( 1 << 15 );	// enable output compare module 2
	OC3CONSET	= ( 1 << 15 );	// enable output compare module 3
	T3CON		= ( 1 << 15 ) | ( 1 << TCKPS31 ) | ( 1 << TCKPS30); //timer3 prescale = 8

	// Configure Timer 5.
	TMR5	= 0;
	PR5		= 99; // period match every 100 us
	IPC5SET	= ( 1 << 4 ) | ( 1 << 3 ) | ( 1 << 2 ) | ( 1 << 1 ) | ( 1 << 0 ); // interrupt priority level 7, sub 3
	IFS0CLR = ( 1 << 20);
	IEC0SET	= ( 1 << 20);
	
	// Start timers.
	T5CON = ( 1 << 15 ) | ( 1 << 5 ) | ( 1 << 4 ); // fTimer5 = fPb / 8
	
	// Setup light sensor pins
	PORTSetPinsDigitalIn(IOPORT_B, BIT_0 | BIT_3);
	
	// Change notice configured for CN 2 through 5 for light sensors.
	mCNOpen(CN_ON, (CN2_ENABLE | CN3_ENABLE | CN4_ENABLE | CN5_ENABLE), CN_PULLUP_DISABLE_ALL);
	ConfigIntCN(CHANGE_INT_OFF | CHANGE_INT_PRI_2);
	    
	// Enable multi-vector interrupts.
	INTEnableSystemMultiVectoredInt();
}
Exemple #13
0
int main(void)
{
    initPic32();

    PORTSetPinsDigitalIn(IOPORT_A, BIT_0);
    PORTSetPinsDigitalIn(IOPORT_A, BIT_1);
    PORTSetPinsDigitalIn(IOPORT_B, BIT_14);

    PPSInput(1, SS1, RPA0);
    PPSInput(2, SDI1, RPA1);

#ifndef NO_SDO
    PPSOutput(3, RPA2, SDO1);
#endif

    SpiChnOpen(1, SPI_OPEN_MODE8|SPI_OPEN_SLVEN|SPI_OPEN_SSEN
#ifdef NO_SDO
               |SPI_OPEN_DISSDO
#endif
               , 2);

    init();

    uint8_t lastByteReceived = 0;
    uint8_t cmd[8];
    uint8_t length=0;
    uint8_t toRead = 1;
    while(1) {
        if(SpiChnTxBuffEmpty(1))
            SpiChnPutC(1, lastByteReceived);
        lastByteReceived = 0;

        while(!SpiChnDataRdy(1))
            loop();
        uint8_t byte = SpiChnGetC(1);
        cmd[length++] = byte;
        toRead--;
        if(toRead==0)
            toRead = commandReceived(cmd, length);
    }
}
void OledHostTerm()
{

	/* Make the Data/Command select, Reset, and SPI CS pins be inputs.
	*/
	PORTSetBits(prtDataCmd, bitDataCmd);
	PORTSetPinsDigitalIn(prtDataCmd, bitDataCmd);		//Data/Command# select
	PORTSetBits(prtReset, bitReset);
	PORTSetPinsDigitalIn(prtReset, bitReset);

	/* Make power control pins be inputs. The pullup resistors on the
	** board will ensure that the power supplies stay off.
	*/
	PORTSetBits(prtVddCtrl, bitVddCtrl);
	PORTSetBits(prtVbatCtrl, bitVbatCtrl);
	PORTSetPinsDigitalIn(prtVddCtrl, bitVddCtrl);		//VDD power control (1=off)
	PORTSetPinsDigitalIn(prtVbatCtrl, bitVbatCtrl);	//VBAT power control (1=off)

	/* Turn SPI port 2 off.
	*/
	#if defined (_BOARD_UNO_)
		SPI2CON = 0;
	#elif defined (_BOARD_MEGA_)
		PORTSetBits(prtSck, bitSck);
		PORTSetBits(prtMosi, bitMosi);
		PORTSetPinsDigitalIn(prtSck, bitSck);
    PORTSetPinsDigitalIn(prtMosi, bitMosi);
	#endif
}
Exemple #15
0
/********************************************************************
 Funciton: void JoyStickInitialization(void)
********************************************************************/
void JoyStickInitialize(void)
{
    // configure the input pins
    PORTSetPinsDigitalIn(IOPORT_B, (BIT_0 | BIT_1 | BIT_3 | BIT_4 | BIT_15));

    joystickCntrl.value = 0;

    // set the change notice pins
    // going to have to use the SFR names here so that I do not overide anything
    CNPUESET = _CNPUE_CNPUE2_MASK | _CNPUE_CNPUE3_MASK | _CNPUE_CNPUE5_MASK | _CNPUE_CNPUE6_MASK | _CNPUE_CNPUE12_MASK;
    CNENSET = _CNEN_CNEN2_MASK | _CNEN_CNEN3_MASK | _CNEN_CNEN5_MASK | _CNEN_CNEN6_MASK | _CNEN_CNEN12_MASK;
    CNCONSET = _CNCON_ON_MASK;

}
Exemple #16
0
void CLIC_Init (void)
{
#ifdef _TARGET_440H
	PORTSetPinsDigitalIn(IOPORT_B, BIT_3);
	PORTSetPinsDigitalIn(IOPORT_B, BIT_2);
	PORTSetPinsDigitalIn(IOPORT_B, BIT_4);
#else
	PORTSetPinsDigitalIn(IO_CLIC_1);
	PORTSetPinsDigitalIn(IO_CLIC_2);
	PORTSetPinsDigitalIn(IO_CLIC_3);
	PORTSetPinsDigitalIn(IO_CLIC_4);
#endif
}
void SetupMenu() // Set up menu
{
	uint8 i;

	while(1)
	{
	  i = GetMenuItem("TERMINAL SETUP","WiFi Setup","ESPUSB Fudge","Scan WiFi","Test Wifi","Exit");

  	if(i==1) SetupWIFI();

		if(i==2) // Open USB in CDC Mode passthough to ESP-01
    {
      SerialPurge(WIFI_UART);
      CLS();
      LCDWriteStrAt(0,4, "  USB <-> ESP01 ");
      LCDWriteStrAt(0,6, "   PROGRAMMIING   ");
      LCDWriteStrAt(0,10,"  PRESS KEY TO ");
      LCDWriteStrAt(0,12,"    CONTINUE    ");
      
      PORTSetPinsDigitalIn(IOPORT_C,  BIT_2 );
      PPSUnLock;					// Unlock PPS (Peripheral Pin Select) to allow PIN Mapping
      PPSOutput(4,RPC2,NULL); 
      PPSLock;						// lock PPS
      ESP_PGM(0);
      WIFI_PWR(1);
      i = WaitEvent(9999);
      CLS();
      WIFI_PWR(0);
      ESP_PGM(1);
  		DelayMs(500);
      WIFI_PWR(1);
      LCDWriteStrAt(0,4, "  USB <-> ESP01 ");
      LCDWriteStrAt(0,6, "   PASSTHROUGH   ");
      LCDWriteStrAt(0,10,"  POWER OFF TO ");
      LCDWriteStrAt(0,12,"     RESUME     ");
      while(1);
    }

		if(i==4) 
    {		
      if(CheckWIFI()) LCDInform("SUCCESS","Connection OK");
    }

		if(i==3) {	LCDInform("WARNING","Not Implemented");	}

		if(i==0 ||i==5) return;
	}
}
Exemple #18
0
int main()
{
    mJTAGPortEnable(DEBUG_JTAGPORT_OFF);
    mPORTFClearBits(BIT_0);

    // Make all lower 8-bits of PORTA as output
    mPORTFSetPinsDigitalOut( BIT_0 );
    TRISE=0x0;
    PORTE = 0x0f;

    // Start timer1, Fpb/256, max period
    OpenTimer1(T1_ON | T1_PS_1_256 | T1_SOURCE_INT, 0xFFFF);

    // The main loop

    PORTSetPinsDigitalIn(IOPORT_D, BIT_5);
    mCNOpen(CN_ON, CN14_ENABLE, 0);

    // Read the port to clear any mismatch on change notice pins
    int dummy = PORTD;

    // Clear change notice interrupt flag
    ConfigIntCN(CHANGE_INT_ON | CHANGE_INT_PRI_2);

    INTEnableSystemMultiVectoredInt();

    uart1_init(115200);
    setbuf(stdin, NULL); //no input buffer (for scanf)
    setbuf(stdout, NULL); //no output buffer (for printf)

    printf ("Hello World!\r\n");


    while( 1)
    {
        putchar(getchar());
        WriteTimer1(0);
        while ( TMR1 < LONG_DELAY);
        PORTE+=1;
    }
}
Exemple #19
0
static void SetPic32MZIoPins(void)
{
    PORTSetPinsDigitalOut(_ETH_MDC_PORT, _ETH_MDC_BIT);
    PORTSetPinsDigitalIn(_ETH_MDIO_PORT, _ETH_MDIO_BIT);

    PORTSetPinsDigitalOut(_ETH_TXEN_PORT, _ETH_TXEN_BIT);
    PORTSetPinsDigitalOut(_ETH_TXD0_PORT, _ETH_TXD0_BIT);
    PORTSetPinsDigitalOut(_ETH_TXD1_PORT, _ETH_TXD1_BIT);


    PORTSetPinsDigitalIn(_ETH_RXCLK_PORT, _ETH_RXCLK_BIT);
    PORTSetPinsDigitalIn(_ETH_RXDV_PORT, _ETH_RXDV_BIT);
    PORTSetPinsDigitalIn(_ETH_RXD0_PORT, _ETH_RXD0_BIT);
    PORTSetPinsDigitalIn(_ETH_RXD1_PORT, _ETH_RXD1_BIT);
    PORTSetPinsDigitalIn(_ETH_RXERR_PORT, _ETH_RXERR_BIT);
}
Exemple #20
0
void openSerial(unsigned char serialPortIndex, unsigned long baudRate) {
    // important to activate the RX for UART5. Information found on the net
    if (serialPortIndex == SERIAL_PORT_5) {
        PORTSetPinsDigitalIn(IOPORT_B, BIT_8);
    }
    UART_MODULE uart = getUartModule(serialPortIndex);
    UARTConfigure(uart, UART_ENABLE_PINS_TX_RX_ONLY);
    UARTSetFifoMode(uart, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
    UARTSetLineControl(uart, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
    UARTSetDataRate(uart, GetPeripheralClock(), baudRate);
    UARTEnable(uart, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));

    INTEnable(INT_SOURCE_UART_RX(uart), INT_ENABLED);
    INTSetVectorPriority(INT_VECTOR_UART(uart), INT_PRIORITY_LEVEL_2);
    INTSetVectorSubPriority(INT_VECTOR_UART(uart), INT_SUB_PRIORITY_LEVEL_0);

    // TODO : Move this code to Global Setup !

    // configure for multi-vectored mode
    INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);

    // enable interrupts
    INTEnableInterrupts();
}
int main(void)
{
//LOCALS
	unsigned int temp;
	unsigned int channel1, channel2;
	M1_stepPeriod = M2_stepPeriod = M3_stepPeriod = M4_stepPeriod = 50; // in tens of u-seconds
	unsigned char M1_state = 0, M2_state = 0, M3_state = 0, M4_state = 0;

	SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

/* TIMER1 - now configured to interrupt at 10 khz (every 100us) */
	OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_1, T1_TICK);
	ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_2);
/* TIMER2 - 100 khz interrupt for distance measure*/
	OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, T2_TICK);
	ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_3); //It is off until trigger

/* PORTA b2 and b3 for servo-PWM */
	mPORTAClearBits(BIT_2 | BIT_3);
	mPORTASetPinsDigitalOut(BIT_2 | BIT_3);

/* ULTRASONICS: some bits of PORTB for ultrasonic sensors */
	PORTResetPins(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11 );	
	PORTSetPinsDigitalOut(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11); //trigger
/* Input Capture pins for echo signals */
	//interrupt on every risging/falling edge starting with a rising edge
	PORTSetPinsDigitalIn(IOPORT_D, BIT_8| BIT_9| BIT_10| BIT_11); //INC1, INC2, INC3, INC4 Pin
	mIC1ClearIntFlag();
	OpenCapture1(  IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//front
	ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
	OpenCapture2(  IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//back
	ConfigIntCapture2(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
	OpenCapture3(  IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//left
	ConfigIntCapture3(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
	OpenCapture4(  IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//right
	ConfigIntCapture4(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);

/* PINS used for the START (RD13) BUTTON */
    PORTSetPinsDigitalIn(IOPORT_D, BIT_13);
	#define CONFIG          (CN_ON | CN_IDLE_CON)
	#define INTERRUPT       (CHANGE_INT_ON | CHANGE_INT_PRI_2)
	mCNOpen(CONFIG, CN19_ENABLE, CN19_PULLUP_ENABLE);
	temp = mPORTDRead();

/* PORT D and E for motors */
	//motor 1
	mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7); 		// Turn on PORTD on startup.
	mPORTDSetPinsDigitalOut(BIT_4 | BIT_5 | BIT_6 | BIT_7);	// Make PORTD output.
	//motor 2
	mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4); 		// Turn on PORTC on startup.
	mPORTCSetPinsDigitalOut(BIT_1 | BIT_2 | BIT_3 | BIT_4);	// Make PORTC output.
	//motor 3 and 4
	mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
					BIT_4 | BIT_5 | BIT_6 | BIT_7); 		// Turn on PORTE on startup.
	mPORTESetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
					BIT_4 | BIT_5 | BIT_6 | BIT_7);	// Make PORTE output.

// UART2 to connect to the PC.
	// This initialization assumes 36MHz Fpb clock. If it changes,
	// you will have to modify baud rate initializer.
    UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
    UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
    UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
    UARTSetDataRate(UART2, GetPeripheralClock(), BAUD);
    UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
	// Configure UART2 RX Interrupt
	INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
    INTSetVectorPriority(INT_VECTOR_UART(UART2), INT_PRIORITY_LEVEL_2);
    INTSetVectorSubPriority(INT_VECTOR_UART(UART2), INT_SUB_PRIORITY_LEVEL_0);


/* PORTD for LEDs - DEBUGGING */
	mPORTDClearBits(BIT_0 | BIT_1 | BIT_2);
	mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2);

	

// Congifure Change/Notice Interrupt Flag
	ConfigIntCN(INTERRUPT);
// configure for multi-vectored mode
    INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// enable interrupts
    INTEnableInterrupts();


	counterDistanceMeasure=600; //measure ULTRASONICS distance each 60 ms

	while (1) {
	
/***************** Robot MAIN state machine *****************/
		unsigned char ret = 0;
		switch (Robo_State) {
			case 0:
				MotorsON = 0;
				Robo_State = 0;

				InvInitialOrientation(RESET);
				TestDog(RESET);
				GoToRoom4short(RESET);
				BackToStart(RESET);
				InitialOrientation(RESET);
				GoToCenter(RESET);
				GoToRoom4long(RESET);
				break;
			case 1:
				ret = InvInitialOrientation(GO);
				if (ret == 1) {
					Robo_State = 2;
				}
				break;
			case 2:
				ret = TestDog(GO);
				if (ret == 1) {
					Robo_State = 3;		//DOG not found
				} else if (ret == 2) {
					Robo_State = 4;		//DOG found
				}
				break;
			case 3:
				ret = GoToRoom4short(GO);
				if (ret == 1) {
					Robo_State = 0;
				}
				break;
			case 4:
				ret = BackToStart(GO);
				if (ret == 1) {
					Robo_State = 5;
				}
				break;
			case 5:
				ret = GoToCenter(GO);
				if (ret == 1) {
					Robo_State = 6;
				}
				break;
			case 6:
				ret = GoToRoom4long(GO);
				if (ret == 1) {
					Robo_State = 0;
				}
				break;
		}

		if (frontDistance < 30 || backDistance < 30 || leftDistance < 30 || rightDistance < 30)
			mPORTDSetBits(BIT_0);
		else 
			mPORTDClearBits(BIT_0);
/***************************************************************/


/***************** Motors State Machine ************************/

		if (MotorsON) {
			/****************************
			MOTOR MAP
				M1 O-------------O M2   ON EVEN MOTORS, STEPS MUST BE INVERTED
					|	 /\		|			i.e. FORWARD IS BACKWARD
					|	/  \	|
					|	 || 	|
					|	 ||		|
				M3 O-------------O M4
			*****************************/
			if (M1_counter == 0) {
				switch (M1_state) {
					case 0: // set 0011
						step (0x3 , 1);
						if (M1forward)
							M1_state = 1;
						else
							M1_state = 3;
						break;
					case 1: // set 1001
						step (0x9 , 1);
						if (M1forward)
							M1_state = 2;
						else
							M1_state = 0;
						break;
					case 2: // set 1100
						step (0xC , 1);
						if (M1forward)
							M1_state = 3;
						else
							M1_state = 1;
						break;
					case 3: // set 0110
					default:
						step (0x6 , 1);
						if (M1forward)
							M1_state = 0;
						else
							M1_state = 2;
						break;	
				}
				M1_counter = M1_stepPeriod;
				step_counter[0]--;
				if (directionNow == countingDirection)
					step_counter[1]--;
			}
			
			if (M2_counter == 0) {
				switch (M2_state) {
					case 0: // set 0011
						step (0x3 , 2);
						if (M2forward)
							M2_state = 1;
						else
							M2_state = 3;
						break;
					case 1: // set 0110
						step (0x6 , 2);
						if (M2forward)
							M2_state = 2;
						else
							M2_state = 0;
						break;
					case 2: // set 1100
						step (0xC , 2);
						if (M2forward)
							M2_state = 3;
						else
							M2_state = 1;
						break;
					case 3: // set 1001
					default:
						step (0x9 , 2);
						if (M2forward)
							M2_state = 0;
						else
							M2_state = 2;
						break;	
				}
				M2_counter = M2_stepPeriod;
			}

			if (M3_counter == 0) {
				switch (M3_state) {
					case 0: // set 0011
						step (0x3 , 3);
						if (M3forward)
							M3_state = 1;
						else
							M3_state = 3;
						break;
					case 1: // set 1001
						step (0x9 , 3);
						if (M3forward)
							M3_state = 2;
						else
							M3_state = 0;
						break;
					case 2: // set 1100
						step (0xC , 3);
						if (M3forward)
							M3_state = 3;
						else
							M3_state = 1;
						break;
					case 3: // set 0110
					default:
						step (0x6 , 3);
						if (M3forward)
							M3_state = 0;
						else
							M3_state = 2;
						break;	
				}
				M3_counter = M3_stepPeriod;
			}
			
			if (M4_counter == 0) {
				switch (M4_state) {
					case 0: // set 0011
						step (0x3 , 4);
						if (M4forward)
							M4_state = 1;
						else
							M4_state = 3;
						break;
					case 1: // set 0110
						step (0x6 , 4);
						if (M4forward)
							M4_state = 2;
						else
							M4_state = 0;
						break;
					case 2: // set 1100
						step (0xC , 4);
						if (M4forward)
							M4_state = 3;
						else
							M4_state = 1;
						break;
					case 3: // set 1001
					default:
						step (0x9 , 4);
						if (M4forward)
							M4_state = 0;
						else
							M4_state = 2;
						break;	
				}
				M4_counter = M4_stepPeriod;
			}
		} else {
			//motors off
			mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7);
			mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4);
			mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
					BIT_4 | BIT_5 | BIT_6 | BIT_7);
		}
/************************************************************/
		

/******* TEST CODE, toggles the servos (from 90 deg. to -90 deg.) every 1 s. ********/
/*		if (auxcounter == 0) {
			
			servo1_angle = 0;

			if (servo2_angle == 90)
				servo2_angle = -90;
			else
				servo2_angle = 90;

			auxcounter = 20000;		// toggle angle every 2 s.
		}
*/

		servo1_angle = 0;
		servo2_angle = -90;
	/*
		if (frontDistance > 13 && frontDistance < 17) {
			servo2_angle = 90;
		}
		else
			servo2_angle = -90;
	*/
/*******************************************************************/


/****************** SERVO CONTROL ******************/
		/*
			Changing the global servoX_angle at any point in the code will 
			move the servo to the desired angle.
		*/
		servo1_counter = (servo1_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
		if (servo1_period == 0) {
			mPORTASetBits(BIT_2);
			servo1_period = SERVOMAXPERIOD; 		/* 200 * 100us = 20000us period  */
		}

		servo2_counter = (servo2_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
		if (servo2_period == 0) {
			mPORTASetBits(BIT_3);
			servo2_period = SERVOMAXPERIOD; 		/* 200 * 100us = 20000us period  */
		}
/*****************************************************/
	
	} /* end of while(1)  */
		
	return 0;
}
Exemple #22
0
/**
 * Initialize an SD flash memory card.
 *
 * \param[in] sckRateID SPI clock rate selector. See setSckRate().
 * \param[in] chipSelectPin SD chip select pin number.
 *
 * \return The value one, true, is returned for success and
 * the value zero, false, is returned for failure.  The reason for failure
 * can be determined by calling errorCode() and errorData().
 */
uint8_t Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
  errorCode_ = inBlock_ = partialBlockRead_ = type_ = 0;

  // 16-bit init start time allows over a minute
  uint16_t t0 = (uint16_t)millis();
  uint32_t arg;

  SPI2CON = 0;

  DDPCONbits.JTAGEN = 0;

  AD1PCFG = 0xFFFF;

  chipSelectPin_ = chipSelectPin;

  pinMode(chipSelectPin_, OUTPUT);

  PORTSetPinsDigitalOut(prtSCK, bnSCK);
  PORTSetPinsDigitalOut(prtSDO, bnSDO);
  PORTSetPinsDigitalIn(prtSDI, bnSDI);
  
  // set pin modes
  chipSelectHigh();

  // must supply min of 74 clock cycles with CS high.
  for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);

  chipSelectLow();

  // command to go idle in SPI mode
  while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
    if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
      error(SD_CARD_ERROR_CMD0);
      goto fail;
    }
  }
  // check SD version
  if ((cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) {
    type(SD_CARD_TYPE_SD1);
  } else {
    // only need last byte of r7 response
    for (uint8_t i = 0; i < 4; i++) status_ = spiRec();
    if (status_ != 0XAA) {
      error(SD_CARD_ERROR_CMD8);
      goto fail;
    }
    type(SD_CARD_TYPE_SD2);
  }
  // initialize card and send host supports SDHC if SD2
  arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;

  while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {
    // check for timeout
    if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
      error(SD_CARD_ERROR_ACMD41);
      goto fail;
    }
  }
  // if SD2 read OCR register to check for SDHC card
  if (type() == SD_CARD_TYPE_SD2) {
    if (cardCommand(CMD58, 0)) {
      error(SD_CARD_ERROR_CMD58);
      goto fail;
    }
    if ((spiRec() & 0XC0) == 0XC0) type(SD_CARD_TYPE_SDHC);
    // discard rest of ocr - contains allowed voltage range
    for (uint8_t i = 0; i < 3; i++) spiRec();
  }
  chipSelectHigh();

#ifndef SOFTWARE_SPI
  return setSckRate(sckRateID);
#else  // SOFTWARE_SPI
  return true;
#endif  // SOFTWARE_SPI

 fail:
  chipSelectHigh();
  return false;
}
void hardwareInit(void)
{
        // Configure the device for maximum performance, but do not change the PBDIV clock divisor.
        // Given the options, this function will change the program Flash wait states,
        // RAM wait state and enable prefetch cache, but will not change the PBDIV.
        // The PBDIV value is already set via the pragma FPBDIV option above.
    SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

    PORTSetPinsAnalogIn(IOPORT_A, BIT_1 | BIT_0);
        // Could also use mPORTDSetPinsDigitalOut(BIT_6 | BIT_7);
    //PORTSetPinsDigitalOut(IOPORT_A, BIT_3 | BIT_2);
    PORTSetPinsDigitalOut(IOPORT_A, BIT_10 | BIT_9 | BIT_8 | BIT_7 | BIT_6 | BIT_5 | BIT_4 );

    PORTSetPinsAnalogIn(IOPORT_B, BIT_2 | BIT_1 | BIT_0);
    PORTSetPinsDigitalOut(IOPORT_B, BIT_15 | BIT_14 | BIT_13 | BIT_12 | BIT_11 | BIT_10 | BIT_9 | BIT_7 | BIT_4 | BIT_3);
    PORTSetPinsDigitalIn(IOPORT_B, BIT_8 | BIT_6 | BIT_5);

    PORTSetPinsDigitalOut(IOPORT_C, BIT_9 | BIT_7 | BIT_6 | BIT_3 | BIT_2 |BIT_1 | BIT_0);
    PORTSetPinsDigitalIn(IOPORT_C, BIT_8 | BIT_5 | BIT_4);

        // This is the waggle to set reprogrammable peripheral
        // Assume ints & DMA disa
    SYSKEY = 0xAA996655;
    SYSKEY = 0x556699AA;
    U1RXR = 0b0001;     // U2.15 RPB6 as RxD1 (PICO) input
    RPB7R = 0b0001;     // U2.16 RPB7 as TxD1 (POCI) output
    SDI1R = 0b0011;     // U2.22 RPB11 is SDI1
    RPB8R = 0b0011;     // U2.17 RPB8 is SDO1
    SYSKEY = 0x33333333;    // Junk relocks it

    OSCCONbits.SOSCEN = 1;
    OSCCONbits.SOSCRDY = 1;
        // Serial port on UART1
        // Note, Mode & Sta have atomic bit clr, set, & inv registers
    U1MODEbits.ON = 1;      // Ena UART1, per UEN, with UTXEN
    U1MODEbits.SIDL = 0;    // Continue oper in idle mode
    U1MODEbits.IREN = 0;    // Disa IrDA
    U1MODEbits.RTSMD = 1;   // U1RTS_n pin in simplex mode
    U1MODEbits.UEN = 0b00;  // U1CTS_n & U1RTS_n unused
    U1MODEbits.WAKE = 0;    // Disa wakeup
    U1MODEbits.LPBACK = 0;  // Disa loopback
    U1MODEbits.ABAUD = 0;   // Disa autobaud
    U1MODEbits.RXINV = 0;   // U1Rx 0 for idle high
    U1MODEbits.BRGH = 0;    // Std speed 16x, 1: high speed is 4x baud clk
    U1MODEbits.PDSEL = 0b00;    // 8 bit data, no parity
    U1MODEbits.STSEL = 0;   // 1 stop bit

    U1STAbits.ADM_EN = 0;   // Disa automatic address mode detect
    U1STAbits.UTXISEL = 0b01;   // Interrupt gen when all chars transmitted
    U1STAbits.UTXINV = 0;  // U1Tx idle is 1.
    U1STAbits.URXEN = 1;    // Ena U1Rx
    U1STAbits.UTXBRK = 0;   // Disa Break (Start bit, then 12 0's, Stop)
    U1STAbits.UTXEN = 1;    // Ena U1Tx
    U1STAbits.URXISEL = 0b01;   // Interrupt flag asserted while buffer is 1/2 or more full
    U1STAbits.ADDEN = 0;    // Disa address mode

    U1BRG = 162;            // 80 for 19200 baud = PBCLK / (16 x (BRG + 1)), PBCLK = 25 MHz @ div / 1, Jitter 0.47%
                            // 162 for 9600, 325 for 4800

    RS485_DE = 0;
    RS485_RE_n = 0;

    AD1CON1bits.FORM = 0b000;   // Integer 16-bit, 10 lsb's
    AD1CON1bits.SSRC = 0b111;   // Internal ctr ends sampling and starte conver, auto.
    AD1CON1bits.ASAM = 1;       // Sampling begins immediately after last conversion completes; SAMP bit is automatically set
    AD1CON1bits.SAMP = 1;       // Ena sampling

    AD1CON2bits.VCFG = 0b001;   // Vref+ has bandgap ref, use Vss
    AD1CON2bits.OFFCAL = 0;     // Disa offset cal mode
    AD1CON2bits.CSCNA = 0;      // Disa scan the inputs
    AD1CON2bits.BUFM = 0;       // Buffer is one 16-bit word
    AD1CON2bits.ALTS = 0;       // Always use sample A input mux settings

    AD1CON3bits.ADRC = 1;       // ADC clk from FRC
    AD1CON3bits.SAMC = 0b11111; // 31 x TAD autosample time
    AD1CON3bits.ADCS = 0xFF;    // 512 x TPB = TAD, TPB from PBCLK

        // These don't matter if we scan.
    AD1CHSbits.CH0NB = 0;       // Sample B Ch 0 neg input is Vrefl
    AD1CHSbits.CH0SB = 0b00000; // Select B: AN0
    AD1CHSbits.CH0NA = 0;       // Sample A Ch 0 neg input is Vrefl
    AD1CHSbits.CH0SA = 0b00000; // Select B: AN0

    AD1CON1bits.ON = 1;         // This must be last step.

//    SPI1CONbits.MSTEN = 1;      // Master mode.  Shd be first command.
//    SPI1CONbits.FRMEN = 0;      // Framed SPI disa
//    SPI1CONbits.MSSEN = 0;      // Slave select SPI support disa
//    SPI1CONbits.MCLKSEL = 0;    // Use PBCLK for BRG
//    SPI1CONbits.ENHBUF = 0;     // Enhanced buffer disa
//    SPI1CONbits.ON = 0;         // Turn it off for now
//    SPI1CONbits.SIDL = 0;       // Continue in Idle
//    SPI1CONbits.DISSDO = 0;     // Use SDOx
//    SPI1CONbits.MODE16 = 0;     // 8 bit transfer
//    SPI1CONbits.MODE32 = 0;     // 8 bit transfer
//    SPI1CONbits.SMP = 0;        // Sample data in middle of phase
//    SPI1CONbits.CKE = 0;        // Serial output data changes on transition from idle clock state to active clock state
//    SPI1CONbits.SSEN = 0;       // Do not use /SS1 pin
//    SPI1CONbits.CKP = 0;        // Idle clock is low
//
//    SPI1CONbits.DISSDI = 0;     // Use SDI1 pin
//
//    SPI1CON2bits.AUDEN = 0;     // Audio protocol disa
//    SPI1BRG = 0x100;

   // spiIoxConfig();

    LED_GREEN = 0;
}
Exemple #24
0
int main(void)
    {
    PORTSetPinsDigitalOut(IOPORT_F,BIT_3);
    PORTSetPinsDigitalOut(IOPORT_C,BIT_14); 
    PORTSetPinsDigitalOut(IOPORT_D,BIT_11);
    PORTSetPinsDigitalIn(IOPORT_B,BIT_2|BIT_3|BIT_4|BIT_5);
while (1)
{

    if ((PORTBbits.RB2)>0)  
    {
        PORTSetBits(IOPORT_C, BIT_14);
        PORTClearBits(IOPORT_D, BIT_11);
        PORTClearBits(IOPORT_F,BIT_3);
    }
    else {
        PORTClearBits(IOPORT_C, BIT_14);
        PORTClearBits(IOPORT_D, BIT_11);
        PORTClearBits(IOPORT_F,BIT_3);
    }

    if ((PORTBbits.RB3)>0)  
    {
        PORTClearBits(IOPORT_C, BIT_14);
        PORTSetBits(IOPORT_D, BIT_11);
        PORTClearBits(IOPORT_F,BIT_3);
    }
    else {
        PORTClearBits(IOPORT_C, BIT_14);
        PORTClearBits(IOPORT_D, BIT_11);
        PORTClearBits(IOPORT_F,BIT_3);
    }

    if ((PORTBbits.RB4)>0)  
    {
        PORTClearBits(IOPORT_C, BIT_14);
        PORTClearBits(IOPORT_D, BIT_11);
        PORTSetBits(IOPORT_F,BIT_3);
    }
    else {
        PORTClearBits(IOPORT_C, BIT_14);
        PORTClearBits(IOPORT_D, BIT_11);
        PORTClearBits(IOPORT_F,BIT_3);
    }

    if ((PORTBbits.RB5)>0)  
    {
        PORTSetBits(IOPORT_C, BIT_14);
        PORTSetBits(IOPORT_D, BIT_11);
        PORTSetBits(IOPORT_F,BIT_3);
    }
    else {
        PORTClearBits(IOPORT_C, BIT_14);
        PORTClearBits(IOPORT_D, BIT_11);
        PORTClearBits(IOPORT_F,BIT_3);
    }

    }    
    return (0);

}
Exemple #25
0
void I2C1update(void) {
  if (I2C1STAT & 0x0400) {
    // bus collision
    i2c1Mode = I2C1_MODE_ERROR;
    i2c1BusState = I2C1_BUS_ERROR;
    I2CEnable(I2C1, FALSE);
  }
  
  if (i2c1Delay) {
    i2c1Delay--;
    return;
  }
  
  if (i2c1Mode == I2C1_MODE_IDLE) {
    if (i2c1QueueRd != i2c1QueueWr) {
      // show that I2C1 is busy
      i2c1Mode = I2C1_MODE_WRITE;
      // clear the write and read indices
      i2c1Queue[i2c1QueueRd].wi = 0;
      i2c1Queue[i2c1QueueRd].ri = 0;
      // start I2C1 transfer
      i2c1BusState = I2C1_BUS_WR_DATA;
      I2C1CONSET = _I2CCON_SEN_MASK;
    }
  } // I2C1_IDLE
  else if (i2c1Mode == I2C1_MODE_WRITE_COMPLETE) {
    I2C1process();
    i2c1QueueRd++;
    if (i2c1QueueRd >= I2C1_QUEUE_SIZE) {
      i2c1QueueRd = 0;
    }
    i2c1Mode = I2C1_MODE_IDLE;
  } // I2C1_WRITE_COMPLETE
  else if (i2c1Mode == I2C1_MODE_READ_COMPLETE) {
    I2C1process();
    i2c1QueueRd++;
    if (i2c1QueueRd >= I2C1_QUEUE_SIZE) {
      i2c1QueueRd = 0;
    }
    i2c1Mode = I2C1_MODE_IDLE;
  } // I2C1_READ_COMPLETE
  else if (i2c1Mode == I2C1_MODE_ERROR) {
    // usually caused is SDA is low before start
    if (!(PORTA & PA_SCL1)) {
      // is clock is low, raise it
      PORTSetPinsDigitalOut(IOPORT_A, PA_SCL1);
      PORTSetBits(IOPORT_A, PA_SCL1);
    }
    else {
      if (!(PORTA & PA_SDA1)) {
        // if SDA is still low, try another clock pulse
        PORTSetPinsDigitalOut(IOPORT_A, PA_SCL1);
        PORTClearBits(IOPORT_A, PA_SCL1);
      }
      else {
        // SDA is now high, try clearing the error
        PORTSetPinsDigitalOut(IOPORT_A, PA_SDA1);
        PORTClearBits(IOPORT_A, PA_SDA1);
        i2c1Mode = I2C1_MODE_ERR_START;
      }
    }
  }
  else if (i2c1Mode == I2C1_MODE_ERR_START) {
    PORTSetBits(IOPORT_A, PA_SDA1);
    i2c1Mode = I2C1_MODE_ERR_STOP;
  }  
  else if (i2c1Mode == I2C1_MODE_ERR_STOP) {
    I2C1STAT &= ~0x400;
    IFS0 &= ~0x20000000;
    PORTSetPinsDigitalIn(IOPORT_A, PA_SCL1 | PA_SDA1);
    I2CEnable(I2C1, TRUE);
    i2c1Mode = I2C1_MODE_IDLE;
  }  
} // I2C1update()
Exemple #26
0
void initButtons() {
  //BTN1 is connected to I/O Port G, bits
  PORTSetPinsDigitalIn(BTN1_PORT, BTN1_BIT);
}
Exemple #27
0
int main(void)
{
    SpiOpenFlags spiFlags;

    AudioStereo test_sine[]={         0	    ,	0	    ,
                                946234      ,   946234      ,
                                1877546     ,   1877546     ,
                                2779247     ,   2779247     ,
                                3637119     ,   3637119     ,
                                4437630     ,   4437630     ,
                                5168158     ,   5168158     ,
                                5817180     ,   5817180     ,
                                6374462     ,   6374462     ,
                                6831216     ,   6831216     ,
                                7180237     ,   7180237     ,
                                7416020     ,   7416020     ,
                                7534850     ,   7534850     ,
                                7534850     ,   7534850     ,
                                7416020     ,   7416020     ,
                                7180237     ,   7180237     ,
                                6831216     ,   6831216     ,
                                6374462     ,   6374462     ,
                                5817180     ,   5817180     ,
                                5168158     ,   5168158     ,
                                4437630     ,   4437630     ,
                                3637119     ,   3637119     ,
                                2779247     ,   2779247     ,
                                1877546     ,   1877546     ,
                                946234      ,   946234      ,
                                0           ,   0           ,
                                -946234     ,   -946234     ,
                                -1877546    ,   -1877546    ,
                                -2779247    ,   -2779247    ,
                                -3637119    ,   -3637119    ,
                                -4437630    ,   -4437630    ,
                                -5168158    ,   -5168158    ,
                                -5817180    ,   -5817180    ,
                                -6374462    ,   -6374462    ,
                                -6831216    ,   -6831216    ,
                                -7180237    ,   -7180237    ,
                                -7416020    ,   -7416020    ,
                                -7534850    ,   -7534850    ,
                                -7534850    ,   -7534850    ,
                                -7416020    ,   -7416020    ,
                                -7180237    ,   -7180237    ,
                                -6831216    ,   -6831216    ,
                                -6374462    ,   -6374462    ,
                                -5817180    ,   -5817180    ,
                                -5168158    ,   -5168158    ,
                                -4437630    ,   -4437630    ,
                                -3637119    ,   -3637119    ,
                                -2779247    ,   -2779247    ,
                        };

    // Initialize audio codec.
    WM8960CodecOpen();
    WM8960CodecConfigVolume(0,0);
    WM8960CodecConfigSampleRate(SAMPLE_RATE_16000_HZ);
    WM8960CodecConfigVolume(volADC,volDAC);

    //Congigure MIPS, Prefetch Cache module.
    SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
    INTEnableSystemMultiVectoredInt();

    //Test tone vector sampled at 48kHz.
    txBuffer = test_sine;

    //Configure the direction of used pins and
    //configure as digital pins.

    PORTSetPinsDigitalIn(IOPORT_G, BIT_7);
    PORTSetPinsDigitalOut(IOPORT_G, BIT_6);
    PORTSetPinsDigitalOut(IOPORT_G, BIT_8);
    PORTSetPinsDigitalOut(IOPORT_G, BIT_9);
    

//    //Configure Reference Clock Output to 12.288MHz.
//    mOSCREFOTRIMSet(REFTRIM);
//    OSCREFConfig(OSC_REFOCON_USBPLL, //USB-PLL clock output used as REFCLKO source
//            OSC_REFOCON_OE | OSC_REFOCON_ON, //Enable and turn on the REFCLKO
//            RODIV);

    //Configure SPI in I2S mode with 24-bit stereo audio.
     spiFlags= SPI_OPEN_MSTEN |      //Master mode enable
                SPI_OPEN_SSEN |      //Enable slave select function
                SPI_OPEN_CKP_HIGH |  //Clock polarity Idle High Actie Low
                SPI_OPEN_MODE32 |    //Data mode: 32b
                SPI_OPEN_FRMEN |     // Enable Framed SPI
                SPI_OPEN_FSP_IN |    // Frame Sync Pulse is input
                SPI_OPEN_FSP_HIGH;   //Frame Sync Pulse is active high

    //Configure and turn on the SPI1 module.
    SpiChnEnable(WM8960DRV_SPI_MODULE, FALSE);
    SpiChnConfigure(WM8960DRV_SPI_MODULE, spiFlags);
    SpiChnSetBitRate(WM8960DRV_SPI_MODULE, GetPeripheralClock(), 1024000);
    SpiChnEnable(WM8960DRV_SPI_MODULE, TRUE);
    
    //Enable SPI2 interrupt.
    INTSetVectorPriority(INT_SPI_2_VECTOR, INT_PRIORITY_LEVEL_4);
    INTSetVectorSubPriority(INT_SPI_2_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
    INTEnable(INT_SPI2, INT_ENABLED);

    SpiChnPutC(SPI_CHANNEL2, 0); //Dummy write to start the SPI
    //while (1);
    return 0;

}
int main(void)
{
     UINT32  menu_choice;
    
    menu_choice = 'y';
        OpenUart(UART1,BAUDERATE);
        OpenUart(UART2,BAUDERATE);
//        OpenUart(UART3,BAUDERATE);
//        OpenUart(UART4,BAUDERATE);
        OpenUart(UART5,BAUDERATE);
        OpenUart(UART6,BAUDERATE);

//IMPORTANT POUR ACTIVER LE RX UART5. INFO TROUVEE SUR LE NET
        PORTSetPinsDigitalIn(IOPORT_B,BIT_8);  

    while (1)
    {

        if (menu_choice=='n')
        {

            SendDataBuffer(UARTTEST,goodbye);
            
            return(0);
        }
        if (menu_choice=='y')
        {

        menu_choice = 'n';
        

        SendDataBuffer(UART1,myHelloStr1);
        SendDataBuffer(UART1,mainMenu);        

        SendDataBuffer(UART2,myHelloStr2);
        SendDataBuffer(UART2,mainMenu);        


//        SendDataBuffer(UART3,myHelloStr3);
//        SendDataBuffer(UART3,mainMenu);


//        SendDataBuffer(UART4,myHelloStr4);
//        SendDataBuffer(UART4,mainMenu);


        SendDataBuffer(UART5,myHelloStr5);
        SendDataBuffer(UART5,mainMenu);


        SendDataBuffer(UART6,myHelloStr6);
        SendDataBuffer(UART6,mainMenu);





        menu_choice = GetMenuChoice();
        }
    }
    return (0);
}
Exemple #29
0
		virtual void setup_digital_in()	{PORTSetPinsDigitalIn(ltr(), num());}
Exemple #30
0
int main(void) {
    int a = 0;
    unsigned char data_mix = 0, data_mix_old = 0;
    SDEV_TYPE1 S1 = {0}, *S1_p = &S1;
    char comm_buffer[MAXSTRLEN];
    int update_rate = 4;
    int eresult = 0, records = 0, file_errors = 0;


    // Init remote device data
    S1.obits.out_byte = 0xff;

    // Enable multi-vectored interrupts
    INTEnableSystemMultiVectoredInt();
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //STEP 1. Configure cache, wait states and peripheral bus clock
    // Configure the device for maximum performance but do not change the PBDIV
    // Given the options, this function will change the flash wait states, RAM
    // wait state and enable prefetch cache but will not change the PBDIV.
    // The PBDIV value is already set via the pragma FPBDIV option above..
    SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
    srand(ReadCoreTimer()); // Seed the pseudo random generator

    // SCLK1 pin 25 - SD pin 5
    PORTSetPinsDigitalOut(IOPORT_B, BIT_14); // Clock output
    // SCLK2 pin 26 - PIC pin 18
    PORTSetPinsDigitalOut(IOPORT_B, BIT_15); // Clock output

    PPSInput(2, SDI1, RPB8); //Assign SDI1 to pin 17 - SD pin 7
    PORTSetPinsDigitalIn(IOPORT_B, BIT_8); // Input for SDI1
    PPSInput(3, SDI2, RPB13); //Assign SDI2 to pin 24
    PORTSetPinsDigitalIn(IOPORT_B, BIT_13); // Input for SDI2
    PPSOutput(2, RPB11, SDO1); // Set 22 pin as output for SDO1 - SD pin 2
    PPSOutput(2, RPB5, SDO2); // Set 14 pin as output for SDO2
    PORTSetPinsDigitalOut(IOPORT_B, BIT_2); // CS line pin 6 - SD pin 1
    mPORTBSetBits(BIT_2); // deselect SDCARD
    PORTSetPinsDigitalOut(IOPORT_B, BIT_3); // select pin enable for SPI slaves bit 2 to 74hc138
    mPORTBSetBits(BIT_3); // deselect Slave1 bit2
    PORTSetPinsDigitalOut(IOPORT_A, BIT_3); // spare digital output
    mPORTASetBits(BIT_3); // 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Diag Led pins
    PORTSetPinsDigitalOut(IOPORT_A, BIT_0 | BIT_1); // bi-color LED
    PORTSetPinsDigitalOut(IOPORT_B, BIT_0 | BIT_1); // programming inputs /device select outputs address for SPI slaves bits [0..1] 74hc138

    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // STEP 3. initialize the port pin states = outputs low
    mPORTASetBits(BIT_0 | BIT_1);
    mPORTBClearBits(BIT_0 | BIT_1);
    RTC_Init(); // Start Timer5 for background processes and 1ms soft timers
    Blink_Init(); // Start Timer4 background blink driver
    blink_led(RED_LED, LED_ON, FALSE);

    init_spi_ports();
    ps_select(0); // select the pic18 slave1 on spi port 2, select 0
    // send some text to clean the buffers
    SpiStringWrite("\r\n                                                                              \n\r");

    eresult = f_mount(&FatFs, "0:", 1);
    if (eresult) {
        sprintf(comm_buffer, "\r\n Mount error %i ", eresult);
        SpiStringWrite(comm_buffer); /* Register work area to the logical drive 1 */
        blink_led(GREEN_LED, LED_OFF, FALSE);
        blink_led(RED_LED, LED_ON, FALSE);
    } else {
        Show_MMC_Info();
        blink_led(RED_LED, LED_OFF, FALSE);
        blink_led(GREEN_LED, LED_ON, TRUE);
    }

    /* Create destination file on the drive 1 */
    eresult = f_open(&File[0], "0:logfile.txt", FA_CREATE_ALWAYS | FA_WRITE);

    while (1) { // loop and move data
        V.Timer1 = update_rate;
        while (V.Timer1);

        /* loop back testing */
        data_mix_old = data_mix; // save the old data
        data_mix = rand(); // make new data
        if (S1_p->char_ready || !S1_p->ibits.in_bits.eject) {
            S1_p->rec_data = S1_p->rec_tmp;

            //			led1_green();
        } else {

            //			led1_off();
        }

        S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
        if (S1_p->ibits.in_bits.card_detect) {
            S1_p->obits.out_bits.eject_led = OFF;
            SD_NOTRDY = STA_NOINIT;
        } else {
            S1_p->obits.out_bits.eject_led = ~S1_p->obits.out_bits.eject_led;
        }
        for (S1_p->chan_no = 0; S1_p->chan_no < 4; S1_p->chan_no++) {
            S1_p->adc_data[S1_p->chan_no] = SpiADCRead(S1_p->chan_no);
        }
        a = 0;

        if (((records % 100)) == 0 && !eresult) {
            if (S1_p->char_ready) {
                snprintf(comm_buffer, 64, "\r\n %x , %i, %x , %i , %i , %i , %i ", S1_p->rec_data, records, S1_p->ibits.in_byte, S1_p->adc_data[0], S1_p->adc_data[1], S1_p->adc_data[2], S1_p->adc_data[3]);
            } else {
                snprintf(comm_buffer, 64, "\r\n %x , %i , %i , %i , %i , %i ", S1_p->ibits.in_byte, records, S1_p->adc_data[0], S1_p->adc_data[1], S1_p->adc_data[2], S1_p->adc_data[3]);
            }
            S1_p->rec_tmp = SpiStringWrite(comm_buffer);
        }
        if (SpiSerialReadOk() || !S1_p->ibits.in_bits.eject) {
            S1_p->char_ready = TRUE;
            if ((S1_p->rec_tmp == 'f') || !S1_p->ibits.in_bits.eject) {
                if (S1_p->ibits.in_bits.card_detect) { // no disk
                    blink_led(0, LED_ON, FALSE);
                    S1_p->obits.out_bits.eject_led = OFF;
                    S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
                    SpiStringWrite("\r\n Insert Disk! y/n ");
                    while (!SpiSerialReadReady() && S1_p->ibits.in_bits.card_detect) S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
                    V.Timer1 = update_rate;
                    while (V.Timer1);
                    if (!S1_p->ibits.in_bits.card_detect) {
                        SpiStringWrite("/\r\n Mounting Disk ");
                        S1_p->obits.out_bits.eject_led = ON;
                        S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
                        eresult = f_mount(&FatFs, "0:", 1);
                        if (eresult) {
                            sprintf(comm_buffer, "\r\n Mount error %i ", eresult);
                            SpiStringWrite(comm_buffer); /* Register work area to the logical drive 1 */
                            blink_led(GREEN_LED, LED_OFF, FALSE);
                            blink_led(RED_LED, LED_ON, FALSE);
                        } else {
                            Show_MMC_Info();
                            blink_led(RED_LED, LED_OFF, FALSE);
                            blink_led(GREEN_LED, LED_ON, TRUE);
                        }
                        /* Create destination file on the drive 1 */
                        eresult = f_open(&File[0], "0:logfile.txt", FA_CREATE_ALWAYS | FA_WRITE);
                        SpiStringWrite("\r\n Mount Complete ");

                        S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
                        if (S1_p->ibits.in_bits.card_detect) SD_NOTRDY = STA_NOINIT;
                    }
                } else { // Eject current disk
                    blink_led(0, LED_ON, FALSE);
                    S1_p->obits.out_bits.eject_led = OFF;
                    S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
                    f_close(&File[0]);
                    SpiStringWrite("\r\n Eject Disk? y/n ");
                    while (!SpiSerialReadReady() && !S1_p->ibits.in_bits.card_detect) S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
                    V.Timer1 = update_rate;
                    while (V.Timer1);
                    if (S1_p->ibits.in_bits.card_detect) {
                        SpiStringWrite("\r\n Ejecting Disk ");
                        S1_p->obits.out_bits.eject_led = ON;
                        S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);

                        if (f_mount(0, "0:", 0)) SpiStringWrite("\r\n UMount error "); /* Unregister work area from the logical drive 1 */
                        SpiStringWrite("\r\n Ejection Complete ");
                        eresult = 1;

                        S1_p->ibits.in_byte = SpiPortWrite(S1_p->obits.out_byte);
                        if (S1_p->ibits.in_bits.card_detect) SD_NOTRDY = STA_NOINIT;
                    }
                }
            }
        } else {
            S1_p->char_ready = FALSE;
        }

        V.Timer1 = update_rate;
        while (V.Timer1);

        // only GREEN if the data sent and received match or eject button is pressed
        if (S1_p->ibits.in_bits.eject && (S1_p->rec_data != data_mix_old)) {
            //            blink_led(0, LED_ON, TRUE);
        } else {
            //            blink_led(0, LED_ON, FALSE);
        }

        if (!eresult) {
            a = f_puts(comm_buffer, &File[0]);
            blink_led(RED_LED, LED_OFF, FALSE);
            blink_led(GREEN_LED, LED_ON, TRUE);
            records++;
        } else {
            file_errors++;
            if ((file_errors % 100) == 0) {
                SpiStringWrite("\r\n not logged ");
                blink_led(GREEN_LED, LED_OFF, FALSE);
                blink_led(RED_LED, LED_ON, FALSE);
            }
        }

        if (a == (-1)) {
            if ((file_errors % 100) == 0) {
                sprintf(comm_buffer, "\r\n File Write error %i ", a);
                SpiStringWrite(comm_buffer);
                blink_led(GREEN_LED, LED_OFF, FALSE);
                blink_led(RED_LED, LED_ON, FALSE);
            }
        }
        f_sync(&File[0]);
    }
}