/*
* File: robo_balance.c
*
* Real-Time Workshop code generated for Simulink model robo_balance.
*
* Model version : 1.7
* Real-Time Workshop file version : 8.2 (R2012a) 29-Dec-2011
* Real-Time Workshop file generated on : Fri Nov 29 16:16:18 2013
* TLC version : 8.2 (Dec 29 2011)
* C source code generated on : Fri Nov 29 16:16:18 2013
*--------------------------------------------------------------
* Embedded Coder for Microchip dsPIC family. |
* Generate .c and .h files from your Matlab/simulink model |
* and compile the diagram to .hex and .coff file that can be |
* downloaded directly into the microcontroller |
* |
* Licence Accorded to Demonstration Version |
* Author : Lubin KERHUEL |
* |
* Written by Lubin KERHUEL - http://www.kerhuel.eu |
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
* Version 3.7e 10-Sep-2012 |
* For Matlab 7.14 R2012a |
*--------------------------------------------------------------
*/
#include "robo_balance.h"
#include "robo_balance_private.h"
/* Block signals (auto storage) */
BlockIO_robo_balance robo_balance_B;
/* Block states (auto storage) */
D_Work_robo_balance robo_balance_DWork;
/* Real-time model */
RT_MODEL_robo_balance robo_balance_M_;
RT_MODEL_robo_balance *const robo_balance_M = &robo_balance_M_;
static void rate_monotonic_scheduler(void);
/*
* Set which subrates need to run this base step (base rate always runs).
* This function must be called prior to calling the model step function
* in order to "remember" which rates need to run this base step. The
* buffering of events allows for overlapping preemption.
*/
void robo_balance_SetEventsForThisBaseStep(boolean_T *eventFlags)
{
/* Task runs when its counter is zero, computed via rtmStepTask macro */
eventFlags[1] = ((boolean_T)rtmStepTask(robo_balance_M, 1));
}
/* rate_monotonic_scheduler */
static void rate_monotonic_scheduler(void)
{
/* Compute which subrates run during the next base time step. Subrates
* are an integer multiple of the base rate counter. Therefore, the subtask
* counter is reset when it reaches its limit (zero means run).
*/
(robo_balance_M->Timing.TaskCounters.TID[1])++;
if ((robo_balance_M->Timing.TaskCounters.TID[1]) > 9) {/* Sample time: [0.01s, 0.0s] */
robo_balance_M->Timing.TaskCounters.TID[1] = 0;
}
}
/* Model step function for TID0 */
void robo_balance_step0(void) /* Sample time: [0.001s, 0.0s] */
{
{ /* Sample time: [0.001s, 0.0s] */
rate_monotonic_scheduler();
}
}
/* Model step function for TID1 */
void robo_balance_step1(void) /* Sample time: [0.01s, 0.0s] */
{
/* local block i/o variables */
real_T rtb_DataTypeConversion4;
real_T rtb_DiscreteZeroPole;
uint32_T rtb_Gain2;
real_T tmp;
/* S-Function "ADC" Block: <Root>/ADC Input */
robo_balance_B.ADCInput = ADC1BUF0;
/* DataTypeConversion: '<Root>/Data Type Conversion4' */
rtb_DataTypeConversion4 = (real_T)robo_balance_B.ADCInput;
/* DiscreteZeroPole: '<S1>/Discrete Zero-Pole' */
{
rtb_DiscreteZeroPole = robo_balance_P.DiscreteZeroPole_D*
rtb_DataTypeConversion4;
rtb_DiscreteZeroPole += robo_balance_P.DiscreteZeroPole_C*
robo_balance_DWork.DiscreteZeroPole_DSTATE;
}
/* DataTypeConversion: '<Root>/Data Type Conversion5' */
tmp = floor(rtb_DiscreteZeroPole);
if (rtIsNaN(tmp) || rtIsInf(tmp)) {
tmp = 0.0;
} else {
tmp = fmod(tmp, 65536.0);
}
/* Gain: '<Root>/Gain2' incorporates:
* DataTypeConversion: '<Root>/Data Type Conversion5'
*/
rtb_Gain2 = (uint32_T)(tmp < 0.0 ? (uint16_T)-(int16_T)(uint16_T)-tmp :
(uint16_T)tmp) * (uint32_T)robo_balance_P.Gain2_Gain;
/* DataTypeConversion: '<Root>/Data Type Conversion1' */
robo_balance_B.DataTypeConversion1 = (uint16_T)(rtb_Gain2 >> 14);
/* S-Function "dsPIC_UART_TX_Labview_Matlab" Block: <Root>/TX Output Multiplexed for Matlab // Labview */
{
static uint16_T nextToSend = 1;
if (nextToSend >= 1) /* should be &, but get robust here */
{
if (!send232Buff_Uart2(robo_balance_B.DataTypeConversion1,1 + 0U*4) )
nextToSend = 1;
}
}
/* Sum: '<Root>/Sum2' incorporates:
* Constant: '<Root>/Constant4'
*/
robo_balance_B.Sum2 = (uint16_T)(rtb_Gain2 >> 14) +
robo_balance_P.Constant4_Value;
/* S-Function "dsPIC_PWM_motor" Block: <Root>/PWM Motor Output */
PDC1 = robo_balance_B.Sum2 ;
/* Update for DiscreteZeroPole: '<S1>/Discrete Zero-Pole' */
{
robo_balance_DWork.DiscreteZeroPole_DSTATE = rtb_DataTypeConversion4 +
robo_balance_P.DiscreteZeroPole_A*
robo_balance_DWork.DiscreteZeroPole_DSTATE;
}
}
void robo_balance_step(int_T tid)
{
switch (tid) {
case 0 :
robo_balance_step0();
break;
case 1 :
robo_balance_step1();
break;
default :
break;
}
}
/* Model initialize function */
void robo_balance_initialize(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)robo_balance_M, 0,
sizeof(RT_MODEL_robo_balance));
/* block I/O */
(void) memset(((void *) &robo_balance_B), 0,
sizeof(BlockIO_robo_balance));
/* states (dwork) */
(void) memset((void *)&robo_balance_DWork, 0,
sizeof(D_Work_robo_balance));
/* S-Function "dsPIC_ADC" initialization Block: <Root>/ADC Input */
/* Initialise ADC converter */
/* 0 mean each 1 conversion */
#define NoSamplesADC 0
#define ADCSval 13
#define SAMCval (1 << 8)
#define OutFormatBitsval (0 << 8)
#define VoltRef (0 << 13)
/* Use internal counter Trigger, continuous simulatenous sampling */
AD1CON1 = 0x0004 | (7 << 5) | (1 << 10)| OutFormatBitsval;
AD1CON2 = 0x0400 | (NoSamplesADC << 2) | VoltRef;
AD1CSSL = (1 & 65535);
AD1CON3 = (ADCSval | SAMCval) & 0xff7f;
AD1CHS0 = 0x0000;
IPC2 = (IPC2 | (6 << 12)); /*Interrupt Priority : 6*/
_AD1IF = 0;
/* We set _ADIE = 1 in the main file if necessary*/
/* Clear Off Any Interrupt Due To Configuration */
/* Turn on ADC Module */
AD1CON1bits.ADON= 1;
/* S-Function "dsPIC_MASTER" initialization Block: <Root>/Master */
/* Solver mode : MultiTasking */
/* CONFIG TIMER 1 for scheduling steps */
ConfigIntTimer1(T1_INT_PRIOR_1 & T1_INT_ON);
T1CON = 0x8000 ; /* T1_PS_1_1 */
PR1 = 9999;
/* Configuration TRIS */
/* Configuration ADCHS */
AD1PCFGL = (0U);
AD2PCFGL = (0U);
AD1PCFGH = ((0U) & 65535);
/* S-Function "dsPIC_UART_config" initialization Block: <Root>/UART Configuration */
/* set priority */
_U2RXIP = 0x0007 & 2;
_U2TXIP = 0x0007 & 1;
/* enable/disable interrupt */
_U2RXIE = (3 != 0);
_U2TXIE = 0;
U2MODE = 0x8080 + 1024;
U2STA = 0x0 + 1 + 1024 + 192 + (1<<12);
U2BRG = 64;
TxPtrHaut_Uart2 = 0;
TxPtrBas_Uart2 = 0;
RxPtrHaut_Uart2 = 0;
RxPtrBas_Uart2 = 0;
_U2TXIF = 0;
/* S-Function "dsPIC_PWM_motor" initialization Block: <Root>/PWM Motor Output */
/* Initialise Output Capture */
SetDCMCPWM(1,0,0);
#define config (PWM_INT_DIS & PWM_FLTA_DIS_INT & PWM_INT_PR1 & PWM_FLTA_INT_PR0)
ConfigIntMCPWM( config );
#define config1 (P
robo_balance.rar_balance_balancing robot_matlab robot
版权申诉
174 浏览量
2022-07-15
17:09:42
上传
评论
收藏 3KB RAR 举报
alvarocfc
- 粉丝: 112
- 资源: 1万+