Станки дома Балансировочный стенд своими руками на отладочной плате silabs c8051f120-tb
Если вы задумали отбалансировать что-то вращающееся, будь то колесо, винт самолета или летающая тарелка. Или Вам интересна история, как проходят рабочие будни программиста. Увлекательная история по созданию балансировочного стенда…
Предисловие.
Выражаю благодарность моему руководителю Дмитриеву Ивану Алексеевичу, инженеру конструктору Арапову Андрею, инженерам электронщикам Тураеву Александру и Гидалю Григорьевичу. Этот стенд результат работы сплаченной команды.
Начну с пред истории: Работаю я программистом в организации
Совершенно не секретно, но к делу не относится, скажу лишь, что занимаемся БПЛА
, где периодически появляется множество разных интересных задач, и появилась у нас необходимость провести балансировку высокой точности винта самолета. Оборудование для такой балансировки как оказалось можно купить, но стоить это будет очень дорого, решили сделать сами.
Немного расскажу зачем это понадобилось. Наш самолет, с этим винтом, ужасно колбасило на холостых оборотах(800 об/мин). Обычно балансируют такие штуки, статически и динамически. Статическая балансировка заключается в уравновешивании относительно центра вращения, без вращения, а динамическая это уравновешивание во время вращения.
Что касается статической балансировки, то тут все понятно винт просто уравновешивается относительно центра вращения, а вот что делать с динамической балансировкой, когда при вращении винт начинает создавать вибрацию.
Для такой задачи был построен
, состоящий из рамы прикрепленной на пружинках к массивному основанию.
На массивном основании установлен электродвигатель, и через шкив он вращает ось, на которую установлен балансируемый винт. Еще на раме установлены акселерометры, а на ось с винтом датчик холла. Электродвигатель подключен к частотнику, который управляет частотой его вращения.
В качестве измерителя отклонения был использован акселерометр на две оси, через усилитель подключенный на
АЦП
отладочной платы SiLabs C8051F120-TB. Чтобы отловить момент прохождения вращающегося тела через 0 градусов, был поставлен датчик холла, сигнал с которого подавался еще на одну ножку отладочной платы.
Итак мы получили нехитрый агрегат,
который может измерить ускорение рамы с телом вращения, и подать сигнал о прохождении через 0 градусов вала, вращающего балансируемый винт.
/внешний вид нехитрого девайса/
Мне дали эту конструкцию, и поставили задачу программным путем узнать, какое необходимо количество изоленты , кусочков пластилинаили аракала очень точно взвешенных грузов, прилепить на краешек лопасти винта, для того, чтобы он стал отбалансированным. И сделать приложение с удобным и понятным интерфейсом, чтобы за 5 минут можно было разобраться как ею пользоваться.
Сначала я подумал, что управлюсь за один день, и задача очень простая. Но при снятии сигнала осциллографом, обнаружилось, что вибрация всей установки, помехи от электросети, и прочий шум, превращают снятый сигнал с АЦП в равномерный непонятный шум. Хотя если приглядеться, то проглядывается явный периодический максимум и минимум. На отладку программной части и железа ушло около недели, или даже чуть больше, зато потом точность девайса стала радовать глаз.
/Показания осцилографа/
На отладочную плату я написал программку, которая снимает показания, и посылает их на COM порт.
Конфигурируем контроллер, определяем основные переменные, выделяем массивы и константы. Готовим отладочную плату к программированию.
#include "c8051f120.h"
#define SYSCLK 98000000 //частота на которой запустили контроллер
#define BAUDRATEU0 57600 // частота Uart0 для передачи по RS232 на COM порт
#define SAMPLE_RATE 24500000 // Sample frequency in Hz
#define INT_DEC 256
#define SAR_CLK 12250000 // Частота АЦП
#define FREQT0 (748*2) //частота Таймера 0
#define BUFADCSIZE 512 //BUFADC
sfr16 ADC0 = 0xbe; // ADC0 data
sfr16 RCAP2 = 0xca; // Timer2 capture/reload
sfr16 RCAP3 = 0xca; // Timer3 capture/reload
sfr16 TMR2 = 0xcc; // Timer2
sfr16 TMR3 = 0xcc; // Timer3
bit ProcessFlag = 0, ADCFlag = 0, flFree = 1, flNewADC = 0; //флаги
xdata unsigned int BufADC[BUFADCSIZE], ADCcount = 0, RTC = 0, RTCP = 0, int_dec = INT_DEC, tmpA = 0, lastTmp = 0;
xdata float Propeller = 0.0, tmp_float;
xdata long accumulator = 0L;
#define RESETTICK (1496)
sbit LED = P1^6; //светодиод для проверки работы датчика холла
sbit BUTTON = P3^7; //кнопка
//UART0 буферы и флаги для передачи
#define NBFM 50
xdata unsigned char BuferFromModem [NBFM];
xdata unsigned char wBFM, rBFM, marBFM;
#define SIZE_BUFFER0 50
xdata char BufferInModem[SIZE_BUFFER0];
xdata int r0, rk;
bit flTransmiter;
//-----функции загрузки в буфер вывода для абстракции протокола обмена
void OutModem1(unsigned char Data, char i)
{
BufferInModem[i] = Data | 0x80;
}
//------------------------------------------------------------------------------
void OutModem2(unsigned int Data, char i)
{
BufferInModem[i] = (Data & 0x007f)| 0x80;
BufferInModem[i 1] = ((Data & 0x3f80) >> 7)| 0x80;
}
//------------------------------------------------------------------------------
void OutModem4(unsigned long int Data, char i)
{
BufferInModem[i] = (Data & 0x0000007f)| 0x80;
BufferInModem[i 1] = ((Data & 0x3f80) >> 7) | 0x80;
BufferInModem[i 2] = ((Data & 0x1fc000) >> 14) | 0x80;
BufferInModem[i 3] = ((Data & 0xfe00000)>> 21) | 0x80;
}
//---- конфигурирование частоты на которой будем работать
void OSCILLATOR_Init (void)
{
int loop;
char SFRPAGE_SAVE = SFRPAGE;
SFRPAGE = CONFIG_PAGE;
OSCICN = 0x83;
CLKSEL = 0x00;
SFRPAGE = CONFIG_PAGE;
PLL0CN = 0x00;
SFRPAGE = LEGACY_PAGE;
FLSCL = 0x10;
SFRPAGE = CONFIG_PAGE;
PLL0CN |= 0x01;
PLL0DIV = 0x01;
PLL0FLT = 0x01;
PLL0MUL = 0x04;
for (loop=0; loop<256; loop );
PLL0CN |= 0x02;
while(!(PLL0CN & 0x10));
CLKSEL = 0x02;
SFRPAGE = SFRPAGE_SAVE;
}
/*Init*/
void Init()
{
//Конфигурирование таймеров
SFRPAGE = TIMER01_PAGE;
TCON = 0x51;
TMOD = 0x11;
CKCON = 0x18;
SFRPAGE = TMR3_PAGE;
TMR3CN = 0x04;
TMR3CF = 0x08;
RCAP3 = -SYSCLK/SAMPLE_RATE;
TMR3 = RCAP3;
EIE2 &= ~0x01;
TR3 = 1;
//запускаем на втором таймере Uart
SFRPAGE = TMR2_PAGE;
TMR2CF = 0x08; // Timer 2 Configuration
RCAP2 = - ((long) SYSCLK/BAUDRATEU0/16);
TMR2L = 0x00; // Timer 2 Low Byte
TMR2H = 0x00; // Timer 2 High Byte
TMR2CN = 0x04; // Timer 2 CONTROL
TR2 = 1;
SFRPAGE = UART0_PAGE;
SCON0 = 0x50;
SSTA0 = 0x05;
ES0 = 1;
//конфигурируем ADC(АЦП)
SFRPAGE = ADC0_PAGE;
AMX0SL = 0x01;
ADC0CN = 0x80;
SFRPAGE = ADC0_PAGE;
ADC0CN = 0x04;
REF0CN = 0x07;
AMX0CF = 0x00;
AMX0SL = 0x01;
ADC0CF = (SYSCLK/SAR_CLK) << 3;
ADC0CF |= 0x00; // Коэффициент усилителя PGA gain => 00 = 1 (default), 01 =2, 02 = 4, 03 = 8
EIE2 |= 0x02; // enable ADC interrupts
SFRPAGE = ADC0_PAGE;
ADC0CN = 0x84;
//Конфигурируем ножки контроллера
SFRPAGE = CONFIG_PAGE;
P0MDOUT = 0xFF;
P1MDOUT = 0xFF;
P2MDOUT = 0xFF;
P3MDOUT = 0xFF;*/
XBR0 = 0x44;
XBR1 = 0x04;
XBR2 = 0x40;
//Запускаем конфигурирование частоты
OSCILLATOR_Init();
//Конфигурируем прерывания
IE = 0x9B;
EIE2 |= 0x02;
//Расставляем приоритеты
IP = 0x13;
EIP2 = 0x02; //АЦП
}
Тут мы крутимся постоянно в бесконечном цикле, и отправляем полученные измерения АЦП
//-------------------------------------------------------------------
void main(void)
{
xdata unsigned int i=0, tmpint;
WDTCN = 0xde; //Останавливаем сторожевой таймер, чтобы контроллер не перезагружался
WDTCN = 0xad; // если есть желание, то можно контролировать с помощью него зависла программа или нет, и ребутнуть в аварийном режиме
EA=0; //отключаем все прерывания перед инициализацией
Init(); //проводим инициализацию
i = 0;
while(i < BUFADCSIZE)
{
BufADC[i]=0;
}
EA=1;
while(1)
{
if(RTC>(7*FREQT0))
{
IE0=1;
}
if(ProcessFlag == 1)
{
ADCFlag = 0;
flFree = 0;
EIE2 &= ~0x02; //АЦП выкл
//запускаем отправку по ком порту
tmpint = ADCcount;
ADCcount = 1;
while(ADCcount < tmpint)
{
//Write to UART0--------------------------------------
BufferInModem[0] = 40 | 0x40;
BufferInModem[0] &= ~0x80;
OutModem2((int)Propeller, 1);
OutModem2((int)ADCcount, 3);
OutModem2((int)BufADC[ADCcount ],5);
OutModem2((int)tmpint, 7);
r0 = 0;
rk = 9;
BufferInModem[rk] = 0;
for (i = r0; i < rk; i )
BufferInModem[rk] = BufferInModem[rk] ^ BufferInModem[i];
BufferInModem[rk] = BufferInModem[rk] | 0x80;
rk ;
flTransmiter = 1;
SFRPAGE = 0x00;
TI0 = 1;
RTC=0;
while(flTransmiter)
{
if(RTC>(RESETTICK))
{
RTC=0;
break;
}
}
RTC=0;
LED=0;
}
i = 0;
while(i < BUFADCSIZE)
{
BufADC[i]=0;
}
ADCcount = 0;
ProcessFlag = 0;
flFree = 1;
}
}
}
Создаем событие для прерывания с ножки, на которую подключен датчик холла
Чтобы точно знать сколько прошло времени, мы запускаем таймер, и считаем в нем время
Все данные снимаемые с АЦП записываем в буфер, чтобы потом передать всю пачку за один оборот. Такой способ позволил не тратить время на передачу во время снятия информации, как следствие шустрее работает и снимает больше точек.
Для того, чтобы как-то отделить нужные отклонения, на настольном приложении я решил применить преобразование Фурье, которое я до этого использовал для обработки картинок, немного поколдовав с бубном, получилось выделить нужные частоты.
Для разработки интерфейса я использовал C Builder 6.0
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "balansCom4.h"
#include <windows.h>
#include <vector.h>
#include "fstream.h"
#include "math.h"
//---------------------------------------------------------------------------
#define assert(ignore)((void)0)
#define BUFSIZE 4096
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CPort"
#pragma link "PERFGRAP"
#pragma resource "*.dfm"
TForm1 *Form1;
int N=1024,k=10;
ShortComplex arr[4096];
double Amp_F[4096];
double Phase_F[4096];
double Amp_max=0, Phase_max=0;
float r=0,rmax=0, fi=0, xx=0, yy=0;
float K_flt = 0.00005;
float Krmax = 0.05;
float kAmp = 0.1;
float a=1, b=0;
//---------------------------------------------------------------------------
bool perekl=false;
struct hComException{};
String tmptxt;
float RadMass[365], RadMassMax, j_max;
int fiMax, WACHDOG;
long data_i=0;
long bad = 0;
int V, Xlast, A, Alast, Vlast;
#define COM "Com5"
#define BodRate CBR_57600
#define TIMEOUT 3000
//---------------------------------------------------------------------------
Для выделения из полученного сигнала нужной частоты, очень полезным оказалось прямое и обратное преобразование Фурье. Данные льются непрерывным потоком, и чтобы успевать их обрабатывать, я применил оптимизированную версию, так называемую FFT. это не панацея, и для обработки видео потока лучше распаралеливать и использовать GPU, но для данной задачи, вполне применимо.
static unsigned char reverse256[]= {
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF,
};
static long double temp;
inline void operator =(ShortComplex &x, const Complex &y) { x.re = (double)y.re; x.im = (double)y.im; }
inline void operator-=(ShortComplex &x, const Complex &y) { x.re -= (double)y.re; x.im -= (double)y.im; }
inline void operator*=(Complex &x, const Complex &y) { temp = x.re; x.re = temp * y.re - x.im * y.im; x.im = temp * y.im x.im * y.re; }
inline void operator*=(Complex &x, const ShortComplex &y) { temp = x.re; x.re = temp * y.re - x.im * y.im; x.im = temp * y.im x.im * y.re; }
inline void operator/=(ShortComplex &x, double div) { x.re /= div; x.im /= div; }
//array exp(-2*pi*j/2^n) for n= 1,...,32
//exp(-2*pi*j/2^n) = Complex( cos(2*pi/2^n), -sin(2*pi/2^n) )
static Complex W2n[32]={
{-1.00000000000000000000000000000000, 0.00000000000000000000000000000000}, // W2 calculator (copy/paste) : po, ps
{ 0.00000000000000000000000000000000, -1.00000000000000000000000000000000}, // W4: p/2=o, p/2=s
{ 0.70710678118654752440084436210485, -0.70710678118654752440084436210485}, // W8: p/4=o, p/4=s
{ 0.92387953251128675612818318939679, -0.38268343236508977172845998403040}, // p/8=o, p/8=s
{ 0.98078528040323044912618223613424, -0.19509032202212826784828486847702}, // p/16=
{ 0.99518472667219688624483695310948, -9.80171403295606019941955638886e-2}, // p/32=
{ 0.99879545620517239271477160475910, -4.90676743274180142549549769426e-2}, // p/64=
{ 0.99969881869620422022576564966617, -2.45412285229122880317345294592e-2}, // p/128=
{ 0.99992470183914454092164649119638, -1.22715382857199260794082619510e-2}, // p/256=
{ 0.99998117528260114265699043772857, -6.13588464915447535964023459037e-3}, // p/(2y9)=
{ 0.99999529380957617151158012570012, -3.06795676296597627014536549091e-3}, // p/(2y10)=
{ 0.99999882345170190992902571017153, -1.53398018628476561230369715026e-3}, // p/(2y11)=
{ 0.99999970586288221916022821773877, -7.66990318742704526938568357948e-4}, // p/(2y12)=
{ 0.99999992646571785114473148070739, -3.83495187571395589072461681181e-4}, // p/(2y13)=
{ 0.99999998161642929380834691540291, -1.91747597310703307439909561989e-4}, // p/(2y14)=
{ 0.99999999540410731289097193313961, -9.58737990959773458705172109764e-5}, // p/(2y15)=
{ 0.99999999885102682756267330779455, -4.79368996030668845490039904946e-5}, // p/(2y16)=
{ 0.99999999971275670684941397221864, -2.39684498084182187291865771650e-5}, // p/(2y17)=
{ 0.99999999992818917670977509588385, -1.19842249050697064215215615969e-5}, // p/(2y18)=
{ 0.99999999998204729417728262414778, -5.99211245264242784287971180889e-6}, // p/(2y19)=
{ 0.99999999999551182354431058417300, -2.99605622633466075045481280835e-6}, // p/(2y20)=
{ 0.99999999999887795588607701655175, -1.49802811316901122885427884615e-6}, // p/(2y21)=
{ 0.99999999999971948897151921479472, -7.49014056584715721130498566730e-7}, // p/(2y22)=
{ 0.99999999999992987224287980123973, -3.74507028292384123903169179084e-7}, // p/(2y23)=
{ 0.99999999999998246806071995015625, -1.87253514146195344868824576593e-7}, // p/(2y24)=
{ 0.99999999999999561701517998752946, -9.36267570730980827990672866808e-8}, // p/(2y25)=
{ 0.99999999999999890425379499688176, -4.68133785365490926951155181385e-8}, // p/(2y26)=
{ 0.99999999999999972606344874922040, -2.34066892682745527595054934190e-8}, // p/(2y27)=
{ 0.99999999999999993151586218730510, -1.17033446341372771812462135032e-8}, // p/(2y28)=
{ 0.99999999999999998287896554682627, -5.85167231706863869080979010083e-9}, // p/(2y29)=
{ 0.99999999999999999571974138670657, -2.92583615853431935792823046906e-9}, // p/(2y30)=
{ 0.99999999999999999892993534667664, -1.46291807926715968052953216186e-9}, // p/(2y31)=
};
void fft(ShortComplex *x, int T, bool complement)
{
unsigned int I, J, Nmax, N, Nd2, k, m, mpNd2, Skew;
unsigned char *Ic = (unsigned char*) &I;
unsigned char *Jc = (unsigned char*) &J;
ShortComplex S;
ShortComplex *Wstore, *Warray;
Complex WN, W, Temp, *pWN;
Nmax = 1 << T;
//first interchanging
for(I = 1; I < Nmax - 1; I )
{
Jc[0] = reverse256[Ic[3]];
Jc[1] = reverse256[Ic[2]];
Jc[2] = reverse256[Ic[1]];
Jc[3] = reverse256[Ic[0]];
J >>= (32 - T);
if (I < J)
{
S = x[I];
x[I] = x[J];
x[J] = S;
}
}
//rotation multiplier array allocation
Wstore = new ShortComplex[Nmax / 2];
Wstore[0].re = 1.0;
Wstore[0].im = 0.0;
//main loop
for(N = 2, Nd2 = 1, pWN = W2n, Skew = Nmax >> 1; N <= Nmax; Nd2 = N, N = N, pWN , Skew >>= 1)
{
//WN = W(1, N) = exp(-2*pi*j/N)
WN= *pWN;
if (complement)
WN.im = -WN.im;
for(Warray = Wstore, k = 0; k < Nd2; k , Warray = Skew)
{
if (k & 1)
{
W *= WN;
*Warray = W;
}
else
W = *Warray;
for(m = k; m < Nmax; m = N)
{
mpNd2 = m Nd2;
Temp = W;
Temp *= x[mpNd2];
x[mpNd2] = x[m];
x[mpNd2] -= Temp;
x[m] = Temp;
}
}
}
delete [] Wstore;
if (complement)
{
for( I = 0; I < Nmax; I )
x[I] /= Nmax;
}
}
Готовим GUI, и настраиваем COM порт для приема.
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
for(int i=0; i<362; i )
RadMass[i]=0;
RadMassMax=0;
Image1->Canvas->Rectangle(0,0,Image1->Width, Image1->Height);
int i=0;
float r, fi=0;
float xx, yy;
while(i<100)
{
Image1->Canvas->Pen->Color=clGreen;
i=i 10;
r=i;
fi=0;
while(fi<360)
{
fi=fi 1;
xx = r*cos(fi) Image1->Width/2;
yy = r*sin(fi) Image1->Height/2;
Image1->Canvas->Ellipse((int)xx,(int)yy, (int)xx 2,(int)yy 2);
}
}
Image1->Canvas->Pen->Color=clBlack;
Button2Click(Owner);
flEdit=0;
hCom = CreateFile(COM,GENERIC_READ | GENERIC_WRITE,0,NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
if( hCom == INVALID_HANDLE_VALUE )
{
ShowMessage("Com port error");
CloseHandle(hCom);
Stat->SimpleText="Com port error";
}
else
{
SetCommMask(hCom, EV_RXCHAR);
SetupComm(hCom, 1500, 1500);
CommTimeOuts.ReadIntervalTimeout = MAXDWORD;
CommTimeOuts.ReadTotalTimeoutMultiplier = TIMEOUT;
CommTimeOuts.ReadTotalTimeoutConstant = TIMEOUT;
CommTimeOuts.WriteTotalTimeoutMultiplier = TIMEOUT;
CommTimeOuts.WriteTotalTimeoutConstant = TIMEOUT;
if(!SetCommTimeouts(hCom, &CommTimeOuts))
{
hCom = 0;
throw hComException();
}
memset(&dcb, 0, sizeof(dcb));
dcb.DCBlength = sizeof(DCB);
GetCommState(hCom, &dcb);
dcb.BaudRate = BodRate;
dcb.fParity = 0;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
dcb.fAbortOnError = FALSE;
dcb.fDtrControl = DTR_CONTROL_DISABLE;
dcb.fRtsControl = RTS_CONTROL_DISABLE;
dcb.fBinary = TRUE;
dcb.fParity = FALSE;
dcb.fInX = FALSE;
dcb.fOutX = FALSE;
dcb.XonChar = 0;
dcb.XoffChar = (unsigned char)0xFF;
dcb.fErrorChar = FALSE;
dcb.fNull = FALSE;
dcb.fOutxCtsFlow = FALSE;
dcb.fOutxDsrFlow = FALSE;
dcb.XonLim = 128;
dcb.XoffLim = 128;
SetCommState(hCom,&dcb);
PurgeComm(hCom, PURGE_RXCLEAR);
begin = GetTickCount();
tmptxt = COM;
tmptxt = " br";
tmptxt = dcb.BaudRate;
tmptxt = " p";
tmptxt = dcb.Parity;
tmptxt = " By";
tmptxt = dcb.ByteSize;
tmptxt = " sb";
tmptxt = dcb.StopBits;
Stat->SimpleText= tmptxt;
overlapped.hEvent = CreateEvent(NULL, true, true, NULL);
}
}
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
CloseHandle(hCom);
}
Решил приделать функции сохранения и загрузки, чтобы можно было как-то поднимать данные при необходимости, хотя совершенно необязательно для стенда. Данные хоть и сохранялись, в будущем никогда не использовались, поэтому можно не делать.
void TForm1::SaveToFile(String FileName)
{
fstream file_;
file_.open(FileName.c_str(), ios::out);
if (!file_)
{
file_.close();
return;
}
int count_ = 0, tmp_count;
tmp_count = Series1->XValues->MaxValue-1;
if(tmp_count>(Series2->XValues->MaxValue-1))
tmp_count = Series2->XValues->MaxValue-1;
if(tmp_count>(Series6->XValues->MaxValue-1))
tmp_count = Series6->XValues->MaxValue-1;
while(count_ < tmp_count)
{
int a1Propeller = Series1->YValue[count_];
int a2X1 = Series2->YValue[count_];
int a6Ugol = Series6->YValue[count_];
file_ << a1Propeller << " " << a2X1 << " " << a6Ugol << " " ;
}
file_.close();
}
void TForm1::LoadFromFile(String FileName)
{
fstream file;
file.open(FileName.c_str());
if (!file)
{
file.close();
return;
}
float a1Propeller = 0, a2X1 = 0, a6Ugol = 0;
Series1->Clear();
Series2->Clear();
Series6->Clear();
long file_i=0;
file_i=0;
while(!file.eof())
{
file >> a1Propeller >> a2X1 >> a6Ugol;
Application->ProcessMessages();
Series1->Add(a1Propeller);
Series2->Add(a2X1);
Series6->Add(a6Ugol);
Dannye->Cells[0][0]="Propeller";
Dannye->Cells[1][0]=a1Propeller;
Dannye->Cells[0][1]="X1";
Dannye->Cells[1][1]=a2X1;
float r, fi, xx, yy;
r = (Image1->Height/2)*(a*a2X1-b)/4095;
fi = a6Ugol;
RadMass[(int)fi]=RadMass[(int)fi] (r-RadMass[(int)fi])*Krmax;
if(RadMass[(int)fi]>RadMassMax)
{
float lastRadMax;
int lastfiMax;
lastfiMax = fiMax;
lastRadMax = RadMass[lastfiMax];
Image1->Canvas->Pen->Color=clWhite;
Image1->Canvas->MoveTo(Image1->Width/2, Image1->Height/2);
xx= lastRadMax*cos(lastfiMax) Image1->Width/2;
yy= lastRadMax*sin(lastfiMax) Image1->Height/2;
Image1->Canvas->LineTo(xx, yy);
Image1->Canvas->MoveTo(xx, yy 1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2 1);
Image1->Canvas->MoveTo(xx, yy-1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2-1);
Image1->Canvas->MoveTo(xx 1, yy);
Image1->Canvas->LineTo(Image1->Width/2 1, Image1->Height/2);
Image1->Canvas->MoveTo(xx-1, yy);
Image1->Canvas->LineTo(Image1->Width/2-1, Image1->Height/2);
RadMassMax = RadMass[(int)fi];
fiMax = fi;
lastRadMax = RadMassMax;
lastfiMax = fiMax;
Image1->Canvas->Pen->Color=clRed;
Image1->Canvas->MoveTo(Image1->Width/2, Image1->Height/2);
xx= RadMassMax*cos(2*M_PI*fiMax/360) Image1->Width/2;
yy= RadMassMax*sin(2*M_PI*fiMax/360) Image1->Height/2;
Image1->Canvas->LineTo(xx, yy);
Image1->Canvas->MoveTo(xx, yy 1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2 1);
Image1->Canvas->MoveTo(xx, yy-1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2-1);
Image1->Canvas->MoveTo(xx 1, yy);
Image1->Canvas->LineTo(Image1->Width/2 1, Image1->Height/2);
Image1->Canvas->MoveTo(xx-1, yy);
Image1->Canvas->LineTo(Image1->Width/2-1, Image1->Height/2);
Image1->Canvas->Pen->Color=clBlack;
Dannye->Cells[0][3]="Дисбаланс";
Dannye->Cells[1][3]= (int)RadMassMax;
}
xx = r*cos(2*M_PI*fi/360) Image1->Width/2;
yy = r*sin(2*M_PI*fi/360) Image1->Height/2;
Image1->Canvas->Ellipse((int)xx,(int)yy, (int)xx 2,(int)yy 2);
if (file_i > (N 1))
{
int count_= 0;
while(count_ < N)
{
arr[count_].re= Series2->YValue[count_ file_i-N];
arr[count_ ].im= 0.0;
}
Series7->Clear();
Series8->Clear();
fft(arr, k, false);
int i=0;
double nSamplesPerSec;
int Nmax= (N 1) / 2;
double *freq= new double[Nmax];
double *amp= new double[Nmax];
double *phase= new double[Nmax];
int j= 0;
double limit= 0.001;
double abs2min= limit * limit * N * N;
double abs2max= 10E150;
if (arr[i].re >= limit)
{
amp[j]= arr[i].re / N;
freq[j]= 0.0;
phase[j]= 0.0;
j;
}
i;
for(i= 1; i < Nmax; i)
{
double re= arr[i].re;
double im= arr[i].im;
long double abs2;
abs2 = re * re im * im;
if (abs2 < abs2min)
continue;
if (abs2 > abs2max)
abs2=abs2max;
amp[j]= 2.0 * sqrt((double)abs2) / N;
Amp_F[j] = Amp_F[j] (amp[j]-Amp_F[j])*K_flt;
Series7->Add(Amp_F[j]);
phase[j]= atan2(im, re);
phase[j] = M_PI_2;
if (phase[j] > M_PI)
phase[j]-= 2*M_PI;
phase[j]= phase[j] * M_PI / 180.0;
Phase_F[j] = Phase_F[j] (phase[j] - Phase_F[j])*K_flt;
Series8->Add(Phase_F[j]);
freq[j]= (nSamplesPerSec * i) / N;
j;
}
delete[] amp;
delete[] freq;
delete[] phase;
}
file_i ;
}
file.close();
return;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
String FileName_;
FileName_ = ExtractFilePath(Application->ExeName);
FileName_ = "Data\";
FileName_ = FormatDateTime("dd_mmm_yyy'-'hh_nn'",Now());
SaveDialog1->FileName = FileName_;
if(SaveDialog1->Execute())
{
SaveToFile(SaveDialog1->FileName);
flEdit=0;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
if(OpenDialog1->Execute())
{
LoadFromFile(OpenDialog1->FileName);
}
}
Чтобы прием и расшифровка буфера происходила автоматически, я сделал возможность делать это по таймеру, не совсем удачная идея, сейчас бы я сделал по другому, я бы собирал данные по приходу в отдельном потоке, и передавал на вывод, чтобы не мешать интерфейсу ввода и другим приложениям. Однако и такой вариант оказался жизнеспособным, и со своей задачей справился вполне успешно.
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
if(CheckBox1->Checked)
{
flEdit=1;
int Propeller, X1, ADCcount, ADCcountMax, Amax;
unsigned char tmp40;
int attempts = 3, nLetter40 = 11;
int rBUF=0, wBUF=0, marBUF=0;
feedback = 0;
BYTE data1[BUFSIZE];
vector<unsigned char> data(data1, data1 BUFSIZE);
unsigned char* buf = &data[0];
ADCcountMax=0;
WaitCommEvent(hCom, &mask, &overlapped);
signal = WaitForSingleObject(overlapped.hEvent, 7000);
if(signal == WAIT_OBJECT_0)
{
if(GetOverlappedResult(hCom, &overlapped, &feedback, true))
if((mask & EV_RXCHAR)!=0)
{
ClearCommError(hCom, &feedback, &comstat);
btr = comstat.cbInQue;
if(btr)
{
ReadFile(hCom, buf, btr, &feedback, &overlapped);
wBUF =btr;//(DWORD)data.size();
if(wBUF >= BUFSIZE)
{
wBUF = 0;
marBUF = 1;
}
}
while(rBUF < (wBUF (marBUF*BUFSIZE)))
{
unsigned char tmpBuf = data[rBUF];
tmpBuf = tmpBuf&~0x80;
if(tmpBuf==(0x40 | 40))
{
nLetter40=0;
tmp40 = 0;
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==0 && (data[rBUF]>>7)==1)
{
nLetter40 ;
Propeller = data[rBUF]&~0x80;
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==1 && (data[rBUF]>>7)==1)
{
nLetter40 ;
Propeller |= ((int)(data[rBUF]&~0x80)<<7);
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==2 && (data[rBUF]>>7)==1)
{
nLetter40 ;
ADCcount = data[rBUF]&~0x80;
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==3 && (data[rBUF]>>7)==1)
{
nLetter40 ;
ADCcount |= ((int)(data[rBUF]&~0x80)<<7);
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==4 && (data[rBUF]>>7)==1)
{
nLetter40 ;
X1 = data[rBUF]&~0x80;
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==5 && (data[rBUF]>>7)==1)
{
nLetter40 ;
X1 |= ((int)(data[rBUF]&~0x80)<<7);
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==6 && (data[rBUF]>>7)==1)
{
nLetter40 ;
Amax = data[rBUF]&~0x80;
tmp40 = tmp40 ^ data[rBUF];
}
else if(nLetter40==7 && (data[rBUF]>>7)==1)
{
nLetter40 ;
Amax |= ((int)(data[rBUF]&~0x80)<<7);
tmp40 = tmp40 ^ data[rBUF ];
tmp40 = tmp40 | 0x80;
float Angle=400;
if(Amax>0)
Angle = 360*ADCcount/Amax;
if(tmp40 != 0x80 && tmp40 == data[rBUF]
&& ADCcount>0 && X1<4096 && X1>0 && Amax>0
&& Propeller<1000 && Propeller>100 && Angle>=0
&& Angle<=360)
{
//Chart1->BottomAxis->Scroll(1, false);
Dannye->Cells[0][0]="Обороты";
Dannye->Cells[1][0]=Propeller;
Series1->Add(Propeller);
Dannye->Cells[0][1]="X1";
Dannye->Cells[1][1]=X1;
V=Xlast-X1;
A=Vlast-V;
Vlast=V;
Alast=A;
Series2->Add(X1);
Series6->Add(360*ADCcount/Amax);
if (data_i > (N 1))
{
int count_= 0;
while(count_ < N)
{
arr[count_].re= Series2->YValue[count_ data_i-N];
arr[count_ ].im= 0.0;
}
Series7->Clear();
Series8->Clear();
fft(arr, k, false);
int i=0;
double nSamplesPerSec;
int Nmax= (N 1) / 2;
double *freq= new double[Nmax];
double *amp= new double[Nmax];
double *phase= new double[Nmax];
int j= 0;
double limit= 0.001;
double abs2min= limit * limit * N * N;
double abs2max= 10E150;
if (arr[i].re >= limit)
{
amp[j]= arr[i].re / N;
freq[j]= 0.0;
phase[j]= 0.0;
j;
}
i;
for(i= 1; i < Nmax; i)
{
double re= arr[i].re;
double im= arr[i].im;
long double abs2;
abs2 = re * re im * im;
if (abs2 < abs2min)
continue;
if (abs2 > abs2max)
abs2=abs2max;
amp[j]= 2.0 * sqrt((double)abs2) / N;
//Series7->Add(amp[j]);
Amp_F[j] = Amp_F[j] (amp[j]-Amp_F[j])*K_flt;
Series7->Add(Amp_F[j]);
phase[j]= atan2(im, re);
phase[j] = M_PI_2;
if (phase[j] > M_PI)
phase[j]-= 2*M_PI;
phase[j]= phase[j] * M_PI / 180.0;
//Series8->Add(phase[j]);
Phase_F[j] = Phase_F[j] (phase[j] - Phase_F[j])*K_flt;
Series8->Add(Phase_F[j]);
freq[j]= (nSamplesPerSec * i) / N;
j;
}
delete[] amp;
delete[] freq;
delete[] phase;
for(i= 0; i<Nmax; i )
{
if(i>(j_max 1))
arr[i].re = 0;
arr[i].im = 0;
}
fft(arr, k, true);
/*
count_= 0;
while(count_ < N)
{
Series4->Add(arr[count_ ].re);
} */
Series4->Add(arr[(N-1)].re);
float r, fi, xx, yy;
r = (Image1->Height/2)*(a*arr[(N-1)].re-b)/4095;
//X1=arr[1023].re; ///!!!!!!!!!!
fi = 360*(ADCcount)/Amax;
xx= r*cos(2*M_PI*fi/360) Image1->Width/2;
yy= r*sin(2*M_PI*fi/360) Image1->Height/2;
Image1->Canvas->Pen->Color = clYellow;
Image1->Canvas->Ellipse((int)xx,(int)yy, (int)xx 2,(int)yy 2);
}
else
{
Series4->Add(X1);
}
Image1->Canvas->Pen->Color = clBlack;
data_i ;
Dannye->Cells[0][2]="Измерений на круг";
Dannye->Cells[1][2]=Amax;
float r, fi, xx, yy;
r = (Image1->Height/2)*(a*X1-b)/4095;
fi = 360*(ADCcount)/Amax;
if(X1>0 && X1<4095 && fi<361 && fi >0)
{
//Черные точки
xx = r*cos(2*M_PI*fi/360) Image1->Width/2;
yy = r*sin(2*M_PI*fi/360) Image1->Height/2;
Image1->Canvas->Ellipse((int)xx,(int)yy, (int)xx 2,(int)yy 2);
X1=arr[(N-1)].re; ///!!!!!!!!!!
r = (Image1->Height/2)*(a*X1-b)/4095;
RadMass[(int)fi]=RadMass[(int)fi] (r-RadMass[(int)fi])*Krmax;
//Красные точки
xx= RadMass[(int)fi]*cos(2*M_PI*fi/360) Image1->Width/2;
yy= RadMass[(int)fi]*sin(2*M_PI*fi/360) Image1->Height/2;
Image1->Canvas->Pen->Color = clYellow;
Image1->Canvas->Ellipse((int)xx,(int)yy, (int)xx 2,(int)yy 2);
Image1->Canvas->Pen->Color = clBlack;
if(RadMass[(int)fi]>RadMassMax)
{
Image1->Canvas->Pen->Color=clWhite;
Image1->Canvas->MoveTo(Image1->Width/2, Image1->Height/2);
xx= RadMassMax*cos(2*M_PI*fiMax/360) Image1->Width/2;
yy= RadMassMax*sin(2*M_PI*fiMax/360) Image1->Height/2;
Image1->Canvas->LineTo(xx, yy);
Image1->Canvas->MoveTo(xx, yy 1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2 1);
Image1->Canvas->MoveTo(xx, yy-1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2-1);
Image1->Canvas->MoveTo(xx 1, yy);
Image1->Canvas->LineTo(Image1->Width/2 1, Image1->Height/2);
Image1->Canvas->MoveTo(xx-1, yy);
Image1->Canvas->LineTo(Image1->Width/2-1, Image1->Height/2);
RadMassMax = RadMass[(int)fi];
fiMax = (int)fi;
Image1->Canvas->Pen->Color=clRed;
Image1->Canvas->MoveTo(Image1->Width/2, Image1->Height/2);
xx= RadMassMax*cos(2*M_PI*fiMax/360) Image1->Width/2;
yy= RadMassMax*sin(2*M_PI*fiMax/360) Image1->Height/2;
Image1->Canvas->LineTo(xx, yy);
Image1->Canvas->MoveTo(xx, yy 1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2 1);
Image1->Canvas->MoveTo(xx, yy-1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2-1);
Image1->Canvas->MoveTo(xx 1, yy);
Image1->Canvas->LineTo(Image1->Width/2 1, Image1->Height/2);
Image1->Canvas->MoveTo(xx-1, yy);
Image1->Canvas->LineTo(Image1->Width/2-1, Image1->Height/2);
Image1->Canvas->Pen->Color=clBlack;
Dannye->Cells[0][6]="Дисбаланс";
Dannye->Cells[1][6]= (int)RadMassMax;
Dannye->Cells[0][7] ="Угол";
Dannye->Cells[1][7] =(int)fiMax;
}
RadMassMax = RadMass[(int)fiMax];
}
}
else
{
bad ;
}
String tmp_txt;
if(Amax>0)
j_max = (int)((float)N/(float)Amax);
Amp_max = Amp_max ((Amp_F[(int)j_max] Amp_F[(int)j_max-1] Amp_F[(int)j_max 1])/3. - Amp_max)*kAmp;
Phase_max = Phase_F[(int)j_max];
Dannye->Cells[0][3]="Амплитуда";
Dannye->Cells[1][3]=(int)Amp_max;
Dannye->Cells[0][4]="Частота и Фаза";
tmp_txt = j_max;
tmp_txt = " |";
tmp_txt =Phase_max;
Dannye->Cells[1][4]=tmp_txt;
Dannye->Cells[0][5]="Ошибки приема";
if(data_i>0)
{
tmp_txt = (int)(100*bad/(data_i bad));
tmp_txt =" %";
}
else
{
tmp_txt = "100%";
}
Dannye->Cells[1][5]=tmp_txt.c_str();
}
if(rBUF >= BUFSIZE)
{
rBUF = 0;
marBUF = 0;
}
}
memset(buf, 0, BUFSIZE);
}
}
else
{
CheckBox1->Checked = false;
}
delete[] buf;
}
}
Чтобы можно было все очистить и начать заново, сделал кнопку очистить и функцию, которая зачищает и перерисовывает поле с накопленными данными.
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Series1->Clear();
Series2->Clear();
Series3->Clear();
Series4->Clear();
Series5->Clear();
Series6->Clear();
Series7->Clear();
Series8->Clear();
r=0;
rmax=0;
fi=0;
xx=0;
yy=0;
data_i = 0; bad=0;
Image1->Canvas->Rectangle(0,0,Image1->Width, Image1->Height);
rmax = 0.3*sqrt(Image1->Width*Image1->Width Image1->Height*Image1->Height);
Image1->Canvas->Pen->Color=clBlue;
r = rmax;
while(fi<360)
{
if(fi>1)
{
Image1->Canvas->Pen->Color=clGreen;
}
xx = r*cos(2*M_PI*fi/360) Image1->Width/2;
yy = r*sin(2*M_PI*fi/360) Image1->Height/2;
Image1->Canvas->MoveTo(Image1->Width/2, Image1->Height/2);
Image1->Canvas->LineTo(xx, yy);
if(fi<=1){
Image1->Canvas->MoveTo(xx, yy 1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2 1);
Image1->Canvas->MoveTo(xx, yy-1);
Image1->Canvas->LineTo(Image1->Width/2, Image1->Height/2-1);
Image1->Canvas->MoveTo(xx 1, yy);
Image1->Canvas->LineTo(Image1->Width/2 1, Image1->Height/2);
Image1->Canvas->MoveTo(xx-1, yy);
Image1->Canvas->LineTo(Image1->Width/2-1, Image1->Height/2);
}
fi=fi 30;
}
r=0;
do
{
r=r 15;
fi=0;
while(fi<360)
{
fi=fi 1;
xx = r*cos(2*M_PI*fi/360) Image1->Width/2;
yy = r*sin(2*M_PI*fi/360) Image1->Height/2;
Image1->Canvas->Ellipse((int)xx,(int)yy, (int)xx 2,(int)yy 2);
}
}while(r<rmax);
Image1->Canvas->Pen->Color=clRed;
fi=0;
while(fi<360)
{
fi=fi 1;
r=RadMass[(int)fi];
xx = r*cos(2*M_PI*fi/360) Image1->Width/2;
yy = r*sin(2*M_PI*fi/360) Image1->Height/2;
//Image1->Canvas->LineTo(xx, yy);
Image1->Canvas->Ellipse((int)xx,(int)yy, (int)xx 2,(int)yy 2);
}
Image1->Canvas->Pen->Color=clRed;
for(int i=0; i<4; i )
{
Image1->Canvas->MoveTo(Image1->Width/2 i, Image1->Height/2 i);
Image1->Canvas->LineTo(RadMassMax*cos(2*M_PI*fiMax/360) Image1->Width/2 i, RadMassMax*sin(2*M_PI*fiMax/360) Image1->Height/2 i);
}
for(int i=0; i<362; i )
RadMass[i]=0;
RadMassMax=0;
for(int i=0; i<4095; i )
{
Amp_F[i]=0;
Phase_F[i]=0;
arr[i].re=0;
arr[i].im=0;
}
Image1->Canvas->Pen->Color=clBlack;
}
Чтобы иметь возможность постепенно увеличивать чувствительность на графическом поле отклонения баланса, добавил переключатель чувствитльности.
В итоге получилась довольно удобная программка, которая показывает, в какую сторону существует дисбаланс, и приноровившись приклеивая кусочки аракала по 0,15г удалось достаточно точно отбалансировать винт.
/Сама программка в работе/
Если посмотреть на пики по частотам, то можно заметить, что ярко выражены две амплитуды, как выяснилось одна отвечает за вибрацию винта, а вторая создается электромотором, так как он подключен через ремень и крутиться быстрее. Таким образом балансируя винт мы минимизируем первый пик, прикрепляя грузик соразмерный с отклонением круга, на противоположенную сторону.
Как откалибровать дорогие модели?
Первое, что следует сделать, — это поместить на основную ось колесо сбалансированного типа с последующей фиксацией при помощи опорных стоек. Далее пользователем задается в программном режиме ширина и диаметр колесной части, а также расстояние опор до внешней поверхности. Если устройство не может определить данные значения автоматически, следует использовать кронциркуль и линейку выдвижного типа.
После выполнения вышеперечисленных действий пользователю необходимо зажать клавиши «C» и «F» до тех пор, пока на основном табло не появится надпись вида «CAL». Данное значение обычно появляется спустя несколько секунд, что сигнализирует о начале настройки. Следует отметить, что клавиши следует удерживать до тех пор, пока вышеописанная надпись не перестанет мигать — в противном случае калибровка не начнется.
По завершении мигания следующее, что необходимо сделать, — это нажать на физическую кнопку Start.
Далее пользователем в программном режиме вводится калибровочный груз — для начала лучше использовать определенное металлическое изделие с точным весом в 100 г. Для установки данного значения необходимо нажать на кнопку «ADD 100» и добавить выбранный груз на внешнюю сторону колесной части.
После того как груз был добавлен, а пользователь нажал на кнопку «ADD 100», автоматическая система начнет процесс калибровки. В данном случае следует выждать определенное количество времени для завершения полного цикла настройки — оборудование самостоятельно выдаст оповещение с надписью END CALL. Далее груз и колесо убирается со станка, а полученные данные выписываются или отправляются в любой удобный цифровой формат.
Следует обратить внимание на то, что калибровочное устройство достаточно легко создается своими руками. Для того чтобы изготовить анализируемое оборудование, необходимо воспользоваться следующей пошаговой инструкцией.
- Создание основного вала. Металлическую конструкцию следует вытачать так, чтобы в изделии было предусмотрено место для будущей установки подшипников. На другом конце следует проделать небольшую резьбу, куда в последующем будет вмонтирована шайба.
- Установка подшипников. Специалисты рекомендуют использовать подшипники, которые ранее уже использовались, однако не полностью израсходовали собственный ресурс. Подобный совет позволит достичь минимального показателя сопротивления.
- Формирование главной стойки. В данном случае пользователю следует установить на вал стойку, которую лучше всего изготовить из профильной трубы диаметром в 5,3 см. На верхней стороне металлического изделия дополнительно монтируются опорные части.
- Установка мотоциклетного колеса. Между опорами стойки производится установка мотоциклетного колеса. Оборудование можно дополнительно оснастить фиксирующей гайкой и раскосом.
Для основания обычно берется стальной лист в 5 мм толщиной и габаритами в 35×50 см, чего более чем достаточно для правильного изготовления самодельного устройства. Дополнительно пользователь может зафиксировать станок при помощи тавровых отрезков в 135-140 мм длины.
Калибровка балансировочного станка и ошибки при работе на нём
Во время работы на балансировочном станке могут происходит различные сбои и поломки. Раскалибровка, это одна из проблем, которая может возникнуть.
Раскалибровка возникает из-за:
1) Перепада напряжения. Дабы не допустить такого, рекомендуем установить стабилизатор напряжения.
2) Удары по валу или корпусу балансировочного станка. Сильное физическое воздействие также может спровоцировать раскалибровку.
Калибровка балансировочного станка.
- Калибровка тракта измерения дистанции.
Для оценки погрешности устройства ввода дистанции выдвиньте штангу ввода параметров и уприте внешнюю боковую сторону её рукоятки в задний торец фланца вала (рис 1). При этом на экране ввода геометрических параметров (рис.2) появится величина дистанции. Если величина дистанции не равна 117±5 мм, то устройство ввода дистанции требует калибровки.
Нажмите кнопку «MENU», в открывшемся окне выберите пункт 5 «Калибровка». Выберите пункт 2 «Калибровка дистанции» (рис. 3). Выдвиньте штангу ввода параметров, уприте внешнюю боковую сторону её рукоятки в задний торец фланца вала, и нажмите кнопку «Enter». В окне «Калибровка дистанции» выделится второй пункт 2. Вставьте ручку дистанции в отверстие 2. Нажмите кнопку «Enter».
Если вы хотите откалибровать только тракт измерения дистанции и не переходить к калибровке тракта измерения диаметра, нужно выйти из «Menu», «Калибровка дистанции» для этого нажмите кнопку «Start». Появится «Параметры записаны», а на экране появится изображение основного рабочего экрана.
- Калибровка тракта ввода диаметра диска колеса.
Установите на вал станка шаблон для калибровки. Вставьте наконечник рукоятки выдвижной штанги в нижнее отверстие шаблона и нажмите «Enter». В окне «Калибровка дистанции» выделите пункт 3. Вставьте ручку дистанции в отверстие 4, нажмите кнопку «Enter». Выполните указание по пункту 2, в окне «Калибровка дистанции» появится фраза «Параметры записаны». Нажмите кнопку «STOP» для возврата к основному рабочему экрану.
Процесс калибровки вы можете посмотреть на видео.
Список возможных ошибок при работе на балансировочном станке
Код ошибки | Наименование ошибки и вероятная причина | Метод устранения |
Err 1 | Не правильное направление вращения вала либо ошибка ротационного датчика. | Поменять местами 2 фазы 380 B либо выполнить операции как при ошибках 6 и 8. |
Err 2 | Ошибка EEPROM. Нет контакта с D9 или она неисправна. | Заменить плату вычисления. |
Err 3 | Ошибки параметров станка | Произвести стирание параметров станка, если код ошибки сохранится, то нужно заменить плату вычисления. |
Err 4 | Ошибка усилителя сигнала пьезодатчиков. Напряжение на входах АЦП <0.8 В или >2.3 В | Проверить напряжение питания платы ±5 В и -5В. Если они в норме, возможно появление утечек из-за отсыревания. Нужно просушить станок и плату вычислителя или заменить плату вычислителя. |
Err 5 | Ошибка параметра балансировки вала | Если ошибка возникает при включении станка и повторяется. Произведите действия как при ошибке Err 3. Если ошибка возникает при балансировке, это означает что сигналы с датчиков превышают допустимое значение. |
Err 6 | Ошибка нулевого отсчёта ротационного датчика | Отрегулировать положение ротационного датчика и проверить чистоту диска с метками на шкифе. |
Err 7 | Остановка вала в процессе измерения | Устранить причину остановки |
Err 8 | Ошибка ротационного датчика | Проверить положение ротационного датчика и чистоту диска с метками |
Err 9 | Замкнуты кнопки клавиатуры при включении станка | Заменить клавиатуру |
Err 10 | Нет сигнала с частотного преобразователя | Проверить предохранитель на частотном преобразователе. |
Загрузка...