Na podstawie schematu od kolegi wyżej robiłem symulację (ale z 5 na 24VDC)
Później doślę z podłączonym tranzystorem. Symulację robiłem w LTSpice.
Nie testowałem tego jeszcze w praktyce, ale daje to już pewien obraz jak to działa:)
Druga sprawa. Właśnie pomiar sinusa - czyli uściślając próba zebrania takiej ilości próbek z przetwornika AC aby wyłapać ten kształt sinusoidy.
Początkowo próbowałem to robić w czasie rzeczywistym -czyli biorę próbkę i wysyłam. ale choćby niewiadomo jak bardzo się starał czy zwiększał szybkość nie otrzymywałem dobrego wyniku.
Zrobiłem więc to tak że w przerwaniu o częstotliwości 20kHz pobieram 100próbek (można więcej lub mniej, ale 100 było optymalnie), zapisuję je do tablicy z danymi. Kiedy wszystkie próbki są zapisane - blokuję pomiary, a raczej zapis tych próbek do tablicy i bierzemy się za wysyłanie. Wynik był obiecujący - wychodziła taka zamazana piła, czy bardziej koślawa sinusoida, ale też zamazanie było spowodowane dużą iloscią zakłóceń na płytce - oscyloskop wskazywał że co chwilę sinusoida się "powielała".
Kodzik dla STM32F1 - bez bicia się przyznam że funkcja przerwania jest z książki o STM, ale te biblioteki można ściągnąć za darmo i legalnie ze strony wydawcy - czy gdzieś w okolicach. Funkcję lekko (naprawdę symbolicznie) zmodyfikowałem dla własnych potrzeb.
[syntax=c]#include "stm32f10x_conf.h"
#include <stdio.h>
#define ADC1_DR_Address ((uint32_t)0x4001244C)
///////////////zmienne z przetwornika AC
volatile uint16_t ADCVal[2];
volatile uint32_t WARTOSC_ANALOGOWA[1000];
volatile uint16_t LICZ_ANAL=0;
volatile uint32_t WART_SREDNIA = 0; //Wartoć rednia z AC
volatile uint16_t LICZ_SRED_ANAL = 0; //licznik srednich
/////////////////////////////////////////
/////////////////////Zmienne USART
volatile char DANE_DO_WYSYLKI[6];
volatile int flaga_wyslania = 0;
volatile int LICZ_WYSLANIA = 0;
volatile int WYSYLKA=0;
//////////////////////zmienne usart
unsigned char bufTxIndex=0;
volatile int Indeks_wysylki = 1;
unsigned char buforTx[20];
unsigned char bufRxIndex=0;
int odebranoDane=0;
unsigned char buforRx[17]={0};
volatile int START_WYSYLKI = 0;
void RCC_CONF(void);
void AC_cf(void);
void GPIO_CF(void);
void TIM_4_CF(void);
void NVIC_CF(void);
void USART_CF(void);
void TIM4_IRQHandler(void)
{
if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
{
if(LICZ_ANAL<100 && flaga_wyslania == 0)
{
WARTOSC_ANALOGOWA[LICZ_ANAL] = ADCVal[0];
LICZ_ANAL++;
}
if(LICZ_ANAL==100){
flaga_wyslania = 1;
}
if(flaga_wyslania==1 && LICZ_WYSLANIA<100)
{
sprintf(buforTx, "%d%s", WARTOSC_ANALOGOWA[LICZ_WYSLANIA],"E");
LICZ_WYSLANIA++;
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
}
if(flaga_wyslania==1 && LICZ_WYSLANIA>=100) {
LICZ_ANAL=0;
LICZ_WYSLANIA=0;
flaga_wyslania=0;
}
TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
}
}
///////////////////////////////////////////////////////////////////////
void USART1_IRQHandler(void)
{
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
{
buforRx[bufRxIndex] = USART_ReceiveData(USART1); //Odczyt danej automatycznie kasuje flage przerwania
if(buforRx[bufRxIndex] == 'E') {
odebranoDane = 1;
while (bufRxIndex<17) { //wyzerowanie znakow do konca bufora (zabezpiecza przed wyswietlaniem "smieci" na LCD)
buforRx[bufRxIndex]=0;
bufRxIndex++;
}
bufRxIndex = 0;
} else { //Obsluga pozostalych, "zwyklych" znakow
bufRxIndex++;
if (bufRxIndex>16){ //Zabezpieczenie przed przepelnieniem bufora jesli tekst odbierany jest dluzszy niz 16 znakow
bufRxIndex=0;
}
}
}
if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) {
USART_SendData(USART1, buforTx[bufTxIndex++]); //Wyslij kolejny znak i zwieksz indeks bufora wyjsciowego
if(buforTx[bufTxIndex-1] == 'E' ) //Jesli wysylany zostal ostatni znak (CR)
{
USART_ITConfig(USART1, USART_IT_TXE, DISABLE); //Wylacz przerwanie = koniec transmisji
bufTxIndex = 0;
Indeks_wysylki++;
}
}
//}
}
////////////////////////////////////////////////////////////////////////////////
int main(void)
{
RCC_CONF();
AC_cf();
GPIO_CF();
TIM_4_CF();
NVIC_CF();
USART_CF();
while(1)
{
}
}
void AC_cf(void)
{
ADC_InitTypeDef ACcf;
DMA_InitTypeDef DMA_InitStruct;
ACcf.ADC_Mode = ADC_Mode_Independent;
ACcf.ADC_ScanConvMode = ENABLE;
ACcf.ADC_ContinuousConvMode = ENABLE;
ACcf.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ACcf.ADC_DataAlign = ADC_DataAlign_Right;
ACcf.ADC_NbrOfChannel = 2;
ADC_Init(ADC1, &ACcf);
ADC_RegularChannelConfig(ADC1, ADC_Channel_10, 1, ADC_SampleTime_7Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_11, 2, ADC_SampleTime_13Cycles5);
ADC_DMACmd(ADC1, ENABLE);
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
ADC_SoftwareStartConvCmd(ADC1,ENABLE);
///DMA - KOFIGURACJA
DMA_DeInit(DMA1_Channel1);
DMA_InitStruct.DMA_PeripheralBaseAddr = ADC1_DR_Address;
DMA_InitStruct.DMA_MemoryBaseAddr = (u32)&ADCVal;
// Kierunek: zrodlem jest ADC
DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
// Rozmiar burora: dwa kanaly = rozmiar bufora 2
DMA_InitStruct.DMA_BufferSize = 2;
DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
// Dane beda przesylane ciagle
DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
DMA_InitStruct.DMA_Priority = DMA_Priority_High;
DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStruct);
// Wlacz DMA
DMA_Cmd(DMA1_Channel1, ENABLE);
}
void GPIO_CF(void)
{
GPIO_InitTypeDef AC,GPIO_InitStructure ;
/////////////Wejcie analogowe//////////////////////////////////////////
AC.GPIO_Pin = GPIO_Pin_0| GPIO_Pin_1;
AC.GPIO_Mode = GPIO_Mode_AIN;
AC.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &AC);
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
//////////////////USART/////////////////////////////////////////
//PA9 - Tx
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//PA10 - Rx
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
void RCC_CONF(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
}
void TIM_4_CF(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef OCI;
TIM_TimeBaseStructure.TIM_Period = 50-1; //na 20Khz
TIM_TimeBaseStructure.TIM_Prescaler = 72-1;//Dzielimy do 1Mhz
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
// TIM IT enable */
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
/* TIM2 enable counter */
TIM_Cmd(TIM4, ENABLE);
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
}
void NVIC_CF(void)
{
NVIC_InitTypeDef T4,USART;
T4.NVIC_IRQChannel = TIM4_IRQn;
T4.NVIC_IRQChannelCmd = ENABLE;
T4.NVIC_IRQChannelPreemptionPriority = 0;
T4.NVIC_IRQChannelSubPriority = 1;
NVIC_Init(&T4);
USART.NVIC_IRQChannel = USART1_IRQn;
USART.NVIC_IRQChannelCmd = ENABLE;
USART.NVIC_IRQChannelPreemptionPriority = 0;
USART.NVIC_IRQChannelSubPriority = 2;
NVIC_Init(&USART);
}
void USART_CF(void)
{
//konfigurowanie ukladu USART
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate =9600; //Predkosc transmisji w bps
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //Dlugosc dlowa danych
USART_InitStructure.USART_StopBits = USART_StopBits_1; //Bity stopu (1 bit)
USART_InitStructure.USART_Parity = USART_Parity_No; //Bit parzystosci (wylaczony)
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //Sprzetowa kontrola przeplywu wylaczona
USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx; //Tryb pracy (tylko odbior)
USART_Init(USART1, &USART_InitStructure);
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
USART_Cmd(USART1, ENABLE);
}[/syntax]
Na szybko C# napisałem programik do testowania i wyświetlania danych
link http://hostuje.net/file.php?id=f8930378a67d617d8c6842eb984ceb78
przycisk pierwszy wykonuje pomiar, trzeci wyświetla wykres.
Drugi coś miał robić ale zapomniałem mu dopisać funkcji:P
Statystyki: Napisane przez kyp — 28 kwi 2014, o 08:33
]]>
