//************************************************************************************ //** //** Source name: C:\Users\Martin\Downloads\Components test_v6.fcfx //** Title: //** Description: //** Device: PIC.16F.16F1939 //** //** Generated by: Flowcode v6.0.0.57 //** Date: Monday, August 19, 2013 10:34:06 //** Users: 0 //** //** ***UNREGISTERED*** //** //** //** NOT FOR COMMERCIAL USE //** //** http://www.matrixmultimedia.com //** //************************************************************************************ #define MX_PIC #define MX_CAL_PIC #define MX_CLK_SPEED 19660800 #ifdef _BOOSTC #pragma DATA 0x8007, 0xFE2 #endif #ifdef HI_TECH_C __CONFIG(0xFE2); #endif #ifdef _BOOSTC #pragma DATA 0x8008, 0x1633 #endif #ifdef HI_TECH_C __CONFIG(0x1633); #endif /*========================================================================*\ Use :Include the type definitions \*========================================================================*/ #include "C:\Program Files (x86)\Flowcode 6 Beta\CAL\internals.c" MX_UINT8 FCLV_LOOP1; MX_UINT8 FCLV_LOOP2; MX_UINT8 FCLV_LOOP3; MX_UINT8 FCLV_LOOP4; /*========================================================================*\ Use :panel :Variable declarations :Macro function declarations \*========================================================================*/ #define FCVsz_STRING2 10 #define FCVsz_BYTEARRAY 50 #define FCVsz_STRINGTEST 10 #define FCV_FALSE (0) #define FCV_TRUE (1) MX_GLOBAL MX_UINT16 FCV_UNIT; MX_GLOBAL MX_SINT16 FCV_INTVAR; MX_GLOBAL MX_UINT8 FCV_TEST1; MX_GLOBAL MX_CHAR FCV_STRING2[FCVsz_STRING2] = ("testing"); MX_GLOBAL MX_SINT32 FCV_LONGVAR; MX_GLOBAL MX_UINT8 FCV_BYTEARRAY[FCVsz_BYTEARRAY]; MX_GLOBAL MX_FLOAT FCV_FLOATVAR; MX_GLOBAL MX_CHAR FCV_STRINGTEST[FCVsz_STRINGTEST] = ("test as well"); MX_GLOBAL MX_UINT32 FCV_ULONGVAR; /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :v5__pwm2 :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_PWM_REF4 #define MX_PWM_PRESCALE4 (1) #define MX_PWM_PIN_4 (2) #define MX_PWM_PORT_4 portc #define MX_PWM_PERIOD 255 #define MX_PWM_TRIS_4 trisc #define MX_PWM_CHANNEL_4 (1) /*=----------------------------------------------------------------------=*\ Use :v5__pwm2 :Supplementary defines \*=----------------------------------------------------------------------=*/ #define MX_PWM void FC_CAL_PWM_ChangePeriod_4(MX_UINT8 FCL_PERIOD, MX_UINT16 FCL_PRESCALER); void FC_CAL_PWM_Disable_4(); void FC_CAL_PWM_SetDuty8Bit_4(MX_UINT8 FCL_DUTY); void FC_CAL_PWM_Enable_4(); void FC_CAL_PWM_SetDuty10Bit_4(MX_UINT16 FCL_DUTY); /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :v5__pwm1 :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_PWM_REF3 #define MX_PWM_PRESCALE3 (1) #define MX_PWM_PIN_3 (0) #define MX_PWM_PORT_3 porte #define MX_PWM_PERIOD 255 #define MX_PWM_TRIS_3 trise #define MX_PWM_CHANNEL_3 (3) /*=----------------------------------------------------------------------=*\ Use :v5__pwm1 :Supplementary defines \*=----------------------------------------------------------------------=*/ #define MX_PWM void FC_CAL_PWM_ChangePeriod_3(MX_UINT8 FCL_PERIOD, MX_UINT16 FCL_PRESCALER); void FC_CAL_PWM_Disable_3(); void FC_CAL_PWM_SetDuty8Bit_3(MX_UINT8 FCL_DUTY); void FC_CAL_PWM_Enable_3(); void FC_CAL_PWM_SetDuty10Bit_3(MX_UINT16 FCL_DUTY); /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :v5__pwm0 :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_PWM_REF2 #define MX_PWM_PRESCALE2 (1) #define MX_PWM_PIN_2 (1) #define MX_PWM_PORT_2 portc #define MX_PWM_PERIOD 255 #define MX_PWM_TRIS_2 trisc #define MX_PWM_CHANNEL_2 (2) /*=----------------------------------------------------------------------=*\ Use :v5__pwm0 :Supplementary defines \*=----------------------------------------------------------------------=*/ #define MX_PWM void FC_CAL_PWM_ChangePeriod_2(MX_UINT8 FCL_PERIOD, MX_UINT16 FCL_PRESCALER); void FC_CAL_PWM_Disable_2(); void FC_CAL_PWM_SetDuty8Bit_2(MX_UINT8 FCL_DUTY); void FC_CAL_PWM_Enable_2(); void FC_CAL_PWM_SetDuty10Bit_2(MX_UINT16 FCL_DUTY); /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :cal_adc :Variable declarations :Macro function declarations \*========================================================================*/ #define ADC_1_MX_ADC_ACTIME 0 #define MX_ADC_REF #define ADC_1_MX_ADC_VREFVOL 500 #define MX_ADC_CHANNEL_1 #define MX_ADC_TYPE_18 #define ADC_1_MX_ADC_VREFOP 0 #define ADC_1_MX_ADC_CONVSP 0 #define MX_ADC_BITS_10 #define ADC_1_MX_ADC_CHANNEL 1 #define FCV_0125d_cal_adc__FALSE (0) #define FCV_0125d_cal_adc__TRUE (1) void FC_CAL_ADC_Disable(); void FC_CAL_ADC_Enable(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_CONV_SPEED, MX_UINT8 FCL_VREF, MX_UINT8 FCL_T_CHARGE); MX_UINT16 FC_CAL_ADC_Sample(MX_UINT8 FCL_SAMPLE_MODE); /*========================================================================*\ Use :adc_base :Variable declarations :Macro function declarations \*========================================================================*/ MX_UINT16 FCD_0123d_adc_base__RawSampleInt(); MX_UINT8 FCD_0123d_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS); void FCD_0123d_adc_base__GetString(MX_CHAR* FCR_RETVAL, MX_UINT16 FCRsz_RETVAL); MX_SINT16 FCD_0123d_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS); MX_FLOAT FCD_0123d_adc_base__GetVoltage(); void FCD_0123d_adc_base__RawEnable(); MX_UINT8 FCD_0123d_adc_base__RawSampleByte(); MX_UINT16 FCD_0123d_adc_base__GetInt(); void FCD_0123d_adc_base__RawDisable(); MX_UINT8 FCD_0123d_adc_base__GetByte(); /*========================================================================*\ Use :v5__adc0 :Variable declarations :Macro function declarations \*========================================================================*/ #define FCD_0fb1_v5__adc0__RawSampleInt FCD_0123d_adc_base__RawSampleInt #define FCD_0fb1_v5__adc0__RawAverageByte FCD_0123d_adc_base__RawAverageByte #define FCD_0fb1_v5__adc0__GetString FCD_0123d_adc_base__GetString #define FCD_0fb1_v5__adc0__RawAverageInt FCD_0123d_adc_base__RawAverageInt #define FCD_0fb1_v5__adc0__GetVoltage FCD_0123d_adc_base__GetVoltage #define FCD_0fb1_v5__adc0__RawEnable FCD_0123d_adc_base__RawEnable #define FCD_0fb1_v5__adc0__RawSampleByte FCD_0123d_adc_base__RawSampleByte #define FCD_0fb1_v5__adc0__GetInt FCD_0123d_adc_base__GetInt #define FCD_0fb1_v5__adc0__RawDisable FCD_0123d_adc_base__RawDisable #define FCD_0fb1_v5__adc0__GetByte FCD_0123d_adc_base__GetByte /*========================================================================*\ Use :lut :Variable declarations :Macro function declarations \*========================================================================*/ #define FCVsz_01225_lut__FLOATFIXEDLIST 1 #define FCVsz_01225_lut__INTLIST 8 #define FCVsz_01225_lut__FLOATLIST 1 #define FCVsz_01225_lut__INTFIXEDLIST 1 #define FCD_01225_lut__INTLIST(ix) FCD_01225_lut__INTLIST_LUT[ix] ROMARRAY_(MX_UINT8) FCD_01225_lut__INTLIST_LUT ROMARRAY_E = { // Property added elements // Dynamically added elements 9, 1, 5, 4, 6, 2, 10, 8 }; /*========================================================================*\ Use :stepper_base :Variable declarations :Macro function declarations \*========================================================================*/ MX_GLOBAL MX_UINT8 FCV_01203_stepper_base__ENABLED = (0x0); MX_GLOBAL MX_UINT8 FCV_01203_stepper_base__STEP_PHASE = (0x0); MX_GLOBAL MX_UINT32 FCV_01203_stepper_base__TARGET_START_POS; MX_GLOBAL MX_FLOAT FCV_01203_stepper_base__TOTAL_Z = (0.0); MX_GLOBAL MX_FLOAT FCV_01203_stepper_base__TOTAL_Y = (0.0); MX_GLOBAL MX_FLOAT FCV_01203_stepper_base__TOTAL_X = (0.0); MX_GLOBAL MX_UINT32 FCV_01203_stepper_base__TARGET_HANDLE = (0x0); MX_GLOBAL MX_FLOAT FCV_01203_stepper_base__TOTAL_ANGLE; MX_GLOBAL MX_UINT8 FCV_01203_stepper_base__DUMMY; MX_GLOBAL MX_UINT8 FCV_01203_stepper_base__ROLLOVER = 8; MX_GLOBAL MX_UINT32 FCV_01203_stepper_base__MOVING_START_POS; void FCD_01203_stepper_base__IncrementStep(); void FCD_01203_stepper_base__DecrementStep(); void FCD_01203_stepper_base__EnableMotor(); void FCD_01203_stepper_base__Output_Step(MX_UINT8 FCL_PATTERN); void FCD_01203_stepper_base__DisableMotor(); /*========================================================================*\ Use :v5__stepper0 :Variable declarations :Macro function declarations \*========================================================================*/ #define FCD_0fb1_v5__stepper0__IncrementStep FCD_01203_stepper_base__IncrementStep #define FCD_0fb1_v5__stepper0__DecrementStep FCD_01203_stepper_base__DecrementStep #define FCD_0fb1_v5__stepper0__EnableMotor FCD_01203_stepper_base__EnableMotor #define FCD_0fb1_v5__stepper0__DisableMotor FCD_01203_stepper_base__DisableMotor /*========================================================================*\ Use :cal_eeprom :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_EEPROM_REF #define MX_EE_SIZE 256 #define MX_EE_TYPE3 /*=----------------------------------------------------------------------=*\ Use :cal_eeprom :Supplementary defines \*=----------------------------------------------------------------------=*/ #define MX_EE MX_UINT16 FC_CAL_EE_Read(MX_UINT16 FCL_ADDRESS); void FC_CAL_EE_Write(MX_UINT16 FCL_ADDRESS, MX_UINT16 FCL_DATA); /*========================================================================*\ Use :v5__eeprom0 :Variable declarations :Macro function declarations \*========================================================================*/ MX_UINT16 FCD_0fb1_v5__eeprom0__Read(MX_UINT16 FCL_ADDRESS); void FCD_0fb1_v5__eeprom0__Write(MX_UINT16 FCL_ADDRESS, MX_UINT16 FCL_VALUE); /*========================================================================*\ Use :v5__servo0 :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_SERVO_CCPR1H 48 #define MX_SERVO_CCPR1L 0 /*=----------------------------------------------------------------------=*\ Use :v5__servo0 :Supplementary defines \*=----------------------------------------------------------------------=*/ #ifdef MX_CAL_PIC #define MX_SERVO_T1CON 0x01 #define MX_SERVO_CCP1CON 0x0b #define MX_SERVO_CCP2CON 0x0a #define MX_SERVO_REG_CCPR1H ccpr1h #define MX_SERVO_REG_CCPR1L ccpr1l #define MX_SERVO_REG_CCPR2H ccpr2h #define MX_SERVO_REG_CCPR2L ccpr2l #define MX_SERVO_REG_T1CON t1con #define MX_SERVO_REG_CCP1CON ccp1con #define MX_SERVO_REG_CCP2CON ccp2con #define MX_SERVO_REG_CCP1EN pie1 #define MX_SERVO_REG_CCP2EN pie2 #define MX_SERVO_FLAG_CCP1EN CCP1IE #define MX_SERVO_FLAG_CCP2EN CCP2IE #define MX_SERVO_REG_CCP1F pir1 #define MX_SERVO_REG_CCP2F pir2 #define MX_SERVO_FLAG_CCP1F CCP1IF #define MX_SERVO_FLAG_CCP2F CCP2IF #define MX_SERVO_REG_INT intcon #define MX_SERVO_FLAG_GLOB GIE #define MX_SERVO_FLAG_PERIPH PEIE #define MX_CCP1_INT_START if (ts_bit(MX_SERVO_REG_CCP1F, MX_SERVO_FLAG_CCP1F) && ts_bit(MX_SERVO_REG_CCP1EN, MX_SERVO_FLAG_CCP1EN)) #define MX_CCP2_INT_START if (ts_bit(MX_SERVO_REG_CCP2F, MX_SERVO_FLAG_CCP2F) && ts_bit(MX_SERVO_REG_CCP2EN, MX_SERVO_FLAG_CCP2EN)) #endif #ifdef MX_CAL_PIC16BIT #define MX_SERVO_REG_CCP1F IFS0bits #define MX_SERVO_FLAG_CCP1F T3IF #define MX_SERVO_REG_CCP2F IFS0bits #define MX_SERVO_FLAG_CCP2F T2IF #define MX_CCP1_INT_START void _ISR _T3Interrupt(void) #define MX_CCP2_INT_START void _ISR _T2Interrupt(void) #endif #ifdef MX_CAL_AVR MX_UINT8 mx_servo_dummy; #ifdef MX_XMEGA #define OCR1AL TCC1.CCA #define OCR1BL TCC1.CCB #define TCCR1A TCC1.CTRLA #define TCCR1B TCC1.CTRLB #define TIMSK1 TCC1.INTCTRLB #define TIFR1 TCC1.INTFLAGS #define OCF1A 4 #define OCF1B 5 #define OCIE1A 0 #define OCIE1B 2 #else #ifndef TIMSK1 #ifdef TIMSK #define TIMSK1 TIMSK #endif #endif #ifndef TIFR1 #ifdef TIFR #define TIFR1 TIFR #endif #endif #ifndef OCR1AH #ifdef OCR1A #define OCR1AH mx_servo_dummy #endif #endif #ifndef OCR1AL #ifdef OCR1A #define OCR1AL OCR1A #endif #endif #ifndef OCR1BH #ifdef OCR1B #define OCR1BH mx_servo_dummy #endif #endif #ifndef OCR1BL #ifdef OCR1B #define OCR1BL TCC1.CCB #endif #endif #endif #define MX_SERVO_T1CON 0x01 #define MX_SERVO_REG_CCPR1H OCR1AH #define MX_SERVO_REG_CCPR1L OCR1AL #define MX_SERVO_REG_CCPR2H OCR1BH #define MX_SERVO_REG_CCPR2L OCR1BL #define MX_SERVO_REG_T1CON mx_servo_dummy #define MX_SERVO_REG_CCP1CON TCCR1A #define MX_SERVO_REG_CCP2CON TCCR1B #define MX_SERVO_REG_CCP1EN TIMSK1 #define MX_SERVO_REG_CCP2EN TIMSK1 #define MX_SERVO_FLAG_CCP1EN OCIE1A #define MX_SERVO_FLAG_CCP2EN OCIE1B #define MX_SERVO_REG_CCP1F TIFR1 #define MX_SERVO_REG_CCP2F TIFR1 #define MX_SERVO_FLAG_CCP1F OCF1A #define MX_SERVO_FLAG_CCP2F OCF1B #define MX_SERVO_REG_INT mx_servo_dummy #define MX_SERVO_FLAG_GLOB 0 #define MX_SERVO_FLAG_PERIPH 0 #define MX_SERVO_CCP1CON 0x00 #define MX_SERVO_CCP2CON 0x0A //CTC mode with PWM prescale / 8 #define MX_CCP1_INT_START ISR(TIMER1_COMPA_vect) #define MX_CCP2_INT_START ISR(TIMER1_COMPB_vect) #endif #ifdef MX_CAL_ARM MX_UINT8 mx_servo_dummy; #define MX_SERVO_REG_CCP1F mx_servo_dummy #define MX_SERVO_REG_CCP2F mx_servo_dummy #define MX_SERVO_FLAG_CCP1F 0 #define MX_SERVO_FLAG_CCP2F 1 #define MX_CCP1_INT_START if ((periphID == AT91C_ID_TC2) && (IFlags & AT91C_TC_CPCS)) #define MX_CCP2_INT_START if ((periphID == AT91C_ID_TC2) && (IFlags & AT91C_TC_CPAS)) #endif #define FCVsz_0fb1_v5__servo0__SERVO_POSITION 8 #define FCVsz_0fb1_v5__servo0__SERVO_TRIM 8 #define FCVsz_0fb1_v5__servo0__SERVO_REQUIRED 8 MX_GLOBAL MX_UINT8 FCV_0fb1_v5__servo0__SERVO_ENABLED = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__servo0__SERVO_IDX = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__servo0__SERVO_POSITION[FCVsz_0fb1_v5__servo0__SERVO_POSITION]; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__servo0__SERVO_TRIM[FCVsz_0fb1_v5__servo0__SERVO_TRIM]; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__servo0__SERVO_REQUIRED[FCVsz_0fb1_v5__servo0__SERVO_REQUIRED]; void FCD_0fb1_v5__servo0__DisableServo(MX_UINT8 FCL_CHANNEL); void FCD_0fb1_v5__servo0__SetPosition(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_POSITION); MX_UINT8 FCD_0fb1_v5__servo0__MoveToPosition(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_POSITION); void FCD_0fb1_v5__servo0__SetTrim(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_TRIM); void FCD_0fb1_v5__servo0__AutoMoveToPosition(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_POSITION); void FCD_0fb1_v5__servo0__EnableServo(MX_UINT8 FCL_CHANNEL); void FCD_0fb1_v5__servo0__Initialise(); /*========================================================================*\ Use :dash_IO_flasher1 :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :cal_pwm1 :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_PWM_REF1 #define MX_PWM_PRESCALE1 (4) #define MX_PWM_PIN_1 (2) #define MX_PWM_PORT_1 portc #define MX_PWM_PERIOD 255 #define MX_PWM_TRIS_1 trisc #define MX_PWM_CHANNEL_1 (0) /*=----------------------------------------------------------------------=*\ Use :cal_pwm1 :Supplementary defines \*=----------------------------------------------------------------------=*/ #define MX_PWM void FC_CAL_PWM_ChangePeriod_1(MX_UINT8 FCL_PERIOD, MX_UINT16 FCL_PRESCALER); void FC_CAL_PWM_Disable_1(); void FC_CAL_PWM_SetDuty8Bit_1(MX_UINT8 FCL_DUTY); void FC_CAL_PWM_Enable_1(); void FC_CAL_PWM_SetDuty10Bit_1(MX_UINT16 FCL_DUTY); /*========================================================================*\ Use :v5__rc50 :Variable declarations :Macro function declarations \*========================================================================*/ #define TIMER_AVR_ENVAL #define PWM_DUTY 69 #define TIMER_PRE_VAL 117 #define PWM_OPT 0 #define CUTOFF_WIDTH 11 #define TIMER_ARM_ENVAL #define TIMER_ENVAL 1 #define PWM_SCALER 0 #define LOWER_WIDTH 3 #define PWM_PERIOD 138 #define UPPER_WIDTH 23 /*=----------------------------------------------------------------------=*\ Use :v5__rc50 :Supplementary defines \*=----------------------------------------------------------------------=*/ #ifdef MX_CAL_PIC #ifndef TMR0 #define tmr0 tmr0l #endif #ifndef OPTION_REG #define option_reg intcon2 #endif #ifndef INTEDG #define INTEDG INTEDG0 #endif #ifndef INTE #define INTE INT0E #endif #ifndef INTF #define INTF INT0F #endif #define TIMER_REGISTER tmr0 #define TIMER_CTRLREG option_reg #define TIMER_ENREG intcon #define TIMER_ENBIT TMR0IE #define TIMER_FLAGREG intcon #define TIMER_FLAGBIT TMR0IF #define TIMER_CSREG option_reg #define TIMER_CSBIT T0CS #define TIMER2_PR pr2 #define TIMER2_CON t2con #define TIMER2_EN TMR2ON #define INT_ENREG intcon #define INT_ENBIT INTE #define INT_FLAGREG intcon #define INT_FLAGBIT INTF #define INT_EDGEREG option_reg #define INT_EDGEBIT INTEDG #define INT_GLOBAL GIE #define INT_GLOBREG intcon #if (PWM_OPT == 1) #define PWM_C1CON ccp1con #define PWM_C1REG ccpr1l #endif #if (PWM_OPT == 2) #define PWM_C2CON ccp2con #define PWM_C2REG ccpr2l #endif #define MX_VOL_PRE #define MX_RC5_INT if ((ts_bit(INT_ENREG, INT_ENBIT)) && (ts_bit(INT_FLAGREG, INT_FLAGBIT))) #define MX_RC5_TIMER if ((ts_bit(TIMER_ENREG, TIMER_ENBIT)) && (ts_bit(TIMER_FLAGREG, TIMER_FLAGBIT))) #endif #ifdef MX_CAL_AVR MX_UINT8 mx_servo_dummy; #define TIMER_REGISTER TCNT0 #define TIMER_CTRLREG TCCR1B #define TIMER_ENREG TIMSK0 #define TIMER_ENBIT TOIE0 #define TIMER_FLAGREG TIFR0 #define TIMER_FLAGBIT TOV0 #define TIMER_CSREG mx_servo_dummy #define TIMER_CSBIT 0 #ifdef MX_TINY #ifdef OCR1C #define TIMER2_PR OCR1C #else #ifdef ICR1 #define TIMER2_PR ICR1 #endif #endif #else #ifdef ICR1 #define TIMER2_PR ICR1 #endif #endif #ifdef TCCR1 #define MX_TCCR1A TCCR1 #define MX_PRESCALE TCCR1 #else #define MX_TCCR1A TCCR1A #define MX_PRESCALE TCCR1B #endif #define TIMER2_CON TCCR1B #define TIMER2_EN 0 #define INT_ENREG EIMSK #define INT_ENBIT INT0 #define INT_FLAGREG EIFR #define INT_FLAGBIT INTF0 #define INT_EDGEREG EICRA #define INT_EDGEBIT ISC00 #define INT_GLOBAL 0 #define INT_GLOBREG mx_servo_dummy #if (PWM_OPT == 1) #define PWM_C1CON MX_TCCR1A #define PWM_C1REG OCR1A #endif #if (PWM_OPT == 2) #define PWM_C2CON MX_TCCR1A #define PWM_C2REG OCR1B #endif #define MX_VOL_PRE volatile #define MX_RC5_INT ISR(INT0_vect) #define MX_RC5_TIMER ISR(TIMER0_OVF_vect) #endif #ifdef MX_CAL_ARM MX_UINT8 dummy_register; #define TIMER_REGISTER AT91C_BASE_TC1->TC_CV #define TIMER_CTRLREG dummy_register #define TIMER_ENREG dummy_register #define TIMER_ENBIT 0 #define TIMER_FLAGREG dummy_register #define TIMER_FLAGBIT 0 #define TIMER_CSREG dummy_register #define TIMER_CSBIT 0 #define TIMER2_PR dummy_register #define TIMER2_CON dummy_register #define TIMER2_EN 0 #define INT_ENREG dummy_register #define INT_ENBIT 0 #define INT_FLAGREG dummy_register #define INT_FLAGBIT 0 #define INT_EDGEREG dummy_register #define INT_EDGEBIT 0 #define INT_GLOBAL dummy_register #define INT_GLOBREG dummy_register #if (PWM_OPT == 1) #define PWM_C1CON dummy_register #define PWM_C1REG 0 #endif #if (PWM_OPT == 2) #define PWM_C2CON dummy_register #define PWM_C2REG 0 #endif #define MX_VOL_PRE volatile #define MX_RC5_INT #define MX_RC5_TIMER if ((periphID == AT91C_ID_TC1) && (IFlags & AT91C_TC_CPCS)) #endif #ifdef MX_CAL_PIC16BIT #define TIMER_REGISTER TMR1 #define TIMER_CTRLREG T1CON #define TIMER_ENREG IEC0bits #define TIMER_ENBIT T1IE #define TIMER_FLAGREG IFS0bits #define TIMER_FLAGBIT T1IF #define TIMER_PRREG PR1 #define TIMER2_PR PR2 #define TIMER2_CON T2CONbits #define TIMER2_EN TON #define INT_ENREG IEC0bits #define INT_ENBIT INT0IE #define INT_FLAGREG IFS0bits #define INT_FLAGBIT INT0IF #define INT_EDGEREG INTCON2bits #define INT_EDGEBIT INT0EP #define PWM_C1CON OC1CON #define PWM_C2CON OC2CON #define MX_VOL_PRE #define MX_RC5_INT if ((INT_ENREG.INT_ENBIT) && (INT_FLAGREG.INT_FLAGBIT)) #define MX_RC5_TIMER if ((TIMER_ENREG.TIMER_ENBIT) && (TIMER_FLAGREG.TIMER_FLAGBIT)) #endif #define FCV_0fb1_v5__rc50__S1 (2) #define FCV_0fb1_v5__rc50__S0 (4) #define FCV_0fb1_v5__rc50__E0 (0) #define FCV_0fb1_v5__rc50__M1 (1) #define FCV_0fb1_v5__rc50__M0 (3) MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__OUT_ADDRESS = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__COUNT = (0x0); MX_GLOBAL MX_UINT16 FCV_0fb1_v5__rc50__TXBUFF; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__ADDRESS = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__OUT_COMMAND = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__COMMAND = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__TOGGLE = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__INTCOUNT; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__STATE = (0x0); MX_GLOBAL MX_UINT16 FCV_0fb1_v5__rc50__PACKET = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__TX_COUNT; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__OUT_TOGGLE = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__TX_CYCLE; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__TMR_RX_EN; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__TX_HALF; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__UPDATE = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__TMR_TX_EN; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__rc50__XPULSELEVEL; void FCD_0fb1_v5__rc50__StateMC(MX_UINT8 FCL_HIGH_PULSE, MX_UINT8 FCL_WIDE_PULSE); MX_UINT8 FCD_0fb1_v5__rc50__CollectData(MX_UINT8 FCL_SELECTION); void FCD_0fb1_v5__rc50__Initialise_States(); void FCD_0fb1_v5__rc50__RXDisable(); void FCD_0fb1_v5__rc50__Timer_Event(); void FCD_0fb1_v5__rc50__TXPacket(MX_UINT8 FCL_COMMAND, MX_UINT8 FCL_ADDRESS, MX_UINT8 FCL_TOGGLE); void FCD_0fb1_v5__rc50__TXEnable(); void FCD_0fb1_v5__rc50__Signal_Edge(); MX_UINT8 FCD_0fb1_v5__rc50__CheckRx(); void FCD_0fb1_v5__rc50__TXDisable(); void FCD_0fb1_v5__rc50__RXEnable(); /*========================================================================*\ Use :dash_IO_flasher :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :cal_spi :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_SPI_REF2 #define MX_SPI_SS_TRIS_2 tris #define MX_SPI_MISO_PORT_2 portc #define MX_SPI_SCK_TRIS_2 trisc #define MX_SPI_SCK_PIN_2 (3) #define MX_SPI_MOSI_TRIS_2 trisc #define MX_SPI_BMODE_2 (0) #define MX_SPI_MISO_TRIS_2 trisc #define MX_SPI_MOSI_PIN_2 (5) #define MX_SPI_MISO_PIN_2 (4) #define MX_SPI_SS_PIN_2 (0) #define MX_SPI_PR_SCALE_2 (4) #define MX_SPI_SS_PORT_2 port #define MX_SPI_SCK_PORT_2 portc #define MX_SPI_MOSI_PORT_2 portc #define MX_SPI_CHANNEL_2 (1) MX_GLOBAL MX_UINT32 FCV_010fd_cal_spi__CONSOLE; void FC_CAL_SPI_Slave_Uninit_2(); void FCD_010fd_cal_spi__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR); void FC_CAL_SPI_Slave_Init_2(); void FC_CAL_SPI_Master_Uninit_2(); MX_UINT8 FC_CAL_SPI_Master_Byte_2(MX_UINT8 FCL_DATAOUT); void FC_CAL_SPI_Slave_TxByte_2(MX_UINT8 FCL_DATA); MX_UINT8 FC_CAL_SPI_Slave_RxByte_2(); void FC_CAL_SPI_SetPrescaler_2(MX_UINT8 FCL_PRESCALER); void FC_CAL_SPI_Master_Init_2(); /*========================================================================*\ Use :v5__spi_legacy0 :Variable declarations :Macro function declarations \*========================================================================*/ #define FCV_0fb1_v5__spi_legacy0__FRAM_WRITE (2) #define FCV_0fb1_v5__spi_legacy0__FRAM_READ (3) #define FCV_0fb1_v5__spi_legacy0__FRAM_WREN (6) void FCD_0fb1_v5__spi_legacy0__SendString(MX_CHAR* PFCL_STR); void FCD_0fb1_v5__spi_legacy0__NVMSendChar(MX_UINT8 FCL_HI_ADDR, MX_UINT8 FCL_LO_ADDR, MX_UINT8 FCL_CHAR); void FCD_0fb1_v5__spi_legacy0__GetString(MX_CHAR* FCR_RETVAL, MX_UINT16 FCRsz_RETVAL, MX_UINT8 FCL_NUMBYTES, MX_UINT8 FCL_CH); void FCD_0fb1_v5__spi_legacy0__DACSendChar(MX_UINT8 FCL_CHAR); void FCD_0fb1_v5__spi_legacy0__SendChar(MX_UINT8 FCL_CHAR); MX_UINT8 FCD_0fb1_v5__spi_legacy0__NVMGetChar(MX_UINT8 FCL_HI_ADDR, MX_UINT8 FCL_LO_ADDR); void FCD_0fb1_v5__spi_legacy0__EnableFram(); MX_UINT8 FCD_0fb1_v5__spi_legacy0__FramOutput(MX_UINT8 FCL_CHAR); void FCD_0fb1_v5__spi_legacy0__DisableFram(); MX_UINT8 FCD_0fb1_v5__spi_legacy0__GetChar(); void FCD_0fb1_v5__spi_legacy0__UnInitialise(); void FCD_0fb1_v5__spi_legacy0__Initialise(); /*========================================================================*\ Use :InjectorBase1 :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :cal_can :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_CAN_TXB1DB4_1 (5) #define MX_CAN_TXB1DB3_1 (6) #define MX_CAN_TXB1DB2_1 (7) #define MX_CAN_TXB1DB1_1 (8) #define MX_CAN_TXB1DB0_1 (9) #define MX_CAN_BAUD3_1 (3) #define MX_CAN_BAUD2_1 (209) #define MX_CAN_TXB2ID_1 (720) #define MX_CAN_BAUD1_1 (7) #define MX_CAN_TXB1LEN_1 (7) #define MX_CAN_TXB2DB7_1 (0) #define MX_CAN_TXB2DB6_1 (0) #define MX_CAN_RXB1CFG_1 (2) #define MX_CAN_TXB2DB5_1 (0) #define MX_CAN_TXB2DB4_1 (0) #define MX_CAN_TXB2DB3_1 (0) #define MX_CAN_TXB2DB2_1 (0) #define MX_CAN_TXB2DB1_1 (0) #define MX_CAN_TXB2DB0_1 (0) #define MX_CAN_TXB0DB7_1 (0) #define MX_CAN_TXB0ID_1 (688) #define MX_CAN_TXB0DB6_1 (0) #define MX_CAN_RXF5_1 (255) #define MX_CAN_TXB0DB5_1 (0) #define MX_CAN_RXF4_1 (255) #define MX_CAN_TXB0DB4_1 (0) #define MX_CAN_RXM1_1 (255) #define MX_CAN_RXF3_1 (255) #define MX_CAN_EXID_1 (0) #define MX_CAN_TXB0DB3_1 (0) #define MX_CAN_RXM0_1 (255) #define MX_CAN_RXF2_1 (192) #define MX_CAN_TXB0DB2_1 (0) #define MX_CAN_TXB2LEN_1 (0) #define MX_CAN_RXF1_1 (255) #define MX_CAN_TXB0DB1_1 (170) #define MX_CAN_RXF0_1 (185) #define MX_CAN_TXB0DB0_1 (85) #define MX_CAN_TXB1ID_1 (704) #define MX_CAN_TXB0LEN_1 (2) #define MX_CAN_TXB1DB7_1 (0) #define MX_CAN_CHANNEL_1 (0) #define MX_CAN_TXB1DB6_1 (3) #define MX_CAN_RXB0CFG_1 (2) #define MX_CAN_TXB1DB5_1 (4) MX_GLOBAL MX_UINT32 FCV_010dd_cal_can__CONSOLE; void FC_CAL_Internal_CAN_Prv_TextConsole_1(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR); void FC_CAL_Internal_CAN_SetTxIdentStd_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO); void FC_CAL_Internal_CAN_SetTxIdentExd_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_ID3, MX_UINT8 FCL_ID2, MX_UINT8 FCL_ID1, MX_UINT8 FCL_ID0); void FC_CAL_Internal_CAN_SetTxData_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_DATA_CNT, MX_UINT8 FCL_D0, MX_UINT8 FCL_D1, MX_UINT8 FCL_D2, MX_UINT8 FCL_D3, MX_UINT8 FCL_D4, MX_UINT8 FCL_D5, MX_UINT8 FCL_D6, MX_UINT8 FCL_D7); void FC_CAL_Internal_CAN_SetRxMask_1(MX_UINT8 FCL_MASK, MX_UINT32 FCL_ID); MX_UINT8 FC_CAL_Internal_CAN_GetRxData_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_INDEX); void FC_CAL_Internal_CAN_SendBuffer_1(MX_UINT8 FCL_BUFFER); MX_UINT8 FC_CAL_Internal_CAN_GetRxDataCount_1(MX_UINT8 FCL_BUFFER); void FC_CAL_Internal_CAN_Init_1(); void FC_CAL_Internal_CAN_SetRxMaskStd_1(MX_UINT8 FCL_MASK, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO); void FC_CAL_Internal_CAN_SetRxMaskExd_1(MX_UINT8 FCL_MASK, MX_UINT8 FCL_ID3, MX_UINT8 FCL_ID2, MX_UINT8 FCL_ID1, MX_UINT8 FCL_ID0); void FC_CAL_Internal_CAN_SetRxFilter_1(MX_UINT8 FCL_FILTER, MX_UINT32 FCL_ID); void FC_CAL_Internal_CAN_SetTxIdent_1(MX_UINT8 FCL_BUFFER, MX_UINT32 FCL_ID); MX_UINT8 FC_CAL_Internal_CAN_CheckRx_1(MX_UINT8 FCL_BUFFER); void FC_CAL_Internal_CAN_Uninit_1(); MX_UINT32 FC_CAL_Internal_CAN_GetRxIdent_1(MX_UINT8 FCL_BUFFER); void FC_CAL_Internal_CAN_SetRxFilterStd_1(MX_UINT8 FCL_FILTER, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO); void FC_CAL_Internal_CAN_SetRxFilterExd_1(MX_UINT8 FCL_FILTER, MX_UINT8 FCL_ID3, MX_UINT8 FCL_ID2, MX_UINT8 FCL_ID1, MX_UINT8 FCL_ID0); /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :cal_spi :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_SPI_REF1 #define MX_SPI_SS_TRIS_1 tris #define MX_SPI_MISO_PORT_1 portc #define MX_SPI_SCK_TRIS_1 trisc #define MX_SPI_SCK_PIN_1 (3) #define MX_SPI_MOSI_TRIS_1 trisc #define MX_SPI_BMODE_1 (5) #define MX_SPI_MISO_TRIS_1 trisc #define MX_SPI_MOSI_PIN_1 (5) #define MX_SPI_MISO_PIN_1 (4) #define MX_SPI_SS_PIN_1 (0) #define MX_SPI_PR_SCALE_1 (64) #define MX_SPI_SS_PORT_1 port #define MX_SPI_SCK_PORT_1 portc #define MX_SPI_MOSI_PORT_1 portc #define MX_SPI_CHANNEL_1 (1) MX_GLOBAL MX_UINT32 FCV_010dd_cal_spi__CONSOLE; void FC_CAL_SPI_Slave_Uninit_1(); void FCD_010dd_cal_spi__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR); void FC_CAL_SPI_Slave_Init_1(); void FC_CAL_SPI_Master_Uninit_1(); MX_UINT8 FC_CAL_SPI_Master_Byte_1(MX_UINT8 FCL_DATAOUT); void FC_CAL_SPI_Slave_TxByte_1(MX_UINT8 FCL_DATA); MX_UINT8 FC_CAL_SPI_Slave_RxByte_1(); void FC_CAL_SPI_SetPrescaler_1(MX_UINT8 FCL_PRESCALER); void FC_CAL_SPI_Master_Init_1(); /*========================================================================*\ Use :v5__can0 :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_SPI_CAN_REF1 #define FCVsz_0fb1_v5__can0__CAN_MSG_DATA 8 #define FCVsz_0fb1_v5__can0__CAN_MSG_IDB 4 #define FCV_0fb1_v5__can0__CAN_WRITE (2) // External CAN Write Command #define FCV_0fb1_v5__can0__CAN_RTS_TXB2 (132) #define FCV_0fb1_v5__can0__CAN_CANSTAT (14) #define FCV_0fb1_v5__can0__CAN_RTS_TXB1 (130) // Request to Send Buffer 1 #define FCV_0fb1_v5__can0__CAN_RTS_TXB0 (129) #define FCV_0fb1_v5__can0__CAN_BFPCTRL (12) #define FCV_0fb1_v5__can0__CAN_CNF3 (40) #define FCV_0fb1_v5__can0__CAN_CNF2 (41) #define FCV_0fb1_v5__can0__CAN_CNF1 (42) #define FCV_0fb1_v5__can0__CAN_RX_STATUS (176) #define FCV_0fb1_v5__can0__CAN_TXRTSCTRL (13) #define FCV_0fb1_v5__can0__CAN_BIT_MODIFY (5) #define FCV_0fb1_v5__can0__CAN_REQOP_NORMAL (0) #define FCV_0fb1_v5__can0__CAN_CANCTRL (15) #define FCV_0fb1_v5__can0__CAN_EFLG (45) #define FCV_0fb1_v5__can0__CAN_READ (3) #define FCV_0fb1_v5__can0__CAN_REQOP_CONFIG (128) #define FCV_0fb1_v5__can0__CAN_RXB0CTRL (96) #define FCV_0fb1_v5__can0__CAN_RXB1CTRL (112) MX_GLOBAL MX_UINT8 FCV_0fb1_v5__can0__CAN_MSG_DLC; MX_GLOBAL MX_CHAR FCV_0fb1_v5__can0__CAN_MSG_DATA[FCVsz_0fb1_v5__can0__CAN_MSG_DATA]; MX_GLOBAL MX_UINT32 FCV_0fb1_v5__can0__CAN_MSG_ID; MX_GLOBAL MX_CHAR FCV_0fb1_v5__can0__CAN_MSG_IDB[FCVsz_0fb1_v5__can0__CAN_MSG_IDB]; MX_UINT8 FC_CAN_ReadSwitches_1(); MX_UINT8 FC_CAN_SPI_CAN_Status_1(MX_UINT8 FCL_COMMAND); void FC_CAN_SetTxData_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_COUNT, MX_UINT8 FCL_D0, MX_UINT8 FCL_D1, MX_UINT8 FCL_D2, MX_UINT8 FCL_D3, MX_UINT8 FCL_D4, MX_UINT8 FCL_D5, MX_UINT8 FCL_D6, MX_UINT8 FCL_D7); void FC_CAN_SPI_CAN_Command_1(MX_UINT8 FCL_COMMAND); void FC_CAN_SetRxMask_1(MX_UINT8 FCL_MASK, MX_UINT32 FCL_ID); MX_UINT8 FC_CAN_GetRxData_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_INDEX); void FC_CAN_SPI_CAN_Config_1(MX_UINT8 FCL_CFG); MX_UINT8 FC_CAN_GetRxIDHi_1(MX_UINT8 FCL_BUFFER); void FC_CAN_SetTxIDSimple_1(MX_UINT8 FCL_BUFFER, MX_UINT16 FCL_ID); void FC_CAN_SendBuffer_1(MX_UINT8 FCL_BUFFER); void FC_CAN_SPI_CAN_BitModify_1(MX_UINT8 FCL_ADDR, MX_UINT8 FCL_MASK, MX_UINT8 FCL_DATA); void FC_CAN_SPI_CS_Disable_1(); void FC_CAN_IDB_to_ID_1(); void FC_CAN_SPI_CAN_ReadIDB_1(MX_UINT8 FCL_BUFFER); MX_UINT8 FC_CAN_GetRxDataCount_1(MX_UINT8 FCL_BUFFER); void FC_CAN_SetRxFilterID_1(MX_UINT8 FCL_FILTER, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO); void FC_CAN_SPI_CAN_Write_1(MX_UINT8 FCL_ADDR, MX_UINT8 FCL_DATA); void FC_CAN_SPI_CS_Enable_1(); void FC_CAN_ID_to_IDB_1(); MX_UINT8 FC_CAN_GetRxIDLo_1(MX_UINT8 FCL_BUFFER); void FC_CAN_SetRxMaskID_1(MX_UINT8 FCL_MASK, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO); void FC_CAN_SetRxFilter_1(MX_UINT8 FCL_FILTER, MX_UINT32 FCL_ID); void FC_CAN_SetTxIdent_1(MX_UINT8 FCL_BUFFER, MX_UINT32 FCL_ID); MX_UINT8 FC_CAN_CheckRx_1(MX_UINT8 FCL_BUFFER); MX_UINT8 FC_CAN_SPI_CAN_Read_1(MX_UINT8 FCL_ADDR); MX_UINT16 FC_CAN_GetRxIDSimple_1(MX_UINT8 FCL_BUFFER); void FC_CAN_SetTxID_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO); void FC_CAN_SPI_CAN_WriteIDB_1(MX_UINT8 FCL_ADDRESS); void FC_CAN_SPI_CAN_Init_1(); void FC_CAN_ShowLEDs_1(MX_UINT8 FCL_LED1, MX_UINT8 FCL_LED2); MX_UINT32 FC_CAN_GetRxIdent_1(MX_UINT8 FCL_BUFFER); void FC_CAN_Initialise_1(); /*========================================================================*\ Use :dash_IO_flasher :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :cal_i2c :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_I2C_SDA_PORT_1 portc #define MX_I2C_REF1 #define MX_I2C_1 #define MX_I2C_BMODE_1 (0) #define MX_I2C_SDA_TRIS_1 trisc #define MX_I2C_SCL_PIN_1 (3) #define MX_I2C_SCL_PORT_1 portc #define MX_I2C_SDA_PIN_1 (4) #define MX_I2C_SCL_TRIS_1 trisc #define MX_I2C_BAUD_1 (100000) #define MX_I2C_CHANNEL_1 (1) /*=----------------------------------------------------------------------=*\ Use :cal_i2c :Supplementary defines \*=----------------------------------------------------------------------=*/ #define MX_MI2C MX_GLOBAL MX_UINT32 FCV_01075_cal_i2c__CONSOLE; void FC_CAL_I2C_Slave_Uninit_1(); void FCD_01075_cal_i2c__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR); void FC_CAL_I2C_Master_Stop_1(); void FC_CAL_I2C_Slave_Init_1(); void FC_CAL_I2C_Master_Uninit_1(); void FC_CAL_I2C_Slave_TxByte_1(MX_UINT8 FCL_DATA); MX_UINT8 FC_CAL_I2C_Slave_RxByte_1(MX_UINT8 FCL_LAST); void FC_CAL_I2C_Master_Init_1(); void FC_CAL_I2C_Master_Start_1(); MX_UINT8 FC_CAL_I2C_Master_TxByte_1(MX_UINT8 FCL_DATA); void FC_CAL_I2C_Master_Restart_1(); MX_UINT8 FC_CAL_I2C_Master_RxByte_1(MX_UINT8 FCL_LAST); /*========================================================================*\ Use :v5__i2c_master0 :Variable declarations :Macro function declarations \*========================================================================*/ MX_UINT8 FCD_0fb1_v5__i2c_master0__ReceiveByte(MX_UINT8 FCL_LAST); void FCD_0fb1_v5__i2c_master0__Restart(); void FCD_0fb1_v5__i2c_master0__Stop(); MX_UINT8 FCD_0fb1_v5__i2c_master0__ReceiveByteTransaction(MX_UINT8 FCL_DEVICE_ID, MX_UINT8 FCL_ADDRH, MX_UINT8 FCL_ADDRL); MX_UINT8 FCD_0fb1_v5__i2c_master0__TransmitByte(MX_UINT8 FCL_DATA); void FCD_0fb1_v5__i2c_master0__SendByteTransaction(MX_UINT8 FCL_DEVICE_ID, MX_UINT8 FCL_ADDRH, MX_UINT8 FCL_ADDRL, MX_UINT8 FCL_DATA); void FCD_0fb1_v5__i2c_master0__Start(); void FCD_0fb1_v5__i2c_master0__Initialise(); /*========================================================================*\ Use :lut_CRC :Variable declarations :Macro function declarations \*========================================================================*/ #define FCVsz_0106b_lut_CRC__FLOATFIXEDLIST 1 #define FCVsz_0106b_lut_CRC__INTLIST 256 #define FCVsz_0106b_lut_CRC__FLOATLIST 1 #define FCVsz_0106b_lut_CRC__INTFIXEDLIST 1 #define FCD_0106b_lut_CRC__INTLIST(ix) FCD_0106b_lut_CRC__INTLIST_LUT[ix] ROMARRAY_(MX_UINT8) FCD_0106b_lut_CRC__INTLIST_LUT ROMARRAY_E = { // Property added elements 0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65, 157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220, 35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98, 190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255, 70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7, 219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154, 101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36, 248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185, 140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205, 17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80, 175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238, 50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115, 202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139, 87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22, 233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168, 116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53 // Dynamically added elements }; /*========================================================================*\ Use :v5__one_wire0 :Variable declarations :Macro function declarations \*========================================================================*/ #define FCVsz_0fb1_v5__one_wire0__ID 8 #define FCVsz_0fb1_v5__one_wire0__SCRATCHPAD 9 #define FCVsz_0fb1_v5__one_wire0__DEV_ID 64 #define FCV_0fb1_v5__one_wire0__OO_CONVERTT (68) #define FCV_0fb1_v5__one_wire0__OO_READPAD (190) #define FCV_0fb1_v5__one_wire0__OO_SEARCHROM (240) #define FCV_0fb1_v5__one_wire0__OO_SKIPROM (204) #define FCV_0fb1_v5__one_wire0__OO_MATCHROM (85) MX_GLOBAL MX_UINT8 FCV_0fb1_v5__one_wire0__CRC; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__one_wire0__NUM_DEVICES = (0x0); MX_GLOBAL MX_UINT8 FCV_0fb1_v5__one_wire0__NEW_CONFLICT; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__one_wire0__ID[FCVsz_0fb1_v5__one_wire0__ID]; MX_GLOBAL MX_SINT16 FCV_0fb1_v5__one_wire0__CONFLICT; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__one_wire0__SCRATCHPAD[FCVsz_0fb1_v5__one_wire0__SCRATCHPAD]; MX_GLOBAL MX_UINT8 FCV_0fb1_v5__one_wire0__DEV_ID[FCVsz_0fb1_v5__one_wire0__DEV_ID]; MX_UINT8 FCD_0fb1_v5__one_wire0__DS1820_StartConversion(); MX_UINT8 FCD_0fb1_v5__one_wire0__ReceiveByte(); void FCD_0fb1_v5__one_wire0__TransmitByte(MX_UINT8 FCL_COMMAND); MX_UINT8 FCD_0fb1_v5__one_wire0__GetPadByte(MX_UINT8 FCL_INDEX); void FCD_0fb1_v5__one_wire0__CRC_Init(); MX_UINT8 FCD_0fb1_v5__one_wire0__BusReset(); MX_UINT8 FCD_0fb1_v5__one_wire0__ScanBus(); MX_UINT8 FCD_0fb1_v5__one_wire0__Receive_Bit(); MX_UINT8 FCD_0fb1_v5__one_wire0__GetDeviceCount(); void FCD_0fb1_v5__one_wire0__CRC_Shuffle_Byte(MX_UINT8 FCL_DATA); MX_UINT8 FCD_0fb1_v5__one_wire0__Get_Next_ID(); MX_UINT8 FCD_0fb1_v5__one_wire0__GetIDByte(MX_UINT8 FCL_DEVICE, MX_UINT8 FCL_OCTET); MX_UINT8 FCD_0fb1_v5__one_wire0__DS1820_ReadScratchpad(); MX_UINT8 FCD_0fb1_v5__one_wire0__ReadDevice(MX_UINT8 FCL_COUNT); MX_UINT16 FCD_0fb1_v5__one_wire0__DS1820_GetTemp(); void FCD_0fb1_v5__one_wire0__Transmit_Bit(MX_UINT8 FCL_DATA); /*========================================================================*\ Use :InjectorBase1 :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :COMPort1 :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :dash_IO_flasher :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :cal_uart :Variable declarations :Macro function declarations \*========================================================================*/ #define MX_UART_TX_TRIS_1 trisc #define MX_UART_REF1 #define MX_UART_RTS_PIN_1 (2) #define MX_UART_DBITS_1 (8) #define MX_UART_RETURN_1 (0) #define MX_UART_RX_PORT_1 portc #define MX_UART_RTS_PORT_1 portb #define MX_UART_ECHO_1 (0) #define MX_UART_FLOWEN_1 (0) #define MX_UART_CTS_PORT_1 portb #define MX_UART_TX_PIN_1 (6) #define MX_UART_RX_TRIS_1 trisc #define MX_UART_RTS_TRIS_1 trisb #define MX_UART_BAUD_1 (9600) #define MX_UART_TX_PORT_1 portc #define MX_UART_RX_PIN_1 (7) #define MX_UART_CTS_TRIS_1 trisb #define MX_UART_CHANNEL_1 (1) #define MX_UART_CTS_PIN_1 (1) #define MX_UART_INT_1 (0) MX_GLOBAL MX_UINT32 FCV_0fcb_cal_uart__CONSOLE; void FCD_0fcb_cal_uart__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR); void FC_CAL_UART_UpdateBaud_1(MX_UINT8 FCL_NEW_BAUD); MX_SINT16 FC_CAL_UART_Receive_1(MX_UINT8 FCL_TIMEOUT); void FC_CAL_UART_Send_1(MX_UINT16 FCL_CHAR); void FC_CAL_UART_Init_1(); void FC_CAL_UART_Delay_1(); void FC_CAL_UART_Uninit_1(); /*========================================================================*\ Use :v5__rs2320 :Variable declarations :Macro function declarations \*========================================================================*/ void FCD_0fb1_v5__rs2320__SendString(MX_CHAR* FCL_SSTRING, MX_UINT16 FCLsz_SSTRING); void FCD_0fb1_v5__rs2320__SendChar(MX_SINT16 FCL_CHAR); void FCD_0fb1_v5__rs2320__ChangeHWBaud(MX_UINT8 FCL_NEWBAUD); void FCD_0fb1_v5__rs2320__ReceiveString(MX_CHAR* FCR_RETVAL, MX_UINT16 FCRsz_RETVAL, MX_UINT8 FCL_TIMEOUT, MX_UINT8 FCL_NUMBYTES); void FCD_0fb1_v5__rs2320__Initialise(); MX_SINT16 FCD_0fb1_v5__rs2320__ReceiveChar(MX_SINT16 FCL_TIMEOUT); /*========================================================================*\ Use :ctrl_lcd :Variable declarations :Macro function declarations \*========================================================================*/ /*========================================================================*\ Use :v5__lcddisplay0 :Variable declarations :Macro function declarations \*========================================================================*/ void FCD_0fb1_v5__lcddisplay0__Clear(); void FCD_0fb1_v5__lcddisplay0__PrintString(MX_CHAR* FCL_TEXT, MX_UINT16 FCLsz_TEXT); void FCD_0fb1_v5__lcddisplay0__PrintAscii(MX_UINT8 FCL_CHARACTER); void FCD_0fb1_v5__lcddisplay0__PrintNumber(MX_SINT16 FCL_NUMBER); void FCD_0fb1_v5__lcddisplay0__RAMWrite(MX_UINT8 FCL_INDEX, MX_UINT8 FCL_D0, MX_UINT8 FCL_D1, MX_UINT8 FCL_D2, MX_UINT8 FCL_D3, MX_UINT8 FCL_D4, MX_UINT8 FCL_D5, MX_UINT8 FCL_D6, MX_UINT8 FCL_D7); void FCD_0fb1_v5__lcddisplay0__ClearLine(MX_UINT8 FCL_LINE); void FCD_0fb1_v5__lcddisplay0__Cursor(MX_UINT8 FCL_X, MX_UINT8 FCL_Y); void FCD_0fb1_v5__lcddisplay0__Command(MX_UINT8 FCL_INSTRUCTION); void FCD_0fb1_v5__lcddisplay0__ScrollDisplay(MX_UINT8 FCL_POSITION, MX_UINT8 FCL_DIRECTION); void FCD_0fb1_v5__lcddisplay0__RawSend(MX_UINT8 FCL_DATA, MX_UINT8 FCL_MASK); void FCD_0fb1_v5__lcddisplay0__Start(); /*========================================================================*\ Use :Include the chip adaption layer \*========================================================================*/ #include "C:\Program Files (x86)\Flowcode 6 Beta\CAL\includes.c" /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :v5__pwm2 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :v5__pwm1 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :v5__pwm0 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_adc :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :adc_base :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Background call to read the ADC at full bit depth :Call Enable() first : :Returns : MX_UINT16 \*=----------------------------------------------------------------------=*/ MX_UINT16 FCD_0123d_adc_base__RawSampleInt() { //Local variable definitions MX_UINT16 FCR_RETVAL; FCR_RETVAL = FC_CAL_ADC_Sample(1); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Background call to read the ADC as a byte :Call Enable() before this : :Parameters for macro RawAverageByte: : NumSamples : MX_UINT8 : DelayUs : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0123d_adc_base__RawAverageByte(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS) { //Local variable definitions MX_UINT32 FCL_AVERAGE = (0x0); MX_UINT8 FCL_COUNT = (0x0); MX_UINT8 FCR_RETVAL; if (FCL_DELAYUS != 0) { while (FCL_COUNT < FCL_NUMSAMPLES) { FCL_AVERAGE = FCL_AVERAGE + FC_CAL_ADC_Sample(0); FCL_COUNT = FCL_COUNT + 1; FCI_DELAYBYTE_US(FCL_DELAYUS); } } else { while (FCL_COUNT < FCL_NUMSAMPLES) { FCL_AVERAGE = FCL_AVERAGE + FC_CAL_ADC_Sample(0); FCL_COUNT = FCL_COUNT + 1; } } FCR_RETVAL = FCL_AVERAGE / FCL_COUNT; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Reads the ADC as a direct voltage and returns as as tring : :Returns : MX_CHAR \*=----------------------------------------------------------------------=*/ void FCD_0123d_adc_base__GetString(MX_CHAR* FCR_RETVAL, MX_UINT16 FCRsz_RETVAL) { //Local variable definitions MX_FLOAT FCL_SAMPLE; FCL_SAMPLE = FCD_0123d_adc_base__GetVoltage(); FCI_FLOAT_TO_STRING(FCL_SAMPLE, FCV_PRECISION, FCR_RETVAL,FCRsz_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Background call to read the ADC as a full width sample over time :Call Enable() before this : :Parameters for macro RawAverageInt: : NumSamples : MX_UINT8 : DelayUs : MX_UINT8 : :Returns : MX_SINT16 \*=----------------------------------------------------------------------=*/ MX_SINT16 FCD_0123d_adc_base__RawAverageInt(MX_UINT8 FCL_NUMSAMPLES, MX_UINT8 FCL_DELAYUS) { //Local variable definitions MX_UINT32 FCL_AVERAGE = (0x0); MX_UINT8 FCL_COUNT = (0x0); MX_SINT16 FCR_RETVAL; if (FCL_DELAYUS != 0) { while (FCL_COUNT < FCL_NUMSAMPLES) { FCL_AVERAGE = FCL_AVERAGE + FC_CAL_ADC_Sample(1); FCL_COUNT = FCL_COUNT + 1; FCI_DELAYBYTE_US(FCL_DELAYUS); } } else { while (FCL_COUNT < FCL_NUMSAMPLES) { FCL_AVERAGE = FCL_AVERAGE + FC_CAL_ADC_Sample(1); FCL_COUNT = FCL_COUNT + 1; } } FCR_RETVAL = FCL_AVERAGE / FCL_COUNT; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Reads the ADC as a direct voltage : :Returns : MX_FLOAT \*=----------------------------------------------------------------------=*/ MX_FLOAT FCD_0123d_adc_base__GetVoltage() { //Local variable definitions MX_UINT16 FCL_SAMPLE; MX_FLOAT FCR_RETVAL; FC_CAL_ADC_Enable(1, 0, 0, 0); FCL_SAMPLE = FC_CAL_ADC_Sample(1); FCR_RETVAL = flt_mul(flt_fromi(FCL_SAMPLE), 0.004883); FC_CAL_ADC_Disable(); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Enables the ADC channel \*=----------------------------------------------------------------------=*/ void FCD_0123d_adc_base__RawEnable() { FC_CAL_ADC_Enable(1, 0, 0, 0); } /*=----------------------------------------------------------------------=*\ Use :Background call to read the ADC as a byte :Call Enable() before this : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0123d_adc_base__RawSampleByte() { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = FC_CAL_ADC_Sample(0); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Blocking call to read the ADC at full bit depth : :Returns : MX_UINT16 \*=----------------------------------------------------------------------=*/ MX_UINT16 FCD_0123d_adc_base__GetInt() { //Local variable definitions MX_UINT16 FCR_RETVAL; FC_CAL_ADC_Enable(1, 0, 0, 0); FCR_RETVAL = FC_CAL_ADC_Sample(1); FC_CAL_ADC_Disable(); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Disables the previously enabled ADC channel \*=----------------------------------------------------------------------=*/ void FCD_0123d_adc_base__RawDisable() { FC_CAL_ADC_Disable(); } /*=----------------------------------------------------------------------=*\ Use :Blocking call to read the ADC as a byte : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0123d_adc_base__GetByte() { //Local variable definitions MX_UINT8 FCR_RETVAL; FC_CAL_ADC_Enable(1, 0, 0, 0); FCR_RETVAL = FC_CAL_ADC_Sample(0); FC_CAL_ADC_Disable(); return (FCR_RETVAL); } /*========================================================================*\ Use :v5__adc0 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :lut :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :stepper_base :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Move the motor forward by one step. \*=----------------------------------------------------------------------=*/ void FCD_01203_stepper_base__IncrementStep() { //Local variable definitions MX_UINT8 FCL_VALUE; if (FCV_01203_stepper_base__ENABLED) { FCV_01203_stepper_base__STEP_PHASE = (FCV_01203_stepper_base__STEP_PHASE + 1); if (FCV_01203_stepper_base__STEP_PHASE >= FCV_01203_stepper_base__ROLLOVER) { FCV_01203_stepper_base__STEP_PHASE = 0; // } else { } FCL_VALUE = FCD_01225_lut__INTLIST(FCV_01203_stepper_base__STEP_PHASE); FCD_01203_stepper_base__Output_Step(FCL_VALUE); // } else { } } /*=----------------------------------------------------------------------=*\ Use :Move the motor backwards by one step. \*=----------------------------------------------------------------------=*/ void FCD_01203_stepper_base__DecrementStep() { //Local variable definitions MX_UINT8 FCL_VALUE; if (FCV_01203_stepper_base__ENABLED) { if (FCV_01203_stepper_base__STEP_PHASE == 0) { FCV_01203_stepper_base__STEP_PHASE = FCV_01203_stepper_base__ROLLOVER; // } else { } FCV_01203_stepper_base__STEP_PHASE = (FCV_01203_stepper_base__STEP_PHASE - 1); FCL_VALUE = FCD_01225_lut__INTLIST(FCV_01203_stepper_base__STEP_PHASE); FCD_01203_stepper_base__Output_Step(FCL_VALUE); // } else { } } /*=----------------------------------------------------------------------=*\ Use :Turn on the motor. This must be done before it will respond to any other macros. \*=----------------------------------------------------------------------=*/ void FCD_01203_stepper_base__EnableMotor() { //Local variable definitions MX_UINT8 FCL_VALUE = (0x0); FCV_01203_stepper_base__ENABLED = 1; FCL_VALUE = FCD_01225_lut__INTLIST(FCV_01203_stepper_base__STEP_PHASE); if (FCL_VALUE & 0x01) { FCP_SET(A, 0x1, 0x0, 1); } else { FCP_SET(A, 0x1, 0x0, 0); } if (FCL_VALUE & 0x02) { FCP_SET(A, 0x2, 0x1, 1); } else { FCP_SET(A, 0x2, 0x1, 0); } if (FCL_VALUE & 0x04) { FCP_SET(A, 0x4, 0x2, 1); } else { FCP_SET(A, 0x4, 0x2, 0); } if (FCL_VALUE & 0x08) { FCP_SET(A, 0x8, 0x3, 1); } else { FCP_SET(A, 0x8, 0x3, 0); } } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro Output_Step: : Pattern : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_01203_stepper_base__Output_Step(MX_UINT8 FCL_PATTERN) { if (FCL_PATTERN & 0x01) { FCP_SET(A, 0x1, 0x0, 1); } else { FCP_SET(A, 0x1, 0x0, 0); } if (FCL_PATTERN & 0x02) { FCP_SET(A, 0x2, 0x1, 1); } else { FCP_SET(A, 0x2, 0x1, 0); } if (FCL_PATTERN & 0x04) { FCP_SET(A, 0x4, 0x2, 1); } else { FCP_SET(A, 0x4, 0x2, 0); } if (FCL_PATTERN & 0x08) { FCP_SET(A, 0x8, 0x3, 1); } else { FCP_SET(A, 0x8, 0x3, 0); } } /*=----------------------------------------------------------------------=*\ Use :Turn off the motor. It will no longer respond to any other macros. \*=----------------------------------------------------------------------=*/ void FCD_01203_stepper_base__DisableMotor() { FCV_01203_stepper_base__ENABLED = 0; FCP_SET(A, 0x1, 0x0, 0); FCP_SET(A, 0x2, 0x1, 0); FCP_SET(A, 0x4, 0x2, 0); FCP_SET(A, 0x8, 0x3, 0); FCV_01203_stepper_base__DUMMY = FCP_GET(A, 0x1, 0x0); FCV_01203_stepper_base__DUMMY = FCP_GET(A, 0x2, 0x1); FCV_01203_stepper_base__DUMMY = FCP_GET(A, 0x4, 0x2); FCV_01203_stepper_base__DUMMY = FCP_GET(A, 0x8, 0x3); } /*========================================================================*\ Use :v5__stepper0 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_eeprom :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :v5__eeprom0 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Reads a packet of bits from the EEPROM :The number of bits read is 8 or 16, depending on the platform : :Parameters for macro Read: : Address : The address, in elements, to read the data from : :Returns : MX_UINT16 \*=----------------------------------------------------------------------=*/ MX_UINT16 FCD_0fb1_v5__eeprom0__Read(MX_UINT16 FCL_ADDRESS) { //Local variable definitions MX_UINT16 FCR_RETVAL; FCR_RETVAL = FC_CAL_EE_Read(FCL_ADDRESS); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Writes a packet of bits from the EEPROM :The number of bits written is 8 or 16, depending on the platform : :Parameters for macro Write: : Address : The address, in elements, to read the data from : Value : The 8 or 16 bit value to store in EEPROM \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__eeprom0__Write(MX_UINT16 FCL_ADDRESS, MX_UINT16 FCL_VALUE) { FC_CAL_EE_Write(FCL_ADDRESS, FCL_VALUE); } /*========================================================================*\ Use :v5__servo0 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Disables a servo channel effectivly disabling the motor. : :Parameters for macro DisableServo: : Channel : The channel to set the position for. First channel is zero. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__servo0__DisableServo(MX_UINT8 FCL_CHANNEL) { //Local variable definitions MX_UINT8 FCL_DUMMY; if (FCL_CHANNEL < 1) { switch (FCL_CHANNEL) { case 1: { FCL_DUMMY = FCP_GET(A, 0x2, 0x1); break; } case 2: { FCL_DUMMY = FCP_GET(A, 0x4, 0x2); break; } case 3: { FCL_DUMMY = FCP_GET(A, 0x8, 0x3); break; } case 4: { FCL_DUMMY = FCP_GET(A, 0x10, 0x4); break; } case 5: { FCL_DUMMY = FCP_GET(A, 0x20, 0x5); break; } case 6: { /* Error: Syntax error */; break; } case 7: { /* Error: Syntax error */; break; } default: { FCL_DUMMY = FCP_GET(D, 0x1, 0x0); } } FCV_0fb1_v5__servo0__SERVO_ENABLED = FCV_0fb1_v5__servo0__SERVO_ENABLED & !(0x01 << FCL_CHANNEL); // } else { } } /*=----------------------------------------------------------------------=*\ Use :Moves directly to the specified position with no interpolation. : :Parameters for macro SetPosition: : Channel : The channel to set the position for. First channel is zero. : Position : Target position to move towards. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__servo0__SetPosition(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_POSITION) { if (FCL_CHANNEL < 1) { FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL] = FCL_POSITION; FCV_0fb1_v5__servo0__SERVO_REQUIRED[FCL_CHANNEL] = FCL_POSITION; // } else { } } /*=----------------------------------------------------------------------=*\ Use :Moves a single step towards the new position, the rate of movement is determined by how often the move to macro is called. Returns 1 if the position has been reached. : :Parameters for macro MoveToPosition: : Channel : The channel to set the position for. First channel is zero. : Position : Target position to move towards. : :Returns : 1 = reached target, 0 = target not reached. \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__servo0__MoveToPosition(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_POSITION) { //Local variable definitions MX_UINT8 FCR_RETVAL; // 1 = reached target, 0 = target not reached. FCR_RETVAL = 1; if (FCL_CHANNEL < 1) { if (FCL_POSITION != FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL]) { FCR_RETVAL = 0; if (FCL_POSITION > FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL]) { FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL] = FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL] + 1; } else { FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL] = FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL] - 1; } FCV_0fb1_v5__servo0__SERVO_REQUIRED[FCL_CHANNEL] = FCV_0fb1_v5__servo0__SERVO_POSITION[FCL_CHANNEL]; // } else { } // } else { } return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Allows the level of trim for each servo channel to be adjusted progmatically. : :Parameters for macro SetTrim: : Channel : The channel to set the position for. First channel is zero. : Trim : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__servo0__SetTrim(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_TRIM) { if (FCL_CHANNEL < 1) { FCV_0fb1_v5__servo0__SERVO_TRIM[FCL_CHANNEL] = FCL_TRIM; // } else { } } /*=----------------------------------------------------------------------=*\ Use :Automatically moves towards the new position with a fixed rate of 100 steps per second. : :Parameters for macro AutoMoveToPosition: : Channel : The channel to set the position for. First channel is zero. : Position : Position to move to. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__servo0__AutoMoveToPosition(MX_UINT8 FCL_CHANNEL, MX_UINT8 FCL_POSITION) { if (FCL_CHANNEL < 1) { FCV_0fb1_v5__servo0__SERVO_REQUIRED[FCL_CHANNEL] = FCL_POSITION; // } else { } } /*=----------------------------------------------------------------------=*\ Use :Enables a servo channel effectivly setting the position of the motor to the value in the local position variable. : :Parameters for macro EnableServo: : Channel : The channel to set the position for. First channel is zero. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__servo0__EnableServo(MX_UINT8 FCL_CHANNEL) { //Local variable definitions MX_UINT8 FCL_DUMMY; if (FCL_CHANNEL < 1) { switch (FCL_CHANNEL) { case 1: { FCP_SET(A, 0x2, 0x1, 0); break; } case 2: { FCP_SET(A, 0x4, 0x2, 0); break; } case 3: { FCP_SET(A, 0x8, 0x3, 0); break; } case 4: { FCP_SET(A, 0x10, 0x4, 0); break; } case 5: { FCP_SET(A, 0x20, 0x5, 0); break; } case 6: { /* Error: Syntax error */; break; } case 7: { /* Error: Syntax error */; break; } default: { FCP_SET(D, 0x1, 0x0, 0); } } FCV_0fb1_v5__servo0__SERVO_ENABLED = FCV_0fb1_v5__servo0__SERVO_ENABLED | (0x01 << FCL_CHANNEL); // } else { } } /*=----------------------------------------------------------------------=*\ Use :Sets up the servo motor interrupts \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__servo0__Initialise() { FCV_0fb1_v5__servo0__SERVO_IDX = 0; while (FCV_0fb1_v5__servo0__SERVO_IDX < 8) { FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX] = 128; FCV_0fb1_v5__servo0__SERVO_REQUIRED[FCV_0fb1_v5__servo0__SERVO_IDX] = 128; FCV_0fb1_v5__servo0__SERVO_TRIM[FCV_0fb1_v5__servo0__SERVO_IDX] = 200; FCV_0fb1_v5__servo0__SERVO_IDX = FCV_0fb1_v5__servo0__SERVO_IDX + 1; } FCV_0fb1_v5__servo0__SERVO_IDX = 0; #if (1) // 1 > 0 #if (0) // 0 > 0 //Code has been optimised out by the pre-processor // #else #endif // #else //Code has been optimised out by the pre-processor #endif #if (0) // 1 > 1 //Code has been optimised out by the pre-processor // #else #endif #if (0) // 1 > 2 //Code has been optimised out by the pre-processor // #else #endif #if (0) // 1 > 3 //Code has been optimised out by the pre-processor // #else #endif #if (0) // 1 > 4 //Code has been optimised out by the pre-processor // #else #endif #if (0) // 1 > 5 //Code has been optimised out by the pre-processor // #else #endif #if (0) // 1 > 6 //Code has been optimised out by the pre-processor // #else #endif #if (0) // 1 > 7 //Code has been optimised out by the pre-processor // #else #endif #ifdef FC_CAL_ARM AT91F_TC2_CfgPMC(); AT91C_BASE_TC2->TC_CMR = (AT91C_TC_WAVE | AT91C_TC_CPCTRG | AT91C_TC_CLKS_TIMER_DIV2_CLOCK); AT91C_BASE_TC2->TC_CCR = (AT91C_TC_SWTRG | AT91C_TC_CLKEN); AT91C_BASE_TC2->TC_RC = MX_SERVO_PERIOD; AT91C_BASE_TC2->TC_CMR |= AT91C_TC_CLKI; AT91C_BASE_TC2->TC_IER = AT91C_TC_CPCS; AT91C_BASE_TC2->TC_IER = AT91C_TC_CPAS; #else #ifdef FC_CAL_PIC16BIT PR3 = MX_SERVO_CCPR1; #if (MX_CLKS_PER_INST == 2) PR3 = PR3 * 2; #endif T2CON = 0; //Stop TMR2 IFS0bits.T2IF = 0; //Clear interrupt IEC0bits.T2IE = 1; //Enable TMR2 interrupts T3CON = 0; //Stop TMR3 IFS0bits.T3IF = 0; //Clear interrupt TMR3 = 0; //Clear TMR3 IEC0bits.T3IE = 1; //Enable TMR3 interrupts T3CON = 0x8000; //Start TMR3 #else MX_SERVO_REG_CCPR1H = MX_SERVO_CCPR1H; //Set capture compare setpoint MX_SERVO_REG_CCPR1L = MX_SERVO_CCPR1L; MX_SERVO_REG_T1CON = MX_SERVO_T1CON; //Setup timer and start running MX_SERVO_REG_CCP1CON = MX_SERVO_CCP1CON; //Configure CCP1 settings st_bit(MX_SERVO_REG_CCP1EN, MX_SERVO_FLAG_CCP1EN); //Enable CCP1 interrupt MX_SERVO_REG_CCP2CON = MX_SERVO_CCP2CON; //Configure CCP2 settings st_bit(MX_SERVO_REG_CCP2EN, MX_SERVO_FLAG_CCP2EN); //Enable CCP2 interrupt st_bit(MX_SERVO_REG_INT, MX_SERVO_FLAG_PERIPH); //Enable Interrupts st_bit(MX_SERVO_REG_INT, MX_SERVO_FLAG_GLOB); #ifdef FC_CAL_AVR sei(); #endif #endif #endif } /*========================================================================*\ Use :dash_IO_flasher1 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_pwm1 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :v5__rc50 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro StateMC: : high_pulse : MX_UINT8 : wide_pulse : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__StateMC(MX_UINT8 FCL_HIGH_PULSE, MX_UINT8 FCL_WIDE_PULSE) { //Local variable definitions MX_UINT8 FCL_TRANSERROR = (0x1); if (FCL_WIDE_PULSE) { if (FCL_HIGH_PULSE) { if (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__M0) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__M1; FCL_TRANSERROR = 0; // } else { } } else { if (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__M1) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__M0; FCL_TRANSERROR = 0; // } else { } } } else { if (FCL_HIGH_PULSE) { if (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__M0) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__S0; FCL_TRANSERROR = 0; // } else { } if (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__S1) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__M1; FCL_TRANSERROR = 0; // } else { } } else { if (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__M1) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__S1; FCL_TRANSERROR = 0; // } else { } if (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__S0) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__M0; FCL_TRANSERROR = 0; // } else { } } } if (FCL_TRANSERROR) { FCD_0fb1_v5__rc50__Initialise_States(); } else { if ((FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__M0) || (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__M1)) { if (FCV_0fb1_v5__rc50__COUNT == 0) { FCV_0fb1_v5__rc50__PACKET = 0; // } else { } FCV_0fb1_v5__rc50__PACKET = FCV_0fb1_v5__rc50__PACKET << 1; if (FCV_0fb1_v5__rc50__STATE == FCV_0fb1_v5__rc50__M1) { FCV_0fb1_v5__rc50__PACKET = FCV_0fb1_v5__rc50__PACKET | 0x01; // } else { } FCV_0fb1_v5__rc50__COUNT = FCV_0fb1_v5__rc50__COUNT + 1; if (FCV_0fb1_v5__rc50__COUNT == 14) { if ((FCV_0fb1_v5__rc50__PACKET & 0x3000) == 0x3000) { FCV_0fb1_v5__rc50__COMMAND = FCV_0fb1_v5__rc50__PACKET & 0x3F; FCV_0fb1_v5__rc50__ADDRESS = (FCV_0fb1_v5__rc50__PACKET & 0x7C0) >> 6; FCV_0fb1_v5__rc50__TOGGLE = (FCV_0fb1_v5__rc50__PACKET & 0x800) >> 11; #if (0) // 0 == 1 //Code has been optimised out by the pre-processor #else FCV_0fb1_v5__rc50__UPDATE = 1; #endif // } else { } FCD_0fb1_v5__rc50__Initialise_States(); // } else { } // } else { } } } /*=----------------------------------------------------------------------=*\ Use :Retreives a value from the last successful RC5 reception. :0 = Read Command :1 = Read Address :2 = Read Toggle Bit : :Parameters for macro CollectData: : selection : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__rc50__CollectData(MX_UINT8 FCL_SELECTION) { //Local variable definitions MX_UINT8 FCR_RETVAL; switch (FCL_SELECTION) { case 0: { FCR_RETVAL = FCV_0fb1_v5__rc50__OUT_COMMAND; break; } case 1: { FCR_RETVAL = FCV_0fb1_v5__rc50__OUT_ADDRESS; break; } case 2: { FCR_RETVAL = FCV_0fb1_v5__rc50__OUT_TOGGLE; break; } default: { FCR_RETVAL = 0; } } return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__Initialise_States() { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__E0; FCV_0fb1_v5__rc50__COUNT = 0; #if (0) // 0 == 2 //Code has been optimised out by the pre-processor // #else #endif #if (0) // (0 == 1) || (0 == 1) //Code has been optimised out by the pre-processor // #else #endif } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__RXDisable() { #if (0) // 0 > 0 //Code has been optimised out by the pre-processor // #else #endif } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__Timer_Event() { //Local variable definitions MX_UINT8 FCL_TX_BIT; MX_UINT8 FCL_PULSELEVEL; MX_UINT8 FCL_TRANSERROR; if (FCV_0fb1_v5__rc50__TMR_TX_EN == 1) { if (FCV_0fb1_v5__rc50__TX_CYCLE == 0) { if (FCV_0fb1_v5__rc50__TX_COUNT) { FCL_TX_BIT = FCV_0fb1_v5__rc50__TXBUFF & 0x01; if (FCV_0fb1_v5__rc50__TX_HALF) { if (FCL_TX_BIT) { FCP_SET(A, 0x1, 0x0, 1); } else { FCP_SET(A, 0x1, 0x0, 0); } FCV_0fb1_v5__rc50__TX_HALF = 0; FCV_0fb1_v5__rc50__TXBUFF = FCV_0fb1_v5__rc50__TXBUFF >> 1; FCV_0fb1_v5__rc50__TX_COUNT = FCV_0fb1_v5__rc50__TX_COUNT - 1; } else { if (FCL_TX_BIT) { FCP_SET(A, 0x1, 0x0, 0); } else { FCP_SET(A, 0x1, 0x0, 1); } FCV_0fb1_v5__rc50__TX_HALF = 1; } } else { FCP_SET(A, 0x1, 0x0, 0); } // } else { } FCV_0fb1_v5__rc50__TX_CYCLE = (FCV_0fb1_v5__rc50__TX_CYCLE + 1) & 0x03; // } else { } if (FCV_0fb1_v5__rc50__TMR_RX_EN == 1) { TIMER_REGISTER = TIMER_PRE_VAL; if (FCV_0fb1_v5__rc50__INTCOUNT <= 23) { FCV_0fb1_v5__rc50__INTCOUNT = FCV_0fb1_v5__rc50__INTCOUNT + 1; // } else { } if (FCP_GET(C, 0x80, 0x7)) { FCL_PULSELEVEL = 1; } else { FCL_PULSELEVEL = 0; } #if (0) // 0 == 1 //Code has been optimised out by the pre-processor // #else #endif if (FCL_PULSELEVEL != FCV_0fb1_v5__rc50__XPULSELEVEL) { if (FCV_0fb1_v5__rc50__INTCOUNT > 23) { FCD_0fb1_v5__rc50__Initialise_States(); // } else { } if (FCV_0fb1_v5__rc50__COUNT == 0) { if (FCL_PULSELEVEL) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__M1; FCV_0fb1_v5__rc50__COUNT = 1; FCV_0fb1_v5__rc50__PACKET = 1; } else { FCD_0fb1_v5__rc50__Initialise_States(); } } else { if ((FCV_0fb1_v5__rc50__INTCOUNT >= 3) && (FCV_0fb1_v5__rc50__INTCOUNT <= 23)) { if (FCV_0fb1_v5__rc50__INTCOUNT > 11) { FCD_0fb1_v5__rc50__StateMC(FCL_PULSELEVEL, 1); } else { FCD_0fb1_v5__rc50__StateMC(FCL_PULSELEVEL, 0); } } else { FCD_0fb1_v5__rc50__Initialise_States(); } } FCV_0fb1_v5__rc50__XPULSELEVEL = FCL_PULSELEVEL; FCV_0fb1_v5__rc50__INTCOUNT = 0; // } else { } // } else { } } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro TXPacket: : command : MX_UINT8 : address : MX_UINT8 : toggle : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__TXPacket(MX_UINT8 FCL_COMMAND, MX_UINT8 FCL_ADDRESS, MX_UINT8 FCL_TOGGLE) { //Local variable definitions MX_UINT16 FCL_PACKET = (0x0); MX_UINT8 FCL_LOOP_DATA; MX_UINT8 FCL_LOOP_MODULATION; #if (0) // 0 > 0 //Code has been optimised out by the pre-processor // #else #endif } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__TXEnable() { FCD_0fb1_v5__rc50__RXDisable(); #if (0) // 0 > 0 //Code has been optimised out by the pre-processor // #else #endif } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__Signal_Edge() { //Local variable definitions MX_UINT8 FCL_TIMEOUT; MX_UINT8 FCL_PULSEWIDTH; MX_UINT8 FCL_PULSELEVEL; MX_UINT8 FCL_TRANSERROR; FCL_PULSEWIDTH = TIMER_REGISTER; TIMER_REGISTER = TIMER_PRE_VAL; #ifdef MX_CAL_PIC16BIT FCL_TIMEOUT = TIMER_FLAGREG.TIMER_FLAGBIT; #else FCL_TIMEOUT = ts_bit(TIMER_FLAGREG, TIMER_FLAGBIT); #endif #ifdef MX_CAL_AVR st_bit(TIMER_FLAGREG, TIMER_FLAGBIT); #else #ifdef MX_CAL_PIC16BIT TIMER_FLAGREG.TIMER_FLAGBIT = 0; #else cr_bit(TIMER_FLAGREG, TIMER_FLAGBIT); #endif #endif if (FCL_TIMEOUT) { FCD_0fb1_v5__rc50__Initialise_States(); // } else { } if (FCP_GET(C, 0x80, 0x7)) { FCL_PULSELEVEL = 1; } else { FCL_PULSELEVEL = 0; } #if (0) // 0 == 1 //Code has been optimised out by the pre-processor // #else #endif #ifdef MX_CAL_PIC if (ts_bit(INT_EDGEREG, INT_EDGEBIT)) cr_bit(INT_EDGEREG, INT_EDGEBIT); else st_bit(INT_EDGEREG, INT_EDGEBIT); #endif if (FCV_0fb1_v5__rc50__COUNT == 0) { if (FCL_PULSELEVEL) { FCV_0fb1_v5__rc50__STATE = FCV_0fb1_v5__rc50__M1; FCV_0fb1_v5__rc50__COUNT = 1; FCV_0fb1_v5__rc50__PACKET = 1; } else { FCD_0fb1_v5__rc50__Initialise_States(); } } else { if ((FCL_PULSEWIDTH >= 3) && (FCL_PULSEWIDTH <= 23)) { if (FCL_PULSEWIDTH > 11) { FCD_0fb1_v5__rc50__StateMC(FCL_PULSELEVEL, 1); } else { FCD_0fb1_v5__rc50__StateMC(FCL_PULSELEVEL, 0); } } else { FCD_0fb1_v5__rc50__Initialise_States(); } } } /*=----------------------------------------------------------------------=*\ Use :Checks to see if a new RC5 packet has been received. :Returns 0 to signify no new data available. :Returns 1 to signify there is new data available. : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__rc50__CheckRx() { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = 0; #if (0) //Code has been optimised out by the pre-processor // #else #endif if (FCV_0fb1_v5__rc50__UPDATE) { while (FCV_0fb1_v5__rc50__UPDATE) { FCV_0fb1_v5__rc50__UPDATE = 0; FCV_0fb1_v5__rc50__OUT_COMMAND = FCV_0fb1_v5__rc50__COMMAND; FCV_0fb1_v5__rc50__OUT_ADDRESS = FCV_0fb1_v5__rc50__ADDRESS; FCV_0fb1_v5__rc50__OUT_TOGGLE = FCV_0fb1_v5__rc50__TOGGLE; } FCR_RETVAL = 1; // } else { } return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__TXDisable() { //Local variable definitions MX_UINT8 FCL_DUMMY; #if (0) // 0 > 0 //Code has been optimised out by the pre-processor // #else #endif } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rc50__RXEnable() { //Local variable definitions MX_UINT8 FCL_DUMMY; #if (0) // 0 > 0 //Code has been optimised out by the pre-processor // #else #endif } /*========================================================================*\ Use :dash_IO_flasher :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_spi :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro Prv_TextConsole: : str[20] : MX_CHAR (by-ref) \*=----------------------------------------------------------------------=*/ void FCD_010fd_cal_spi__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR) { } /*========================================================================*\ Use :v5__spi_legacy0 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SendString: : Str[20] : MX_CHAR \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__SendString(MX_CHAR* PFCL_STR) { //Local variable definitions MX_UINT8 FCL_CH; MX_UINT8 FCL_IDX; MX_UINT8 FCL_LEN; #define FCLsz_STR 20 MX_CHAR FCL_STR[FCLsz_STR]; FCI_CONCATENATE(PFCL_STR,FCLsz_STR,"",0,FCL_STR,FCLsz_STR); FCL_LEN = FCI_GETLENGTH(FCL_STR, FCLsz_STR); FCL_IDX = 0; while (FCL_IDX < FCL_LEN) { FC_CAL_SPI_Master_Byte_2(FCL_STR[FCL_IDX]); FCL_IDX = FCL_IDX + 1; } //Local variable definitions #undef FCLsz_STR } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro NVMSendChar: : hi_addr : MX_UINT8 : lo_addr : MX_UINT8 : char : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__NVMSendChar(MX_UINT8 FCL_HI_ADDR, MX_UINT8 FCL_LO_ADDR, MX_UINT8 FCL_CHAR) { FCD_0fb1_v5__spi_legacy0__EnableFram(); FCD_0fb1_v5__spi_legacy0__FramOutput(FCV_0fb1_v5__spi_legacy0__FRAM_WREN); FCD_0fb1_v5__spi_legacy0__DisableFram(); //Comment: //Comment FCD_0fb1_v5__spi_legacy0__EnableFram(); FCD_0fb1_v5__spi_legacy0__FramOutput(FCV_0fb1_v5__spi_legacy0__FRAM_WRITE); FCD_0fb1_v5__spi_legacy0__FramOutput(FCL_HI_ADDR); FCD_0fb1_v5__spi_legacy0__FramOutput(FCL_LO_ADDR); FCD_0fb1_v5__spi_legacy0__FramOutput(FCL_CHAR); FCD_0fb1_v5__spi_legacy0__DisableFram(); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro GetString: : NumBytes : MX_UINT8 : Ch : MX_UINT8 : :Returns : MX_CHAR \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__GetString(MX_CHAR* FCR_RETVAL, MX_UINT16 FCRsz_RETVAL, MX_UINT8 FCL_NUMBYTES, MX_UINT8 FCL_CH) { //Local variable definitions FCI_SCOPY("",0, FCR_RETVAL,FCRsz_RETVAL); while (FCL_NUMBYTES) { FCL_CH = FC_CAL_SPI_Master_Byte_2(0x55); FCI_SHEAD(FCR_RETVAL,FCRsz_RETVAL, &FCL_CH,1, FCR_RETVAL,FCRsz_RETVAL); FCL_NUMBYTES = FCL_NUMBYTES - 1; } } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro DACSendChar: : Char : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__DACSendChar(MX_UINT8 FCL_CHAR) { //Local variable definitions MX_UINT8 FCL_DAC_VAL; FCP_SET(B, 0x80, 0x7, 0); FCL_DAC_VAL = FCL_CHAR >> 4; FC_CAL_SPI_Master_Byte_2(FCL_DAC_VAL); FCL_DAC_VAL = FCL_CHAR << 4; FC_CAL_SPI_Master_Byte_2(FCL_DAC_VAL); FCP_SET(B, 0x80, 0x7, 1); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SendChar: : Char : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__SendChar(MX_UINT8 FCL_CHAR) { FC_CAL_SPI_Master_Byte_2(FCL_CHAR); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro NVMGetChar: : hi_addr : MX_UINT8 : lo_addr : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__spi_legacy0__NVMGetChar(MX_UINT8 FCL_HI_ADDR, MX_UINT8 FCL_LO_ADDR) { //Local variable definitions MX_UINT8 FCR_RETVAL; FCD_0fb1_v5__spi_legacy0__EnableFram(); FCD_0fb1_v5__spi_legacy0__FramOutput(FCV_0fb1_v5__spi_legacy0__FRAM_READ); FCD_0fb1_v5__spi_legacy0__FramOutput(FCL_HI_ADDR); FCD_0fb1_v5__spi_legacy0__FramOutput(FCL_LO_ADDR); FCR_RETVAL = FCD_0fb1_v5__spi_legacy0__FramOutput(0x5A); FCD_0fb1_v5__spi_legacy0__DisableFram(); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__EnableFram() { FCP_SET(B, 0x40, 0x6, 0); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro FramOutput: : Char : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__spi_legacy0__FramOutput(MX_UINT8 FCL_CHAR) { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = FC_CAL_SPI_Master_Byte_2(FCL_CHAR); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__DisableFram() { FCP_SET(B, 0x40, 0x6, 1); } /*=----------------------------------------------------------------------=*\ Use :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__spi_legacy0__GetChar() { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = FC_CAL_SPI_Master_Byte_2(0x55); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__UnInitialise() { FC_CAL_SPI_Master_Uninit_2(); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__spi_legacy0__Initialise() { FCP_SET(B, 0x80, 0x7, 1); FCP_SET(B, 0x40, 0x6, 1); FC_CAL_SPI_Master_Init_2(); } /*========================================================================*\ Use :InjectorBase1 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_can :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro Prv_TextConsole: : str[20] : MX_CHAR (by-ref) \*=----------------------------------------------------------------------=*/ void FC_CAL_Internal_CAN_Prv_TextConsole_1(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR) { } /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_spi :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro Prv_TextConsole: : str[20] : MX_CHAR (by-ref) \*=----------------------------------------------------------------------=*/ void FCD_010dd_cal_spi__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR) { } /*========================================================================*\ Use :v5__can0 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Returns switch input states :(External CAN only) : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_ReadSwitches_1() { //Local variable definitions MX_UINT8 FCR_RETVAL; #if (1) // 0 == 0 FCR_RETVAL = FC_CAN_SPI_CAN_Read_1(FCV_0fb1_v5__can0__CAN_TXRTSCTRL); FCR_RETVAL = FCR_RETVAL & 0x38; FCR_RETVAL = FCR_RETVAL >> 3; // #else //Code has been optimised out by the pre-processor #endif return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :sends command and gets reply : :Parameters for macro SPI_CAN_Status: : Command : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_SPI_CAN_Status_1(MX_UINT8 FCL_COMMAND) { //Local variable definitions MX_UINT8 FCR_RETVAL; FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCL_COMMAND); FCR_RETVAL = FC_CAL_SPI_Master_Byte_1(0x5a); FC_CAN_SPI_CS_Disable_1(); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SetTxData: : Buffer : MX_UINT8 : Count : MX_UINT8 : d0 : MX_UINT8 : d1 : MX_UINT8 : d2 : MX_UINT8 : d3 : MX_UINT8 : d4 : MX_UINT8 : d5 : MX_UINT8 : d6 : MX_UINT8 : d7 : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetTxData_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_COUNT, MX_UINT8 FCL_D0, MX_UINT8 FCL_D1, MX_UINT8 FCL_D2, MX_UINT8 FCL_D3, MX_UINT8 FCL_D4, MX_UINT8 FCL_D5, MX_UINT8 FCL_D6, MX_UINT8 FCL_D7) { //Local variable definitions MX_UINT8 FCL_N; #if (0) //Code has been optimised out by the pre-processor #else //Comment: //Transfer data to External CAN Tx Buffer via SPI if ((FCL_BUFFER < 3) & (FCL_COUNT < 9)) { FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_WRITE); FC_CAL_SPI_Master_Byte_1((FCL_BUFFER * 0x10) + 0x35); FC_CAL_SPI_Master_Byte_1(FCL_COUNT); FCL_N = 0; while (FCL_N < FCL_COUNT) { switch (FCL_N) { case 1: { FC_CAL_SPI_Master_Byte_1(FCL_D1); break; } case 2: { FC_CAL_SPI_Master_Byte_1(FCL_D2); break; } case 3: { FC_CAL_SPI_Master_Byte_1(FCL_D3); break; } case 4: { FC_CAL_SPI_Master_Byte_1(FCL_D4); break; } case 5: { FC_CAL_SPI_Master_Byte_1(FCL_D5); break; } case 6: { FC_CAL_SPI_Master_Byte_1(FCL_D6); break; } case 7: { FC_CAL_SPI_Master_Byte_1(FCL_D7); break; } default: { FC_CAL_SPI_Master_Byte_1(FCL_D0); } } FCL_N = FCL_N + 1; } FC_CAN_SPI_CS_Disable_1(); // } else { } #endif } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SPI_CAN_Command: : Command : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CAN_Command_1(MX_UINT8 FCL_COMMAND) { FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCL_COMMAND); FC_CAN_SPI_CS_Disable_1(); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SetRxMask: : Mask : MX_UINT8 : ID : MX_UINT32 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetRxMask_1(MX_UINT8 FCL_MASK, MX_UINT32 FCL_ID) { //Local variable definitions MX_UINT8 FCL_ADDRESS; #if (0) //Code has been optimised out by the pre-processor #else //Comment: //send the Mask ID to the CAN via SPI if (FCL_MASK < 2) { FCV_0fb1_v5__can0__CAN_MSG_ID = FCL_ID; FC_CAN_ID_to_IDB_1(); if (FCL_MASK == 0) { FCL_ADDRESS = 0x20; } else { FCL_ADDRESS = 0x24; } FC_CAN_SPI_CAN_WriteIDB_1(FCL_ADDRESS); } else { } #endif } /*=----------------------------------------------------------------------=*\ Use :Returns last received message data byte at position Index. :Buffer parameter is currently ignored : :Parameters for macro GetRxData: : Buffer : MX_UINT8 : Index : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_GetRxData_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_INDEX) { //Local variable definitions MX_UINT8 FCR_RETVAL; #if (0) //Code has been optimised out by the pre-processor #else if (FCL_INDEX < 8) { FCR_RETVAL = FCV_0fb1_v5__can0__CAN_MSG_DATA[FCL_INDEX]; } else { FCR_RETVAL = 0; } #endif return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :changes CAN chip mode : :Parameters for macro SPI_CAN_Config: : cfg : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CAN_Config_1(MX_UINT8 FCL_CFG) { //Local variable definitions MX_UINT8 FCL_MODE; MX_UINT16 FCL_TIMEOUT = (0x0); while (1) { FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_CANCTRL, FCL_CFG); FCI_DELAYBYTE_MS(1); FCL_MODE = FC_CAN_SPI_CAN_Read_1(FCV_0fb1_v5__can0__CAN_CANSTAT); FCI_DELAYBYTE_MS(1); FCL_TIMEOUT = FCL_TIMEOUT + 1; if (FCL_TIMEOUT > 0x100) { goto FCC_SPI_CAN_Config_A; // } else { } if (((FCL_MODE & 0xE0) != FCL_CFG) == 0) break; } FCC_SPI_CAN_Config_A: ; } /*=----------------------------------------------------------------------=*\ Use :Gets the Hi byte Rx ID :Buffer not used. : :Parameters for macro GetRxIDHi: : Buffer : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_GetRxIDHi_1(MX_UINT8 FCL_BUFFER) { //Local variable definitions MX_UINT8 FCR_RETVAL; #if (0) //Code has been optimised out by the pre-processor // #else #endif FCR_RETVAL = FCV_0fb1_v5__can0__CAN_MSG_IDB[0]; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Set the Tx CAN ID, Standard only, and in chip register format : :Parameters for macro SetTxIDSimple: : Buffer : MX_UINT8 : ID : MX_UINT16 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetTxIDSimple_1(MX_UINT8 FCL_BUFFER, MX_UINT16 FCL_ID) { //Local variable definitions MX_UINT8 FCL_HI; MX_UINT8 FCL_LO; FCL_LO = FCL_ID << 5; FCL_HI = FCL_ID >> 3; FC_CAN_SetTxID_1(FCL_BUFFER, FCL_HI, FCL_LO); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SendBuffer: : Buffer : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SendBuffer_1(MX_UINT8 FCL_BUFFER) { #if (0) //Code has been optimised out by the pre-processor #else switch (FCL_BUFFER) { case 0: { FC_CAN_SPI_CAN_Command_1(FCV_0fb1_v5__can0__CAN_RTS_TXB0); break; } case 1: { FC_CAN_SPI_CAN_Command_1(FCV_0fb1_v5__can0__CAN_RTS_TXB1); break; } case 2: { FC_CAN_SPI_CAN_Command_1(FCV_0fb1_v5__can0__CAN_RTS_TXB2); break; } default: { } } #endif } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SPI_CAN_BitModify: : addr : MX_UINT8 : mask : MX_UINT8 : data : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CAN_BitModify_1(MX_UINT8 FCL_ADDR, MX_UINT8 FCL_MASK, MX_UINT8 FCL_DATA) { FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_BIT_MODIFY); FC_CAL_SPI_Master_Byte_1(FCL_ADDR); FC_CAL_SPI_Master_Byte_1(FCL_MASK); FC_CAL_SPI_Master_Byte_1(FCL_DATA); FC_CAN_SPI_CS_Disable_1(); } /*=----------------------------------------------------------------------=*\ Use :Disable the Chip Select for the external CAN device \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CS_Disable_1() { #if (0) //Code has been optimised out by the pre-processor #else FCP_SET(C, 0x40, 0x6, 1); #endif } /*=----------------------------------------------------------------------=*\ Use :Converts U8 register array in CAN_MSG_IDB into U32 CAN_MSG_ID :IDE bit of IDB[1] determines Std or Ext ID format :This hidden function only used for External MCP2515, :CAN CAL does its own bit mapping for registers \*=----------------------------------------------------------------------=*/ void FC_CAN_IDB_to_ID_1() { if (FCV_0fb1_v5__can0__CAN_MSG_IDB[1] & 8) { //Comment: //Extended Identifier FCV_0fb1_v5__can0__CAN_MSG_ID = FCV_0fb1_v5__can0__CAN_MSG_IDB[0] << 15; FCV_0fb1_v5__can0__CAN_MSG_ID = FCV_0fb1_v5__can0__CAN_MSG_ID | ((FCV_0fb1_v5__can0__CAN_MSG_IDB[1] & 0xE0) << 13); FCV_0fb1_v5__can0__CAN_MSG_ID = FCV_0fb1_v5__can0__CAN_MSG_ID | ((FCV_0fb1_v5__can0__CAN_MSG_IDB[1] & 0x03) << 16); FCV_0fb1_v5__can0__CAN_MSG_ID = FCV_0fb1_v5__can0__CAN_MSG_ID | (FCV_0fb1_v5__can0__CAN_MSG_IDB[2] << 8); FCV_0fb1_v5__can0__CAN_MSG_ID = FCV_0fb1_v5__can0__CAN_MSG_ID | FCV_0fb1_v5__can0__CAN_MSG_IDB[3]; } else { //Comment: //Standard Identifier FCV_0fb1_v5__can0__CAN_MSG_ID = (FCV_0fb1_v5__can0__CAN_MSG_IDB[0] << 3) | ((FCV_0fb1_v5__can0__CAN_MSG_IDB[1] >> 5) & 7); } } /*=----------------------------------------------------------------------=*\ Use :read the Rx message ID from Buffer (0 or 1) : :Parameters for macro SPI_CAN_ReadIDB: : Buffer : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CAN_ReadIDB_1(MX_UINT8 FCL_BUFFER) { //Local variable definitions MX_UINT8 FCL_COMMAND; MX_UINT8 FCL_N; if (FCL_BUFFER == 0) { FCL_COMMAND = 0x90; } else { FCL_COMMAND = 0x94; } FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCL_COMMAND); FCL_N = 0; while (FCL_N < 4) { FCV_0fb1_v5__can0__CAN_MSG_IDB[FCL_N] = FC_CAL_SPI_Master_Byte_1(0x5a); FCL_N = FCL_N + 1; } FC_CAN_SPI_CS_Disable_1(); } /*=----------------------------------------------------------------------=*\ Use :Returns last received message data length. :Buffer parameter is currently ignored : :Parameters for macro GetRxDataCount: : Buffer : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_GetRxDataCount_1(MX_UINT8 FCL_BUFFER) { //Local variable definitions MX_UINT8 FCR_RETVAL; #if (0) //Code has been optimised out by the pre-processor #else FCR_RETVAL = FCV_0fb1_v5__can0__CAN_MSG_DLC; #endif return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :sets the Filter :Standard mode only :(for V5 compatibility only) : :Parameters for macro SetRxFilterID: : Filter : MX_UINT8 : Hi : MX_UINT8 : Lo : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetRxFilterID_1(MX_UINT8 FCL_FILTER, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO) { //Local variable definitions MX_UINT8 FCL_ADDRESS; #if (0) //Code has been optimised out by the pre-processor #else if (FCL_FILTER < 6) { FCL_ADDRESS = FCL_FILTER * 4; if (FCL_FILTER < 3) { } else { FCL_ADDRESS = FCL_ADDRESS + 4; } FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_CONFIG); FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_WRITE); FC_CAL_SPI_Master_Byte_1(FCL_ADDRESS); FC_CAL_SPI_Master_Byte_1(FCL_HI); FC_CAL_SPI_Master_Byte_1(FCL_LO); FC_CAL_SPI_Master_Byte_1(0xff); FC_CAL_SPI_Master_Byte_1(0xff); FC_CAN_SPI_CS_Disable_1(); FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_NORMAL); // } else { } #endif } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SPI_CAN_Write: : addr : MX_UINT8 : data : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CAN_Write_1(MX_UINT8 FCL_ADDR, MX_UINT8 FCL_DATA) { FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_WRITE); FC_CAL_SPI_Master_Byte_1(FCL_ADDR); FC_CAL_SPI_Master_Byte_1(FCL_DATA); FC_CAN_SPI_CS_Disable_1(); } /*=----------------------------------------------------------------------=*\ Use :Enable the Chip Select for the external CAN device \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CS_Enable_1() { #if (0) //Code has been optimised out by the pre-processor #else FCP_SET(C, 0x40, 0x6, 0); #endif } /*=----------------------------------------------------------------------=*\ Use :Convert U32 CAN_MSG_ID into U8 register array in CAN_MSG_IDB :Bit mapping depends upon ID Type: Std/Ext :This internal function only used for External MCP2515, :CAN CAL does its own bit mapping for registers \*=----------------------------------------------------------------------=*/ void FC_CAN_ID_to_IDB_1() { #if (0) //Code has been optimised out by the pre-processor #else FCV_0fb1_v5__can0__CAN_MSG_IDB[0] = FCV_0fb1_v5__can0__CAN_MSG_ID >> 3; FCV_0fb1_v5__can0__CAN_MSG_IDB[1] = FCV_0fb1_v5__can0__CAN_MSG_ID << 5; FCV_0fb1_v5__can0__CAN_MSG_IDB[2] = 0; FCV_0fb1_v5__can0__CAN_MSG_IDB[3] = 0; #endif } /*=----------------------------------------------------------------------=*\ Use :Gets the Lo byte Rx ID :Buffer not used. : :Parameters for macro GetRxIDLo: : Buffer : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_GetRxIDLo_1(MX_UINT8 FCL_BUFFER) { //Local variable definitions MX_UINT8 FCR_RETVAL; #if (0) //Code has been optimised out by the pre-processor // #else #endif FCR_RETVAL = FCV_0fb1_v5__can0__CAN_MSG_IDB[1]; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :set the Mask :Standard ID mode only :(for V5 compatibility) : :Parameters for macro SetRxMaskID: : Mask : MX_UINT8 : Hi : MX_UINT8 : Lo : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetRxMaskID_1(MX_UINT8 FCL_MASK, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO) { //Local variable definitions MX_UINT8 FCL_ADDRESS; #if (0) //Code has been optimised out by the pre-processor #else if (FCL_MASK < 2) { FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_CONFIG); //Comment: //point to the External MCP2515 //address of the MASK 0 or 1 registers if (FCL_MASK) { FCL_ADDRESS = 0x24; } else { FCL_ADDRESS = 0x20; } FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_WRITE); FC_CAL_SPI_Master_Byte_1(FCL_ADDRESS); FC_CAL_SPI_Master_Byte_1(FCL_HI); FC_CAL_SPI_Master_Byte_1(FCL_LO); FC_CAL_SPI_Master_Byte_1(0xff); FC_CAL_SPI_Master_Byte_1(0xff); FC_CAN_SPI_CS_Disable_1(); FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_NORMAL); // } else { } #endif } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SetRxFilter: : Filter : MX_UINT8 : ID : MX_UINT32 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetRxFilter_1(MX_UINT8 FCL_FILTER, MX_UINT32 FCL_ID) { //Local variable definitions MX_UINT8 FCL_ADDRESS; #if (0) //Code has been optimised out by the pre-processor #else //Comment: //send the filter ID to the CAN via SPI if (FCL_FILTER < 6) { FCV_0fb1_v5__can0__CAN_MSG_ID = FCL_ID; FC_CAN_ID_to_IDB_1(); if (FCL_FILTER < 3) { FCL_ADDRESS = FCL_FILTER * 4; } else { FCL_ADDRESS = (FCL_FILTER * 4) + 4; } FC_CAN_SPI_CAN_WriteIDB_1(FCL_ADDRESS); } else { } #endif } /*=----------------------------------------------------------------------=*\ Use :set the Tx message ID for Buffer : :Parameters for macro SetTxIdent: : Buffer : MX_UINT8 : ID : MX_UINT32 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetTxIdent_1(MX_UINT8 FCL_BUFFER, MX_UINT32 FCL_ID) { //Local variable definitions MX_UINT8 FCL_ADDRESS; #if (0) //Code has been optimised out by the pre-processor #else //Comment: //send the Tx ID to the CAN via SPI if (FCL_BUFFER < 3) { FCV_0fb1_v5__can0__CAN_MSG_ID = FCL_ID; FC_CAN_ID_to_IDB_1(); FCL_ADDRESS = 0x31 + (FCL_BUFFER * 0x10); FC_CAN_SPI_CAN_WriteIDB_1(FCL_ADDRESS); } else { } #endif } /*=----------------------------------------------------------------------=*\ Use :Checks to see if any messages are available for 'Buffer' specified : :Parameters for macro CheckRx: : Buffer : Send buffer: 0 to 1 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_CheckRx_1(MX_UINT8 FCL_BUFFER) { //Local variable definitions MX_UINT8 FCL_N; MX_UINT8 FCL_COMMAND; MX_UINT8 FCR_RETVAL; #if (0) //Code has been optimised out by the pre-processor #else FCR_RETVAL = FC_CAN_SPI_CAN_Status_1(FCV_0fb1_v5__can0__CAN_RX_STATUS); switch (FCL_BUFFER) { case 0: { FCR_RETVAL = FCR_RETVAL & 0x40; break; } case 1: { FCR_RETVAL = FCR_RETVAL & 0x80; break; } default: { FCR_RETVAL = 0; } } if (FCR_RETVAL) { //Comment: //get the data via SPI into local buffer if (FCL_BUFFER == 0) { FCL_COMMAND = 0x90; } else { FCL_COMMAND = 0x94; } FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCL_COMMAND); FCL_N = 0; while (FCL_N < 4) { FCV_0fb1_v5__can0__CAN_MSG_IDB[FCL_N] = FC_CAL_SPI_Master_Byte_1(0x5a); FCL_N = FCL_N + 1; } FCV_0fb1_v5__can0__CAN_MSG_DLC = FC_CAL_SPI_Master_Byte_1(0x5a); FCL_N = 0; while ((FCL_N < 8) & (FCL_N < FCV_0fb1_v5__can0__CAN_MSG_DLC)) { FCV_0fb1_v5__can0__CAN_MSG_DATA[FCL_N] = FC_CAL_SPI_Master_Byte_1(0x5a); FCL_N = FCL_N + 1; } FC_CAN_SPI_CS_Disable_1(); FCR_RETVAL = 1; // } else { } #endif return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SPI_CAN_Read: : addr : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FC_CAN_SPI_CAN_Read_1(MX_UINT8 FCL_ADDR) { //Local variable definitions MX_UINT8 FCR_RETVAL; FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_READ); FC_CAL_SPI_Master_Byte_1(FCL_ADDR); FCR_RETVAL = FC_CAL_SPI_Master_Byte_1(0x5a); FC_CAN_SPI_CS_Disable_1(); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Gets the Rx ID as a Integer : :Parameters for macro GetRxIDSimple: : Buffer : MX_UINT8 : :Returns : MX_UINT16 \*=----------------------------------------------------------------------=*/ MX_UINT16 FC_CAN_GetRxIDSimple_1(MX_UINT8 FCL_BUFFER) { //Local variable definitions MX_UINT8 FCL_HI; MX_UINT8 FCL_LO; MX_UINT16 FCR_RETVAL; FCL_LO = FC_CAN_GetRxIDLo_1(FCL_BUFFER); FCL_HI = FC_CAN_GetRxIDHi_1(FCL_BUFFER); FCR_RETVAL = (FCL_LO >> 5) || (FCL_HI << 3); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Set the Tx CAN ID, Standard only, and in chip register format : :Parameters for macro SetTxID: : Buffer : MX_UINT8 : Hi : MX_UINT8 : Lo : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SetTxID_1(MX_UINT8 FCL_BUFFER, MX_UINT8 FCL_HI, MX_UINT8 FCL_LO) { #if (0) //Code has been optimised out by the pre-processor #else FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_WRITE); FC_CAL_SPI_Master_Byte_1((FCL_BUFFER * 0x10) + 0x31); FC_CAL_SPI_Master_Byte_1(FCL_HI); FC_CAL_SPI_Master_Byte_1(FCL_LO); FC_CAN_SPI_CS_Disable_1(); #endif } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SPI_CAN_WriteIDB: : address : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CAN_WriteIDB_1(MX_UINT8 FCL_ADDRESS) { FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_CONFIG); FC_CAN_SPI_CS_Enable_1(); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_WRITE); FC_CAL_SPI_Master_Byte_1(FCL_ADDRESS); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_MSG_IDB[0]); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_MSG_IDB[1]); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_MSG_IDB[2]); FC_CAL_SPI_Master_Byte_1(FCV_0fb1_v5__can0__CAN_MSG_IDB[3]); FC_CAN_SPI_CS_Disable_1(); FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_NORMAL); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FC_CAN_SPI_CAN_Init_1() { //Comment: //setup the initial values for MCP2515 Registers //Comment: //setup RX Buffer 0 Mask and Filters switch (2) { case 1: { //Comment: //Use Mask and Filters #if (0) //Code has been optimised out by the pre-processor #else FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_RXB0CTRL, 0x20); #endif FC_CAN_SetRxMask_1(0, 2047); FC_CAN_SetRxFilter_1(0, 697); FC_CAN_SetRxFilter_1(1, 2047); break; } case 2: { //Comment: //Accept All FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_RXB0CTRL, 0x60); break; } default: { //Comment: //Reject All #if (0) //Code has been optimised out by the pre-processor #else FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_RXB0CTRL, 0x40); #endif FC_CAN_SetRxMask_1(0, 0x1fffffff); FC_CAN_SetRxFilter_1(0, 697); FC_CAN_SetRxFilter_1(1, 2047); } } //Comment: //setup RX Buffer 1 Mask and Filters switch (2) { case 1: { //Comment: //Use Mask and Filters #if (0) //Code has been optimised out by the pre-processor #else FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_RXB1CTRL, 0x20); #endif FC_CAN_SetRxMask_1(1, 2047); FC_CAN_SetRxFilter_1(2, 704); FC_CAN_SetRxFilter_1(3, 2047); FC_CAN_SetRxFilter_1(4, 2047); FC_CAN_SetRxFilter_1(5, 2047); break; } case 2: { //Comment: //Accept All FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_RXB1CTRL, 0x60); break; } default: { //Comment: //Reject All #if (0) //Code has been optimised out by the pre-processor #else FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_RXB1CTRL, 0x40); #endif FC_CAN_SetRxMask_1(1, 0x1fffffff); FC_CAN_SetRxFilter_1(2, 704); FC_CAN_SetRxFilter_1(3, 2047); FC_CAN_SetRxFilter_1(4, 2047); FC_CAN_SetRxFilter_1(5, 2047); } } //Comment: //setup TX Buffers FC_CAN_SetTxData_1(0, 2, 85, 170, 0, 0, 0, 0, 0, 0); FC_CAN_SetTxIdent_1(0, 688); FC_CAN_SetTxData_1(1, 7, 9, 8, 7, 6, 5, 4, 3, 2); FC_CAN_SetTxIdent_1(1, 704); FC_CAN_SetTxData_1(2, 0, 0, 0, 0, 0, 0, 0, 0, 0); FC_CAN_SetTxIdent_1(2, 720); //Comment: //setup CNF and control registers FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_CONFIG); FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_CNF1, 7); FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_CNF2, 209); FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_CNF3, 3); FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_TXRTSCTRL, 0); FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_EFLG, 0); FC_CAN_SPI_CAN_Write_1(FCV_0fb1_v5__can0__CAN_CANCTRL, 0x80); FC_CAN_SPI_CAN_Config_1(FCV_0fb1_v5__can0__CAN_REQOP_NORMAL); } /*=----------------------------------------------------------------------=*\ Use :Set LED state :(External CAN only) : :Parameters for macro ShowLEDs: : led1 : MX_UINT8 : led2 : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FC_CAN_ShowLEDs_1(MX_UINT8 FCL_LED1, MX_UINT8 FCL_LED2) { //Local variable definitions MX_UINT8 FCL_DATA; #if (1) // 0 == 0 FCL_DATA = 0; if (FCL_LED1) { FCL_DATA = FCL_DATA | 0x10; // } else { } if (FCL_LED2) { FCL_DATA = FCL_DATA | 0x20; // } else { } FC_CAN_SPI_CAN_BitModify_1(FCV_0fb1_v5__can0__CAN_BFPCTRL, 0x30, FCL_DATA); // #else //Code has been optimised out by the pre-processor #endif } /*=----------------------------------------------------------------------=*\ Use :Get the Rx message ID for Buffer : :Parameters for macro GetRxIdent: : Buffer : MX_UINT8 : :Returns : MX_UINT32 \*=----------------------------------------------------------------------=*/ MX_UINT32 FC_CAN_GetRxIdent_1(MX_UINT8 FCL_BUFFER) { //Local variable definitions MX_UINT8 FCL_ADDRESS; MX_UINT32 FCR_RETVAL; #if (0) //Code has been optimised out by the pre-processor #else //Comment: //get the Rx message ID from the CAN via SPI if (FCL_BUFFER < 2) { FC_CAN_SPI_CAN_ReadIDB_1(FCL_BUFFER); FC_CAN_IDB_to_ID_1(); FCR_RETVAL = FCV_0fb1_v5__can0__CAN_MSG_ID; } else { } #endif return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Must be called at least once and after every Uninit call to enable the CAN instance \*=----------------------------------------------------------------------=*/ void FC_CAN_Initialise_1() { #if (0) //Code has been optimised out by the pre-processor #else FC_CAN_SPI_CS_Disable_1(); FC_CAL_SPI_Master_Init_1(); FCI_DELAYBYTE_MS(50); FC_CAN_SPI_CAN_Init_1(); #endif } /*========================================================================*\ Use :dash_IO_flasher :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_i2c :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro Prv_TextConsole: : str[20] : MX_CHAR (by-ref) \*=----------------------------------------------------------------------=*/ void FCD_01075_cal_i2c__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR) { } /*========================================================================*\ Use :v5__i2c_master0 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro ReceiveByte: : Last : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__i2c_master0__ReceiveByte(MX_UINT8 FCL_LAST) { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = FC_CAL_I2C_Master_RxByte_1(FCL_LAST); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__i2c_master0__Restart() { FC_CAL_I2C_Master_Restart_1(); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__i2c_master0__Stop() { FC_CAL_I2C_Master_Stop_1(); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro ReceiveByteTransaction: : Device_ID : MX_UINT8 : AddrH : MX_UINT8 : AddrL : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__i2c_master0__ReceiveByteTransaction(MX_UINT8 FCL_DEVICE_ID, MX_UINT8 FCL_ADDRH, MX_UINT8 FCL_ADDRL) { //Local variable definitions MX_UINT8 FCR_RETVAL; FCL_DEVICE_ID = FCL_DEVICE_ID << 1; FC_CAL_I2C_Master_Start_1(); FC_CAL_I2C_Master_TxByte_1(FCL_DEVICE_ID); FC_CAL_I2C_Master_TxByte_1(FCL_ADDRH); FC_CAL_I2C_Master_TxByte_1(FCL_ADDRL); FC_CAL_I2C_Master_Restart_1(); FCL_DEVICE_ID = FCL_DEVICE_ID | 0x01; FC_CAL_I2C_Master_TxByte_1(FCL_DEVICE_ID); FCR_RETVAL = FC_CAL_I2C_Master_RxByte_1(0x01); FC_CAL_I2C_Master_Stop_1(); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro TransmitByte: : Data : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__i2c_master0__TransmitByte(MX_UINT8 FCL_DATA) { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = FC_CAL_I2C_Master_TxByte_1(FCL_DATA); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SendByteTransaction: : Device_ID : MX_UINT8 : AddrH : MX_UINT8 : AddrL : MX_UINT8 : Data : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__i2c_master0__SendByteTransaction(MX_UINT8 FCL_DEVICE_ID, MX_UINT8 FCL_ADDRH, MX_UINT8 FCL_ADDRL, MX_UINT8 FCL_DATA) { FCL_DEVICE_ID = FCL_DEVICE_ID << 1; FC_CAL_I2C_Master_Start_1(); FC_CAL_I2C_Master_TxByte_1(FCL_DEVICE_ID); FC_CAL_I2C_Master_TxByte_1(FCL_ADDRH); FC_CAL_I2C_Master_TxByte_1(FCL_ADDRL); FC_CAL_I2C_Master_TxByte_1(FCL_DATA); FC_CAL_I2C_Master_Stop_1(); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__i2c_master0__Start() { FC_CAL_I2C_Master_Start_1(); } /*=----------------------------------------------------------------------=*\ Use : \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__i2c_master0__Initialise() { FC_CAL_I2C_Master_Init_1(); } /*========================================================================*\ Use :lut_CRC :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :v5__one_wire0 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :DS1820 device specific function :Commands all sensors to start a temperature conversion : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__DS1820_StartConversion() { //Local variable definitions MX_UINT8 FCL_IN = (0x0); MX_UINT8 FCL_COUNTER = (0x0); MX_UINT8 FCR_RETVAL; FCD_0fb1_v5__one_wire0__BusReset(); FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__OO_SKIPROM); FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__OO_CONVERTT); while (FCL_IN == 0) { FCL_IN = FCD_0fb1_v5__one_wire0__ReceiveByte(); FCI_DELAYBYTE_MS(4); FCL_COUNTER = FCL_COUNTER + 1; if (FCL_COUNTER == 255) { FCR_RETVAL = 1; goto FCC_DS1820_StartConversion_A; // } else { } } FCR_RETVAL = 0; FCC_DS1820_StartConversion_A: ; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__ReceiveByte() { //Local variable definitions MX_UINT8 FCL_COUNTER = (0x0); MX_UINT8 FCL_BIT = (0x0); MX_UINT8 FCR_RETVAL; FCR_RETVAL = 0; while (FCL_COUNTER < 8) { FCL_BIT = FCD_0fb1_v5__one_wire0__Receive_Bit(); FCR_RETVAL = FCR_RETVAL >> 1; if (FCL_BIT) { FCR_RETVAL = FCR_RETVAL | 0x80; // } else { } FCL_COUNTER = FCL_COUNTER + 1; } #if (0) //Code has been optimised out by the pre-processor // #else #endif return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro TransmitByte: : Command : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__one_wire0__TransmitByte(MX_UINT8 FCL_COMMAND) { //Local variable definitions MX_UINT8 FCL_COUNTER = (0x0); while (FCL_COUNTER < 8) { FCD_0fb1_v5__one_wire0__Transmit_Bit(FCL_COMMAND & 0x01); FCL_COMMAND = FCL_COMMAND >> 1; FCL_COUNTER = FCL_COUNTER + 1; } } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro GetPadByte: : Index : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__GetPadByte(MX_UINT8 FCL_INDEX) { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = FCV_0fb1_v5__one_wire0__SCRATCHPAD[FCL_INDEX]; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Initialise the CRC working register to be able to start a new calculation \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__one_wire0__CRC_Init() { #if (0) //Code has been optimised out by the pre-processor // #else #endif } /*=----------------------------------------------------------------------=*\ Use :Issue a 'ping' on the bus. If there is at least one sensor on the bus then it will generate a presence pulse. : :Returns 0 if a presense pulse was detected :Returns 1 no device was detected : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__BusReset() { //Local variable definitions MX_UINT8 FCL_DUMMY; MX_UINT8 FCR_RETVAL; FCL_DUMMY = FCP_GET(A, 0x80, 0x7); FCI_DELAYBYTE_US(100); FCP_SET(A, 0x80, 0x7, 0); FCI_DELAYBYTE_US(200); FCI_DELAYBYTE_US(200); FCI_DELAYBYTE_US(200); FCL_DUMMY = FCP_GET(A, 0x80, 0x7); FCI_DELAYBYTE_US(60); FCL_DUMMY = FCP_GET(A, 0x80, 0x7); if (FCL_DUMMY) { FCR_RETVAL = 1; goto FCC_BusReset_A; // } else { } FCI_DELAYBYTE_US(140); FCI_DELAYBYTE_US(200); FCI_DELAYBYTE_US(200); FCR_RETVAL = 0; FCC_BusReset_A: ; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Scans the one wire bus to detect all devices : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__ScanBus() { //Local variable definitions MX_UINT8 FCL_DEVICE_COUNT = (0x0); MX_UINT8 FCL_LOPER; MX_UINT8 FCR_RETVAL; FCV_0fb1_v5__one_wire0__CONFLICT = -1; FCV_0fb1_v5__one_wire0__NEW_CONFLICT = 1; FCR_RETVAL = FCD_0fb1_v5__one_wire0__BusReset(); if (FCR_RETVAL == 1) { FCR_RETVAL = 255; goto FCC_ScanBus_A; // } else { } while (FCV_0fb1_v5__one_wire0__NEW_CONFLICT) { FCR_RETVAL = FCD_0fb1_v5__one_wire0__Get_Next_ID(); if (FCR_RETVAL) { goto FCC_ScanBus_A; // } else { } FCL_LOPER = 0; while (FCL_LOPER < 8) { FCV_0fb1_v5__one_wire0__DEV_ID[(FCL_LOPER + (FCL_DEVICE_COUNT << 3))] = FCV_0fb1_v5__one_wire0__ID[FCL_LOPER]; FCL_LOPER = FCL_LOPER + 1; } FCL_DEVICE_COUNT = FCL_DEVICE_COUNT + 1; } FCV_0fb1_v5__one_wire0__NUM_DEVICES = FCL_DEVICE_COUNT; FCR_RETVAL = 0; FCC_ScanBus_A: ; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__Receive_Bit() { //Local variable definitions MX_UINT8 FCL_DUMMY; MX_UINT8 FCR_RETVAL; FCP_SET(A, 0x80, 0x7, 0); FCI_DELAYBYTE_US(1); FCL_DUMMY = FCP_GET(A, 0x80, 0x7); FCI_DELAYBYTE_US(10); FCR_RETVAL = FCP_GET(A, 0x80, 0x7); FCI_DELAYBYTE_US(50); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Returns the number of detected devices : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__GetDeviceCount() { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = FCV_0fb1_v5__one_wire0__NUM_DEVICES; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Shuffle the next byte into the CRC : :Parameters for macro CRC_Shuffle_Byte: : Data : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__one_wire0__CRC_Shuffle_Byte(MX_UINT8 FCL_DATA) { #if (0) //Code has been optimised out by the pre-processor // #else #endif } /*=----------------------------------------------------------------------=*\ Use :Helper function for the scanbus function. :Collects the next ID on the bus : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__Get_Next_ID() { //Local variable definitions MX_UINT8 FCL_VAL0 = (0x0); MX_UINT8 FCL_VAL1 = (0x0); MX_UINT8 FCL_COUNTER = (0x0); MX_UINT8 FCL_BIT_INDEX = (0x0); MX_UINT8 FCL_BYTE_INDEX = (0x0); MX_UINT8 FCL_DATA_IN_BYTE = (0x0); MX_UINT8 FCL_LZ_SELECTED = (0x0); MX_UINT8 FCL_GO_ON = (0x0); MX_UINT8 FCL_BIT_TEST; MX_UINT8 FCR_RETVAL; FCV_0fb1_v5__one_wire0__NEW_CONFLICT = 0; FCL_BIT_TEST = FCD_0fb1_v5__one_wire0__BusReset(); if (FCL_BIT_TEST) { FCR_RETVAL = 1; goto FCC_Get_Next_ID_A; // } else { } FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__OO_SEARCHROM); FCL_BYTE_INDEX = 0; while (FCL_BYTE_INDEX < 8) { FCL_DATA_IN_BYTE = 0; FCL_BIT_INDEX = 0; while (FCL_BIT_INDEX < 8) { FCL_VAL0 = FCD_0fb1_v5__one_wire0__Receive_Bit(); FCL_VAL1 = FCD_0fb1_v5__one_wire0__Receive_Bit(); FCL_VAL0 = FCL_VAL0 | (FCL_VAL1 << 1); switch (FCL_VAL0) { case 1: { break; } case 2: { break; } case 3: { FCR_RETVAL = 2; goto FCC_Get_Next_ID_A; break; } default: { if (FCL_COUNTER < FCV_0fb1_v5__one_wire0__CONFLICT) { if ((FCV_0fb1_v5__one_wire0__ID[FCL_BYTE_INDEX] >> FCL_BIT_INDEX) & 0x01) { FCL_VAL0 = 1; } else { FCL_VAL0 = 0; FCL_LZ_SELECTED = FCL_COUNTER; FCL_GO_ON = 1; } } else { if (FCL_COUNTER == FCV_0fb1_v5__one_wire0__CONFLICT) { FCL_VAL0 = 1; } else { FCL_VAL0 = 0; FCV_0fb1_v5__one_wire0__CONFLICT = FCL_COUNTER; FCV_0fb1_v5__one_wire0__NEW_CONFLICT = 1; } } } } FCL_DATA_IN_BYTE = FCL_DATA_IN_BYTE >> 1; if (FCL_VAL0) { FCL_DATA_IN_BYTE = FCL_DATA_IN_BYTE | 0x80; // } else { } FCD_0fb1_v5__one_wire0__Transmit_Bit(FCL_VAL0); FCL_COUNTER = FCL_COUNTER + 1; FCL_BIT_INDEX = FCL_BIT_INDEX + 1; } FCV_0fb1_v5__one_wire0__ID[FCL_BYTE_INDEX] = FCL_DATA_IN_BYTE; FCL_BYTE_INDEX = FCL_BYTE_INDEX + 1; } if ((FCV_0fb1_v5__one_wire0__NEW_CONFLICT == 0) && (FCL_GO_ON)) { FCV_0fb1_v5__one_wire0__NEW_CONFLICT = 1; FCV_0fb1_v5__one_wire0__CONFLICT = FCL_LZ_SELECTED; // } else { } #if (0) //Code has been optimised out by the pre-processor // #else #endif FCR_RETVAL = 0; FCC_Get_Next_ID_A: ; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Returns byte ectet of the 64-Bit lasered ROM code, 255 on error : :Parameters for macro GetIDByte: : device : MX_UINT8 : octet : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__GetIDByte(MX_UINT8 FCL_DEVICE, MX_UINT8 FCL_OCTET) { //Local variable definitions MX_UINT8 FCR_RETVAL; FCR_RETVAL = 255; if (((FCL_DEVICE >= FCV_0fb1_v5__one_wire0__NUM_DEVICES) | (FCL_OCTET > 7))) { } else { FCR_RETVAL = FCV_0fb1_v5__one_wire0__DEV_ID[(FCL_OCTET + (FCL_DEVICE << 3))]; } return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Reads the scratchpad of the currently selected device : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__DS1820_ReadScratchpad() { //Local variable definitions MX_UINT8 FCL_COUNTER = (0x0); MX_UINT8 FCR_RETVAL; FCR_RETVAL = FCD_0fb1_v5__one_wire0__BusReset(); if (FCR_RETVAL) { FCR_RETVAL = 1; goto FCC_DS1820_ReadScratchpad_A; // } else { } FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__OO_SKIPROM); FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__OO_READPAD); #if (0) //Code has been optimised out by the pre-processor // #else #endif while (FCL_COUNTER < 9) { FCV_0fb1_v5__one_wire0__SCRATCHPAD[FCL_COUNTER] = FCD_0fb1_v5__one_wire0__ReceiveByte(); FCL_COUNTER = FCL_COUNTER + 1; } #if (0) //Code has been optimised out by the pre-processor // #else #endif FCC_DS1820_ReadScratchpad_A: ; return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Reads the temperature of the device at location count in the id array : :Parameters for macro ReadDevice: : count : MX_UINT8 : :Returns : MX_UINT8 \*=----------------------------------------------------------------------=*/ MX_UINT8 FCD_0fb1_v5__one_wire0__ReadDevice(MX_UINT8 FCL_COUNT) { //Local variable definitions MX_UINT8 FCL_LOPER = (0x0); MX_UINT8 FCL_COUNTER = (0x0); MX_UINT8 FCL_TEMP; MX_UINT8 FCR_RETVAL; FCD_0fb1_v5__one_wire0__BusReset(); FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__OO_MATCHROM); while (FCL_LOPER < 8) { FCV_0fb1_v5__one_wire0__DEV_ID[FCL_LOPER] = FCV_0fb1_v5__one_wire0__ID[(FCL_LOPER + (FCL_COUNT << 3))]; FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__ID[FCL_LOPER]); FCL_LOPER = FCL_LOPER + 1; } FCD_0fb1_v5__one_wire0__TransmitByte(FCV_0fb1_v5__one_wire0__OO_READPAD); #if (0) //Code has been optimised out by the pre-processor // #else #endif while (FCL_COUNTER < 9) { FCL_TEMP = FCD_0fb1_v5__one_wire0__ReceiveByte(); FCV_0fb1_v5__one_wire0__SCRATCHPAD[FCL_COUNTER] = FCL_TEMP; FCL_COUNTER = FCL_COUNTER + 1; } #if (0) //Code has been optimised out by the pre-processor #else FCR_RETVAL = 0; #endif return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Returns the two byte value of the temperature sensor : :Returns : MX_UINT16 \*=----------------------------------------------------------------------=*/ MX_UINT16 FCD_0fb1_v5__one_wire0__DS1820_GetTemp() { //Local variable definitions MX_UINT16 FCR_RETVAL; FCR_RETVAL = FCV_0fb1_v5__one_wire0__SCRATCHPAD[1]; FCR_RETVAL = FCR_RETVAL << 8; FCR_RETVAL = FCR_RETVAL | (FCV_0fb1_v5__one_wire0__SCRATCHPAD[0]); return (FCR_RETVAL); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro Transmit_Bit: : Data : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__one_wire0__Transmit_Bit(MX_UINT8 FCL_DATA) { //Local variable definitions MX_UINT8 FCL_DUMMY; FCP_SET(A, 0x80, 0x7, 0); FCI_DELAYBYTE_US(1); if (FCL_DATA & 0x01) { FCL_DUMMY = FCP_GET(A, 0x80, 0x7); // } else { } FCI_DELAYBYTE_US(60); FCL_DUMMY = FCP_GET(A, 0x80, 0x7); FCI_DELAYBYTE_US(10); } /*========================================================================*\ Use :InjectorBase1 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :COMPort1 :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :dash_IO_flasher :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :fcdhelper :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :cal_uart :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro Prv_TextConsole: : Str[20] : MX_CHAR (by-ref) \*=----------------------------------------------------------------------=*/ void FCD_0fcb_cal_uart__Prv_TextConsole(MX_CHAR* FCL_STR, MX_UINT16 FCLsz_STR) { } /*========================================================================*\ Use :v5__rs2320 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SendString: : sString[20] : MX_CHAR (by-ref) \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rs2320__SendString(MX_CHAR* FCL_SSTRING, MX_UINT16 FCLsz_SSTRING) { //Local variable definitions MX_UINT8 FCL_LEN; MX_UINT8 FCL_IDX; FCL_LEN = FCI_GETLENGTH(FCL_SSTRING, FCLsz_SSTRING); FCL_IDX = 0; while (FCL_IDX < FCL_LEN) { FC_CAL_UART_Send_1(FCL_SSTRING[FCL_IDX]); FCL_IDX = FCL_IDX + 1; } } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro SendChar: : Char : MX_SINT16 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rs2320__SendChar(MX_SINT16 FCL_CHAR) { FC_CAL_UART_Send_1(FCL_CHAR); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro ChangeHWBaud: : NewBaud : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rs2320__ChangeHWBaud(MX_UINT8 FCL_NEWBAUD) { FC_CAL_UART_UpdateBaud_1(FCL_NEWBAUD); } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro ReceiveString: : Timeout : MX_UINT8 : NumBytes : MX_UINT8 : :Returns : MX_CHAR \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rs2320__ReceiveString(MX_CHAR* FCR_RETVAL, MX_UINT16 FCRsz_RETVAL, MX_UINT8 FCL_TIMEOUT, MX_UINT8 FCL_NUMBYTES) { //Local variable definitions MX_SINT16 FCL_ERRORVAL; MX_UINT8 FCL_CHCOUNT; MX_SINT16 FCL_RETVAL; MX_UINT8 FCL_CH; #if (0) // 0 == 1 //Code has been optimised out by the pre-processor #else FCL_ERRORVAL = 255; #endif while (FCL_CHCOUNT < FCL_NUMBYTES) { FCL_RETVAL = FC_CAL_UART_Receive_1(FCL_TIMEOUT); if (FCL_RETVAL < FCL_ERRORVAL) { FCL_CH = FCL_RETVAL & 0xff; FCI_SHEAD(FCR_RETVAL,FCRsz_RETVAL, &FCL_CH,1, FCR_RETVAL,FCRsz_RETVAL); FCL_CHCOUNT = FCL_CHCOUNT + 1; } else { FCL_CHCOUNT = FCL_NUMBYTES; } } } /*=----------------------------------------------------------------------=*\ Use :Sets up the RS232 peripheral \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__rs2320__Initialise() { //Local variable definitions #define FCLsz_TEMP 20 MX_CHAR FCL_TEMP[FCLsz_TEMP]; FC_CAL_UART_Init_1(); //Local variable definitions #undef FCLsz_TEMP } /*=----------------------------------------------------------------------=*\ Use :Parameters for macro ReceiveChar: : Timeout : MX_SINT16 : :Returns : MX_SINT16 \*=----------------------------------------------------------------------=*/ MX_SINT16 FCD_0fb1_v5__rs2320__ReceiveChar(MX_SINT16 FCL_TIMEOUT) { //Local variable definitions MX_SINT16 FCR_RETVAL; FCR_RETVAL = FC_CAL_UART_Receive_1(FCL_TIMEOUT); return (FCR_RETVAL); } /*========================================================================*\ Use :ctrl_lcd :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :v5__lcddisplay0 :Macro implementations \*========================================================================*/ /*=----------------------------------------------------------------------=*\ Use :Clear the whole display. Leaves an empty display with the cursor positioned :at the top, left (0, 0). \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__Clear() { FCD_0fb1_v5__lcddisplay0__RawSend(0x01, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x02, 0); FCI_DELAYBYTE_MS(2); } /*=----------------------------------------------------------------------=*\ Use :Breaks down a string of text and sends it to the LCD via the private RawSend(byte, mask) macro : :Parameters for macro PrintString: : Text[20] : String to print \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__PrintString(MX_CHAR* FCL_TEXT, MX_UINT16 FCLsz_TEXT) { //Local variable definitions MX_UINT8 FCL_IDX = (0x0); MX_UINT8 FCL_COUNT; FCL_COUNT = FCI_GETLENGTH(FCL_TEXT, FCLsz_TEXT); while (FCL_IDX < FCL_COUNT) { FCD_0fb1_v5__lcddisplay0__RawSend(FCL_TEXT[FCL_IDX], 0x10); FCL_IDX = FCL_IDX + 1; } } /*=----------------------------------------------------------------------=*\ Use :Takes the ascii value for a character and prints the character : :Parameters for macro PrintAscii: : character : Holds an ascii value. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__PrintAscii(MX_UINT8 FCL_CHARACTER) { //Local variable definitions MX_UINT8 FCL_X; FCD_0fb1_v5__lcddisplay0__RawSend(FCL_CHARACTER, 0x10); } /*=----------------------------------------------------------------------=*\ Use :Based on v5 macro, will allow you to print a number. This is limited to a signed-INT, -32768 to 32767 : :Parameters for macro PrintNumber: : Number : An integer in the range -32768 to 32767 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__PrintNumber(MX_SINT16 FCL_NUMBER) { //Local variable definitions #define FCLsz_S 20 MX_CHAR FCL_S[FCLsz_S]; FCI_TOSTRING(FCL_NUMBER, FCL_S,FCLsz_S); FCD_0fb1_v5__lcddisplay0__PrintString(FCL_S, FCLsz_S); //Local variable definitions #undef FCLsz_S } /*=----------------------------------------------------------------------=*\ Use :Modifies the internal memory of the LCD to allow for up to 8 customised characters to be created and stored in the device memory : :Parameters for macro RAMWrite: : Index : Values 0 to 7 : d0 : MX_UINT8 : d1 : MX_UINT8 : d2 : MX_UINT8 : d3 : MX_UINT8 : d4 : MX_UINT8 : d5 : MX_UINT8 : d6 : MX_UINT8 : d7 : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__RAMWrite(MX_UINT8 FCL_INDEX, MX_UINT8 FCL_D0, MX_UINT8 FCL_D1, MX_UINT8 FCL_D2, MX_UINT8 FCL_D3, MX_UINT8 FCL_D4, MX_UINT8 FCL_D5, MX_UINT8 FCL_D6, MX_UINT8 FCL_D7) { FCD_0fb1_v5__lcddisplay0__RawSend(64 + (FCL_INDEX << 3), 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D0, 0x10); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D1, 0x10); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D2, 0x10); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D3, 0x10); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D4, 0x10); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D5, 0x10); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D6, 0x10); FCD_0fb1_v5__lcddisplay0__RawSend(FCL_D7, 0x10); FCD_0fb1_v5__lcddisplay0__Clear(); } /*=----------------------------------------------------------------------=*\ Use :Clear a single line of the display. Leaves the cursor at the start of the :empty line. : :Parameters for macro ClearLine: : Line : The line to clear. The top lline is line zero. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__ClearLine(MX_UINT8 FCL_LINE) { //Local variable definitions MX_UINT8 FCL_NUMROWS; MX_UINT8 FCL_NUMCOLS; MX_SINT16 FCL_X; if (FCL_LINE < 2) { FCD_0fb1_v5__lcddisplay0__Cursor(0, FCL_LINE); FCL_X = 0; while (FCL_X < 16) { FCD_0fb1_v5__lcddisplay0__RawSend(' ', 0x10); FCL_X = FCL_X + 1; } FCD_0fb1_v5__lcddisplay0__Cursor(0, FCL_LINE); // } else { } } /*=----------------------------------------------------------------------=*\ Use :Moves the cursor on the LCD Display : :Parameters for macro Cursor: : x : X = columns going left to right. First column is zero. : y : Y = lines going top to bottom. First line is zero. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__Cursor(MX_UINT8 FCL_X, MX_UINT8 FCL_Y) { #if (0) // 2 == 1 //Code has been optimised out by the pre-processor // #else #endif #if (1) // 2 == 2 if (FCL_Y == 0) { FCL_Y = 0x80; } else { FCL_Y = 0xC0; } // #else //Code has been optimised out by the pre-processor #endif #if (0) // 2 == 4 //Code has been optimised out by the pre-processor // #else #endif FCD_0fb1_v5__lcddisplay0__RawSend(FCL_Y + FCL_X, 0); FCI_DELAYBYTE_MS(2); } /*=----------------------------------------------------------------------=*\ Use :Use this method/macro to send a specific command to the LCD. Refer to the Matrix Multimedia EB006 datasheet for a list of supported instructions. For Non-Matrix LCD's refer to the manufacturers datasheet. : :Parameters for macro Command: : instruction : Send a defined command to the LCD Screen. See datasheet for supported commands. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__Command(MX_UINT8 FCL_INSTRUCTION) { FCD_0fb1_v5__lcddisplay0__RawSend(FCL_INSTRUCTION, 0); FCI_DELAYBYTE_MS(2); } /*=----------------------------------------------------------------------=*\ Use :Scrolls the display left or right by a number of given positions. : :Parameters for macro ScrollDisplay: : Position : Holds the number of positions to shift the display : direction : 0 = left, 1 = right \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__ScrollDisplay(MX_UINT8 FCL_POSITION, MX_UINT8 FCL_DIRECTION) { //Local variable definitions MX_UINT8 FCL_CMD = (0x0); FCL_CMD = -1; switch (FCL_DIRECTION) { case 0: { FCL_CMD = 0x18; break; } case 'l': { FCL_CMD = 0x18; break; } case 'L': { FCL_CMD = 0x18; break; } case 1: { FCL_CMD = 0x1C; break; } case 'r': { FCL_CMD = 0x1C; break; } case 'R': { FCL_CMD = 0x1C; break; } default: { } } if (FCL_CMD != -1 & FCL_POSITION != 0) { while (FCL_POSITION != 0) { FCD_0fb1_v5__lcddisplay0__RawSend(FCL_CMD, 0); FCL_POSITION = FCL_POSITION - 1; } // } else { } } /*=----------------------------------------------------------------------=*\ Use :Sends data to the LCD display : :Parameters for macro RawSend: : data : MX_UINT8 : mask : MX_UINT8 \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__RawSend(MX_UINT8 FCL_DATA, MX_UINT8 FCL_MASK) { //Local variable definitions MX_UINT8 FCL_NIBBLE; FCP_SET(B, 0x1, 0x0, 0); FCP_SET(B, 0x2, 0x1, 0); FCP_SET(B, 0x4, 0x2, 0); FCP_SET(B, 0x8, 0x3, 0); FCP_SET(B, 0x10, 0x4, 0); FCP_SET(B, 0x20, 0x5, 0); //Comment: //Take the MSB(most significant bits from the byte) //and assign them to pins 0 through 3. FCL_NIBBLE = (FCL_DATA >> 4); FCP_SET(B, 0x1, 0x0, (FCL_NIBBLE & 0x01)); FCL_NIBBLE = FCL_NIBBLE >> 1; FCP_SET(B, 0x2, 0x1, (FCL_NIBBLE & 0x01)); FCL_NIBBLE = FCL_NIBBLE >> 1; FCP_SET(B, 0x4, 0x2, (FCL_NIBBLE & 0x01)); FCL_NIBBLE = FCL_NIBBLE >> 1; FCP_SET(B, 0x8, 0x3, (FCL_NIBBLE & 0x01)); if (FCL_MASK) { FCP_SET(B, 0x10, 0x4, 1); // } else { } FCI_DELAYBYTE_US(100); //Comment: //Set pin5 high, pause then set low //to acknowledge the MSB data has //been submitted. FCP_SET(B, 0x20, 0x5, 1); FCI_DELAYBYTE_US(100); FCP_SET(B, 0x20, 0x5, 0); FCI_DELAYBYTE_US(100); //Comment: //Now deal with the LSB(Least significant bits) //and send them. FCP_SET(B, 0x1, 0x0, 0); FCP_SET(B, 0x2, 0x1, 0); FCP_SET(B, 0x4, 0x2, 0); FCP_SET(B, 0x8, 0x3, 0); FCP_SET(B, 0x10, 0x4, 0); FCP_SET(B, 0x20, 0x5, 0); FCL_NIBBLE = (FCL_DATA & 0xf); FCP_SET(B, 0x1, 0x0, (FCL_NIBBLE & 0x01)); FCL_NIBBLE = FCL_NIBBLE >> 1; FCP_SET(B, 0x2, 0x1, (FCL_NIBBLE & 0x01)); FCL_NIBBLE = FCL_NIBBLE >> 1; FCP_SET(B, 0x4, 0x2, (FCL_NIBBLE & 0x01)); FCL_NIBBLE = FCL_NIBBLE >> 1; FCP_SET(B, 0x8, 0x3, (FCL_NIBBLE & 0x01)); if (FCL_MASK) { FCP_SET(B, 0x10, 0x4, 1); // } else { } //Comment: //Set pin5 high, pause then set low //to acknowledge the MSB data has //been submitted. FCI_DELAYBYTE_US(100); FCP_SET(B, 0x20, 0x5, 1); FCI_DELAYBYTE_US(100); FCP_SET(B, 0x20, 0x5, 0); FCI_DELAYBYTE_US(100); } /*=----------------------------------------------------------------------=*\ Use :Startup routine required by the hardware device. \*=----------------------------------------------------------------------=*/ void FCD_0fb1_v5__lcddisplay0__Start() { FCP_SET(B, 0x1, 0x0, 0); FCP_SET(B, 0x2, 0x1, 0); FCP_SET(B, 0x4, 0x2, 0); FCP_SET(B, 0x8, 0x3, 0); FCP_SET(B, 0x10, 0x4, 0); FCP_SET(B, 0x20, 0x5, 0); FCI_DELAYBYTE_MS(12); FCD_0fb1_v5__lcddisplay0__RawSend(0x33, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x33, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x32, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x2c, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x06, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x0c, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x01, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__RawSend(0x02, 0); FCI_DELAYBYTE_MS(2); FCD_0fb1_v5__lcddisplay0__Clear(); } /*========================================================================*\ Use :panel :Macro implementations \*========================================================================*/ /*========================================================================*\ Use :Main \*========================================================================*/ void main() { ansela = 0x00; anselb = 0x00; anseld = 0x00; ansele = 0x00; option_reg = 0xC0; // Call Component Macro // Call Component Macro: v5__lcddisplay0::Start() FCD_0fb1_v5__lcddisplay0__Start(); // Call Component Macro // Call Component Macro: v5__pwm0::Enable() FC_CAL_PWM_Enable_2(); // Call Component Macro // Call Component Macro: v5__pwm1::Enable() FC_CAL_PWM_Enable_3(); // Call Component Macro // Call Component Macro: v5__pwm2::Enable() FC_CAL_PWM_Enable_4(); // Call Component Macro // Call Component Macro: v5__pwm0::SetDuty10Bit(100) FC_CAL_PWM_SetDuty10Bit_2(100); // Call Component Macro // Call Component Macro: v5__pwm1::SetDuty8Bit(20) FC_CAL_PWM_SetDuty8Bit_3(20); // Call Component Macro // Call Component Macro: v5__pwm2::SetDuty10Bit(180) FC_CAL_PWM_SetDuty10Bit_4(180); // Call Component Macro // Call Component Macro: v5__rs2320::SendString("Hello world") FCD_0fb1_v5__rs2320__SendString("Hello world", 11); // Call Component Macro // Call Component Macro: Intvar=v5__one_wire0::DS1820_StartConversion() FCV_INTVAR = FCD_0fb1_v5__one_wire0__DS1820_StartConversion(); // Call Component Macro // Call Component Macro: v5__i2c_master0::Initialise() FCD_0fb1_v5__i2c_master0__Initialise(); // Call Component Macro // Call Component Macro: v5__can0::Initialise() FC_CAN_Initialise_1(); // Call Component Macro // Call Component Macro: v5__spi_legacy0::Initialise() FCD_0fb1_v5__spi_legacy0__Initialise(); // Call Component Macro // Call Component Macro: v5__rc50::RXEnable() FCD_0fb1_v5__rc50__RXEnable(); // Call Component Macro // Call Component Macro: v5__servo0::EnableServo(1) FCD_0fb1_v5__servo0__EnableServo(1); // Call Component Macro // Call Component Macro: v5__lcddisplay0::Cursor(0, 0) FCD_0fb1_v5__lcddisplay0__Cursor(0, 0); // Call Component Macro // Call Component Macro: v5__rs2320::SendString("Hello World") FCD_0fb1_v5__rs2320__SendString("Hello World", 11); // Call Component Macro // Call Component Macro: v5__stepper0::EnableMotor() FCD_0fb1_v5__stepper0__EnableMotor(); // Calculation // Calculation: // StringTest = FloatToString$ (FloatVar) // FloatVar = StringToFloat$ (StringTest) // FloatVar = 12.5612 // ByteArray[1] = 80 // Intvar = 20000 // LongVar = 802000 // UlongVar = 45855555 // Unit = 45274111 // StringTest = ToString$ (LongVar) // StringTest = Mid$ (StringTest,1,6) // Test1 = Compare$ (StringTest,String2,0) FCI_FLOAT_TO_STRING(FCV_FLOATVAR, FCV_PRECISION, FCV_STRINGTEST,FCVsz_STRINGTEST); FCV_FLOATVAR = FCI_STRING_TO_FLOAT(FCV_STRINGTEST, FCVsz_STRINGTEST); FCV_FLOATVAR = 12.5612; FCV_BYTEARRAY[1] = 80; FCV_INTVAR = 20000; FCV_LONGVAR = 802000; FCV_ULONGVAR = 45855555; FCV_UNIT = 45274111; FCI_TOSTRING(FCV_LONGVAR, FCV_STRINGTEST,FCVsz_STRINGTEST); FCI_MIDSTRING(FCV_STRINGTEST, FCVsz_STRINGTEST, 1, 6, FCV_STRINGTEST,FCVsz_STRINGTEST); FCV_TEST1 = FCI_COMPARE(FCV_STRINGTEST, FCVsz_STRINGTEST, FCV_STRING2, FCVsz_STRING2, 0); // Call Component Macro // Call Component Macro: v5__eeprom0::Write(1, 10) FCD_0fb1_v5__eeprom0__Write(1, 10); // Call Component Macro // Call Component Macro: v5__rc50::TXEnable() FCD_0fb1_v5__rc50__TXEnable(); // Loop // Loop: While 1 while (1) { // Call Component Macro // Call Component Macro: v5__lcddisplay0::Cursor(2, 1) FCD_0fb1_v5__lcddisplay0__Cursor(2, 1); // Call Component Macro // Call Component Macro: v5__eeprom0::Read(2) FCD_0fb1_v5__eeprom0__Read(2); // Call Component Macro // Call Component Macro: Intvar=v5__adc0::GetInt() FCV_INTVAR = FCD_0fb1_v5__adc0__GetInt(); // Call Component Macro // Call Component Macro: Unit=v5__adc0::RAWAverageInt(10, 15) FCV_UNIT = FCD_0fb1_v5__adc0__RawAverageInt(10, 15); // Call Component Macro // Call Component Macro: v5__lcddisplay0::PrintNumber(Unit) FCD_0fb1_v5__lcddisplay0__PrintNumber(FCV_UNIT); // Call Component Macro // Call Component Macro: v5__lcddisplay0::PrintString(" ") FCD_0fb1_v5__lcddisplay0__PrintString(" ", 13); } mainendloop: goto mainendloop; } /*========================================================================*\ Use :Interrupt \*========================================================================*/ void MX_INTERRUPT_MACRO(void) { MX_RC5_INT { FCD_0fb1_v5__rc50__Signal_Edge(); #ifdef MX_CAL_AVR st_bit(INT_FLAGREG, INT_FLAGBIT); #else #ifdef MX_CAL_PIC16BIT INT_FLAGREG.INT_FLAGBIT = 0; #else cr_bit(INT_FLAGREG, INT_FLAGBIT); #endif #endif } MX_RC5_TIMER { FCD_0fb1_v5__rc50__Timer_Event(); #ifdef MX_CAL_AVR st_bit(TIMER_FLAGREG, TIMER_FLAGBIT); #else #ifdef MX_CAL_PIC16BIT TIMER_FLAGREG.TIMER_FLAGBIT = 0; #else cr_bit(TIMER_FLAGREG, TIMER_FLAGBIT); #endif #endif } MX_CCP1_INT_START { MX_UINT32 FCL_SERVOCAL; if (FCV_0fb1_v5__servo0__SERVO_IDX < 1) { if (FCV_0fb1_v5__servo0__SERVO_ENABLED & (0x01 << FCV_0fb1_v5__servo0__SERVO_IDX)) { if (1 > 0) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 0) { FCP_SET(D, 0x1, 0x0, 1); // } else { } // } else { } if (1 > 1) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 1) { FCP_SET(A, 0x2, 0x1, 1); // } else { } // } else { } if (1 > 2) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 2) { FCP_SET(A, 0x4, 0x2, 1); // } else { } // } else { } if (1 > 3) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 3) { FCP_SET(A, 0x8, 0x3, 1); // } else { } // } else { } if (1 > 4) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 4) { FCP_SET(A, 0x10, 0x4, 1); // } else { } // } else { } if (1 > 5) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 5) { FCP_SET(A, 0x20, 0x5, 1); // } else { } // } else { } if (1 > 6) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 6) { /* Error: Syntax error */; // } else { } // } else { } if (1 > 7) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 7) { /* Error: Syntax error */; // } else { } // } else { } // } else { } // } else { } FCL_SERVOCAL = FCV_0fb1_v5__servo0__SERVO_TRIM[FCV_0fb1_v5__servo0__SERVO_IDX]; FCL_SERVOCAL = FCL_SERVOCAL + FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX]; FCL_SERVOCAL = FCL_SERVOCAL * 6291; FCL_SERVOCAL = FCL_SERVOCAL >> 8; FCL_SERVOCAL = FCL_SERVOCAL & 0xFFFF; //Comment: //Still Needed??? #if 0 // Disabled code #ifdef MX_CAL_AVR #endif // #if 0: Disabled code #if 0 // Disabled code FCL_SERVOCAL = FCL_SERVOCAL / 2; #endif // #if 0: Disabled code #if 0 // Disabled code #endif #endif // #if 0: Disabled code #if 0 // Disabled code #ifdef MX_CAL_PIC16BIT #endif // #if 0: Disabled code #if 0 // Disabled code if (FCV_0fb1_v5__servo0__CLOCKS_PER_INST == 2) { #if 0 // Disabled code FCL_SERVOCAL = FCL_SERVOCAL * 2; #endif // #if 0: Disabled code // } else { } #endif // #if 0: Disabled code #if 0 // Disabled code #endif #endif // #if 0: Disabled code #ifdef MX_CAL_ARM AT91C_BASE_TC2->TC_RA = FCL_SERVOCAL; //Setup capture compare registers #else #ifdef MX_CAL_PIC16BIT PR2 = FCL_SERVOCAL; TMR2 = 0; T2CON = 0x8000; #else MX_SERVO_REG_CCPR2H = ( FCL_SERVOCAL >> 8 ); //Setup capture compare registers MX_SERVO_REG_CCPR2L = ( FCL_SERVOCAL & 0xFF ); #endif #endif #ifdef MX_CAL_PIC16BIT MX_SERVO_REG_CCP1F.MX_SERVO_FLAG_CCP1F = 0; //Clear interrupt #else cr_bit(MX_SERVO_REG_CCP1F, MX_SERVO_FLAG_CCP1F); //Clear interrupt #endif } MX_CCP2_INT_START { if (FCV_0fb1_v5__servo0__SERVO_IDX < 1) { if (FCV_0fb1_v5__servo0__SERVO_ENABLED & (0x01 << FCV_0fb1_v5__servo0__SERVO_IDX)) { if (1 > 0) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 0) { FCP_SET(D, 0x1, 0x0, 0); // } else { } // } else { } if (1 > 1) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 1) { FCP_SET(A, 0x2, 0x1, 0); // } else { } // } else { } if (1 > 2) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 2) { FCP_SET(A, 0x4, 0x2, 0); // } else { } // } else { } if (1 > 3) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 3) { FCP_SET(A, 0x8, 0x3, 0); // } else { } // } else { } if (1 > 4) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 4) { FCP_SET(A, 0x10, 0x4, 0); // } else { } // } else { } if (1 > 5) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 5) { FCP_SET(A, 0x20, 0x5, 0); // } else { } // } else { } if (1 > 6) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 6) { /* Error: Syntax error */; // } else { } // } else { } if (1 > 7) { if (FCV_0fb1_v5__servo0__SERVO_IDX == 7) { /* Error: Syntax error */; // } else { } // } else { } // } else { } // } else { } FCV_0fb1_v5__servo0__SERVO_IDX = (FCV_0fb1_v5__servo0__SERVO_IDX + 1) & 0x07; if (FCV_0fb1_v5__servo0__SERVO_REQUIRED[FCV_0fb1_v5__servo0__SERVO_IDX] > FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX]) { FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX] = FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX] + 1; // } else { } if (FCV_0fb1_v5__servo0__SERVO_REQUIRED[FCV_0fb1_v5__servo0__SERVO_IDX] < FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX]) { FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX] = FCV_0fb1_v5__servo0__SERVO_POSITION[FCV_0fb1_v5__servo0__SERVO_IDX] - 1; // } else { } #ifdef MX_CAL_PIC16BIT T2CON = 0; MX_SERVO_REG_CCP2F.MX_SERVO_FLAG_CCP2F = 0; //Clear interrupt #else cr_bit(MX_SERVO_REG_CCP2F, MX_SERVO_FLAG_CCP2F); //Clear interrupt #endif } }