Osciloskop (za Arduno Uno)

utorak, 22.10.2024.

Brzo upoznavanje sa projektom

A) Da bi brzo upoznali neka osnovna svojstva osciloskopa, dovoljno je instalirati programe u Arduino Uno, uključiti Serial monitor, utaknuti neki vodič u pin A0 i eventualno dodirnuti ga prstima; na Serial monitoru će se pokazati signal od 50Hz .

B) Možete i izmjeriti cca. 500Hz , ako spojite jednim vodičem pin 5 i pin A0 ( u programu je pin 5 podešen na PWM)

C) ukoliko budete kupili nešto dodatne opreme, moći ćete vidjeti i ovakve slike:

- vremenski dijagram

- frekventna analiza

22.10.2024. u 22:18 • 3 Komentara • Print • #

nedjelja, 06.10.2024.

*.S datoteka

;Autor: Marino Jurinović
;16MHz Arduino ATmega328P
;1/16MHz=6,26E-8 sekundi
;
;
;r16 ULAZ5, LO DELAY
;r18 ULAZ4, HI DELAY
;r20 ULAZ3, speed, init_ADC, start_ADC
;r22 ULAZ2, donji pt, ADC.LO
;r24 ULAZ1, gornji pt , ADC.HI

;r17 BROJ SEMPLINGA 127,do 256
;r19 ADCSRA =0xC7 , 4. BIT
;r21 ADCSRA
;r23 ADCH! UHI
;r25 MOJ DELAY_HI IZ R16
;r26 MOJ DELAY_LO IZ R18
;r27 SAMPLE(-1)
;r28 <-R20 , TRIG
;r29
;r30 ->Z-MLO DOBIVA ULAZ ZA POLJE SA R22
;r31 ->Z-MHI DOBIVA ULAZ ZA POLJE SA R24

;---------------
; Assembly Code
;---------------
#define __SFR_OFFSET 0x00
#include "avr/io.h"
;------------------------
.global init_ADC
.global init_and_read_ADC1
.global start_ADC
.global rread0_ADC
.global rread_ADC
.global read_ADC

;------------------------
init_ADC:
PUSH R16
PUSH R17
PUSH R18
PUSH R19
PUSH R20
PUSH R21
PUSH R22
PUSH R23
PUSH R24
PUSH R25
PUSH R26
PUSH R27
PUSH R28
PUSH R29
PUSH R30
PUSH R31
LDI R20, 0xFF
//OUT DDRD, R20 ;set port D as o/p for low byte result
//OUT DDRB, R20 ;set port B as o/p for high byte result
//SBI DDRC, 0 ;set pin PC0 as i/p for ADC0
;--------------------------------------------------------------
LDI R20, 0x60 ;0xC0 ;internal 2.56V, right-justified data, ADC0
;LDI R20, 0xE0 ;internal 2.56V, left-justified data, ADC0
STS ADMUX, R20
LDI R20,0xC0
ADD R20,R24
;LDI R20, 0x82 ;enable ADC, ADC prescaler CLK/128
STS ADCSRA, R20
POP R31
POP R30
POP R29
POP R28
POP R27
POP R26
POP R25
POP R24
POP R23
POP R22
POP R21
POP R20
POP R19
POP R18
POP R17
POP R16
RET
;==========================
init_and_read_ADC1:
PUSH R16
PUSH R17
PUSH R18
PUSH R19
PUSH R20
PUSH R21
PUSH R22
PUSH R23
PUSH R24
PUSH R25
PUSH R26
PUSH R27
PUSH R28
PUSH R29
PUSH R30
PUSH R31
LDI R21, 0xFF
//OUT DDRD, R20 ;set port D as o/p for low byte result
//OUT DDRB, R20 ;set port B as o/p for high byte result
//SBI DDRC, 0 ;set pin PC0 as i/p for ADC0
;--------------------------------------------------------------
LDI R21, 0x61 ;0xC0 ;internal 2.56V, right-justified data, ADC1
;LDI R21, 0xE0 ;internal 2.56V, left-justified data, ADC1
STS ADMUX, R21
LDI R21,0xC0
ADD R21,R20
;LDI R21, 0x82 ;enable ADC, ADC prescaler CLK/128
STS ADCSRA, R21
CALL read1_ADC ; jedno mjerenje ;cca12;4cyc
; LDS R22 , ADCL ;ULO ;2cyc
LDS R23 , ADCH ;UHI
MOV R31, R24 ; R24 SADA SLOBODAN?
MOV R30, R22 ;r22 SADA SLOBODAN?
;PRELAZAK NA 3D
; ST Z+, R24 ;T3/3 ;2cyc
; ST Z+, R22 ;T3/3 ;2cyc
ST Z+, R23 ;2cyc
POP R31
POP R30
POP R29
POP R28
POP R27
POP R26
POP R25
POP R24
POP R23
POP R22
POP R21
POP R20
POP R19
POP R18
POP R17
POP R16
RET

;==========================
rread0_ADC:
PUSH R16
PUSH R17
PUSH R18
PUSH R19
PUSH R20
PUSH R21
PUSH R22
PUSH R23
PUSH R24
PUSH R25
PUSH R26
PUSH R27
PUSH R28
PUSH R29
PUSH R30
PUSH R31
;OVAJ RED ZA SPEED
MOV R28 , R20 ; LDI R28 , 128 ; MOV R28 , R20
LDI R17 , 127 ;do 255, =N_MAX ;1cyc
MOV R31, R24 ; R24 SADA SLOBODAN?
MOV R30, R22 ;r22 SADA SLOBODAN?
opetlja1b:
; CALL read1_ADC
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
;LDS R22 , ADCL ;ULO
LDS R23 , ADCH ;UHI
CP R23 , R28
BRSH opetlja1b
opetlja1a:
MOV R27 , R23
; CALL read1_ADC
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
;LDS R22 , ADCL ;ULO
LDS R23 , ADCH ;UHI
;CALL cekaj
CP R27 , R28
BRSH opetlja1a
CP R23 , R28
BRLO opetlja1a
;::::::::::::::::::::::::::::::
opetlja2:
;MOV R27, R23 ;1cyc
; CALL read1_ADC ; jedno mjerenje ;7+4cyc
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
;LDS R22 , ADCL ;ULO ;2cyc
LDS R23 , ADCH ;UHI ;2cyc
; CALL u_memoriju ;zapisivanje podataka u memoriju ;6+4cyc
ST Z+, R23 ;2cyc
;CALL cekaj ;cekanje u duljini od d_int*4/16e6 ;cca 9+4cyc
DEC R17 ;R17 ;1cyc
CPI R17 , 0 ; R17,4 ;počinje usporedba ;1cyc
BREQ okraj ; ako je napravljano127 uzoraka ;1-2cyc
;CP R27 , R28 ; počinje usporedba ;1cyc
;BRSH opetlja2 ; ako je predzadnji podataka isti ili veći od trigera nastavi uzorkovati
;12cyc
;CP R23 , R28 ; počinje usporedba ;1cyc
;BRLO opetlja2 ; ako je zadnji podatak manji od trigera nastavi uzorkovati
;12cyc
RJMP opetlja2 ;2cyc
okraj:
MOV R27, R23
; CALL read1_ADC
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
;LDS R22 , ADCL ;UHI
LDS R23 , ADCH ;UHI
; CALL u_memoriju
ST Z+, R23 ;2cyc
;LDI R22 , 0
LDI R23 , 0
;CALL u_memoriju
ST Z+, R23 ;2cyc

;LDI R22 , 255
LDI R23 , 255
;CALL u_memoriju
ST Z+, R23 ;2cyc
POP R31
POP R30
POP R29
POP R28
POP R27
POP R26
POP R25
POP R24
POP R23
POP R22
POP R21
POP R20
POP R19
POP R18
POP R17
POP R16
RET
;-rread0_ADC
;==========================
rread_ADC:
PUSH R16
PUSH R17
PUSH R18
PUSH R19
PUSH R20
PUSH R21
PUSH R22
PUSH R23
PUSH R24
PUSH R25
PUSH R26
PUSH R27
PUSH R28
PUSH R29
PUSH R30
PUSH R31
;OVAJ RED ZA SPEED
MOV R28 , R20; LDI R28 , 128 ; MOV R28 , R20
LDI R17 , 127 ;do 255, =N_MAX ;1?
MOV R31, R24 ; R24 SADA SLOBODAN?
MOV R30, R22 ;r22 SADA SLOBODAN?
petlja1b:
; CALL read1_ADC
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
LDS R23 , ADCH ;UHI
CP R23 , R28
BRSH petlja1b
petlja1a:
MOV R27 , R23
; CALL read1_ADC
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
;LDS R22 , ADCL ;ULO
LDS R23 , ADCH ;UHI
CALL cekaj
CP R27 , R28
BRSH petlja1a
CP R23 , R28
BRLO petlja1a
;-------------------------------
petlja1:
; CALL u_memoriju ;10-cyc;4cyc
ST Z+, R23 ;2cyc
DEC R17 ;R17 ;1cyc
;::::::::::::::::::::::::::::::
petlja2:
MOV R27, R23 ;1cyc
CALL read1_ADC ; jedno mjerenje ;cca12;4cyc
; LDS R22 , ADCL ;ULO ;2cyc
LDS R23 , ADCH ;UHI ;2cyc
; CALL u_memoriju ;zapisivanje podataka u memoriju ;10cyc
ST Z+, R23 ;2cyc
CALL cekaj ;cekanje u duljini od d_int*4/16e6 ;9-cyc;4cyc
DEC R17 ;R17 ;1cyc
CPI R17 , 0 ; R17,4 ;počinje usporedba ;1cyc
BREQ kraj ; ako je napravljano 127 uzoraka ;1-2cyc
CP R27 , R28 ; počinje usporedba ;1cyc
BRSH petlja2 ; ako je predzadnji podataka isti ili veći od trigera nastavi uzorkovati
;1-2cyc
CP R23 , R28 ; počinje usporedba ;1cyc
BRLO petlja2 ; ako je zadnji podatak manji od trigera nastavi uzorkovati
;1-2cyc
;RJMP petlja2 ;2cyc
kraj:
MOV R27, R23
CALL read1_ADC
;LDS R22 , ADCL ;ULO
LDS R23 , ADCH ;UHI
;CALL u_memoriju
ST Z+, R23 ;2cyc

LDI R22 , 0
LDI R23 , 0
;CALL u_memoriju
ST Z+, R23 ;2cyc

LDI R22 , 255
LDI R23 , 255
;CALL u_memoriju
ST Z+, R23 ;2cyc
POP R31
POP R30
POP R29
POP R28
POP R27
POP R26
POP R25
POP R24
POP R23
POP R22
POP R21
POP R20
POP R19
POP R18
POP R17
POP R16

RET
;-rread_ADC
;=============================
read1_ADC:
;OVA DVA REDA ZA SPEED
LDI R19,0xC3;LDI R19,0xC7 ;1cyc
;ADD R19,R20 ;1cyc
STS ADCSRA, R19 ;1cyc
;---------------------------------------------
; LDI R22, 0 ;T1/3 ;1cyc
; LDI R24, 0 ;T1/3 ;1cyc
wait1_ADC:
LDS R19, ADCSRA ;check ADIF flag in ADCSRA ;2cyc
SBRC R19, 4 ; ;1-2-3cyc
RJMP dalje1 ;2cyc
INC R22 ;T2/3 ;1cyc
; CPI R22 , 0 ;1cyc
; BRNE dalje0 ;1-2cyc
; INC R24 ;T2/3 ;1cyc
;OVA DVA REDA ZA SPEED
LDI R21, 0xD3 ;LDI R27, 0xD7 ;set ADIF flag again ;1cyc
//ADD R21 , R20
STS ADCSRA, R21 ;so that controller clears ADIF ;1cyc
dalje0:
RJMP wait1_ADC ;2 ; ADIF zastavica ;2cyc
;-------------------------------------------
dalje1:
RET ;4cyc
;-read1
;==============================
u_memoriju:
;ZA PRRELAZAK U 3D
; ST Z+, R24 ;T3/3 ;2cyc
; ST Z+, R22 ;T3/3 ;2cyc
ST Z+, R23 ;2cyc
RET ;4cyc
;10cyc
;==============================
cekaj:
MOV R26 , R18 ;1cyc
MOV R25 , R16 ;1cyc
visi:
DEC R26 ;1cyc
nizi:
DEC R25 ;1cyc
CPI R25 , 0 ;1cyc
BRNE nizi ;1-2cyc
CPI R26 , 0 ;1cyc
BRNE visi ;1-2cyc
RET ;4cyc
;======================

06.10.2024. u 23:45 • 0 Komentara • Print • #

*.ino datoteka

/*
Autor: Marino Jurinović
**************************************************************************/
/**************************************************************************
This is a library for several Adafruit displays based on ST77* drivers.

Works with the Adafruit 1.8" TFT Breakout w/SD card
---- > http://www.adafruit.com/products/358
The 1.8" TFT shield
---- > https://www.adafruit.com/product/802
The 1.44" TFT breakout
---- > https://www.adafruit.com/product/2088
The 1.14" TFT breakout
---- > https://www.adafruit.com/product/4383
The 1.3" TFT breakout
---- > https://www.adafruit.com/product/4313
The 1.54" TFT breakout
---- > https://www.adafruit.com/product/3787
The 1.69" TFT breakout
---- > https://www.adafruit.com/product/5206
The 2.0" TFT breakout
---- > https://www.adafruit.com/product/4311
as well as Adafruit raw 1.8" TFT display
---- > http://www.adafruit.com/products/618

Check out the links above for our tutorials and wiring diagrams.
These displays use SPI to communicate, 4 or 5 pins are required to
interface (RST is optional).

Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!

Written by Limor Fried/Ladyada for Adafruit Industries.
MIT license, all text above must be included in any redistribution
**************************************************************************/

//#include "TFT.h"
#include "Adafruit_GFX.h" // Core graphics library
#include "Adafruit_ST7735.h" // Hardware-specific library for ST7735
#include "Adafruit_ST7789.h" // Hardware-specific library for ST7789
#include "SPI.h"
#define TFT_CS 10
#define TFT_RST 9 // Or set to -1 and connect to Arduino RESET pin
#define TFT_DC 8
// OPTION 1 (recommended) is to use the HARDWARE SPI pins, which are unique
// to each board and not reassignable. For Arduino Uno: MOSI = pin 11 and
// SCLK = pin 13. This is the fastest mode of operation and is required if
// using the breakout boards microSD card.

// For 1.44" and 1.8" TFT with ST7735 use:
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

// For 1.14", 1.3", 1.54", 1.69", and 2.0" TFT with ST7789:
//Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST);

// OPTION 2 lets you interface the display using ANY TWO or THREE PINS,
// tradeoff being that performance is not as fast as hardware SPI above.
//#define TFT_MOSI 11 // Data out
//#define TFT_SCLK 13 // Clock out

// For ST7735-based displays, we will use this call
//Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);

// OR for the ST7789-based displays, we will use this call
//Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);

//==========================

//==========================

//==========================

//--------------------
volatile int ledState = HIGH;

int plava=0,zelena=64,crvena=1048;//?
bool crtam;
float ppp1;
int pot;
String pref;

//ZA UZORKOVANJE, A POTOM CRTANJE
unsigned char n_mem = 127 ;//može i do 255 ,
//maksimalni broj uzoraka
//ovaj broj se poklapa sa redom 133 u assebleru

int n_graf2 = 125;//128
//širina ekrana

int n_graf1 = 122 ;//122 //maksimalna širina slike

int tolerancija_graf1 = 2 ;// +/-2 tolerancija broja uzoraka
//dodaje se na n_graf_1 za broj pixela/uzoraka na ekranu

int mjerni_opseg = 255;
//mjerni opseg nije 1023, jer se uzimaju podaci iz ADC
//na poseban način
//ZA KOJEKAKVE PODATKE
int cyc_u_memoriju;
int cyc_cekaj;
int cyc_read1;

int obr_t_bez_d, br_t_d=4, br_t_bez_d=22;
int broj_preskocenih_crtanja=0;
int broj_parametra;
int deltay=10;
int pp_g_x[10]; int pp_g_y[10];
String pp_text[10];
String pp_dim[10];

bool test;//na kraju izbaci

bool ispis_serial=true;

float frekvencija_mhz=0.987*16000000;//!!!! inace je 16MHz !!

float visina_grafa=100.0;

float pola;//=136.0;//128!!!
//ovaj podatak je ovisan o naponskom djelilu
// i offsetu operacionog pojačala

byte trig_level;//=128;//135;
//razina na kojoj počinje sempliranje
//uz to da je trend uzlazni,
//vrijednost prilagođena varijali "pola"

float pi=3.141592653589793;//broj pi

int stop_podatak=255;

float perioda;
//perioda sempliranja
//perioda se u svakom loopu-u ponovo mijenja,
//prilagođava frekvenciji signala

int broj_serija=0, broj_serija_stari;
//broj serija semplinga

//------------------
//ZA TESTIRANJE
bool samotestiranje_sa_pwm=true;

char pin_pwm_testnog_signala=5;
//pwm sa digitalnog izlaza može biti dobar testni signal

byte test_signal;

//------------------
//ZA UZORKOVANJE

int n_uzoraka, n_uzoraka_stari;
//ovaj podatak se stalno mijenja između
//124+/-2

byte speed_7_do_2_ADC;//2-7, za 1 je prebrzo
//7 je najsporije,a 2 najbrže

byte p[127];
//polje u koje assembler piše podatke sempliranja
//upisuju se 3 podatke po semplingu
//p[x][0] - gornji byte podatka o kašnjenju ADC
//p[x][1] - donji byte podatka o kašnjenju ADC
//p[x][2] - semplirani podatak (0-255)

byte *pt_start;
// deklaracija pointera koji pokazuje na varijablu tipa byte
// konkrentno na početak polja p (podatak p[0][0])
//sam po sebi taj pointer je long int!!!!
byte gornja_adr_pt_p,donja_adr_pt_p;
//gornji i donji dio adrese polja p (p[0][0])

byte p_g[127];
//polje koje nastaje iz polja p[0-139][2]
//služi za grafički prikaz

//----------------
//ZA PARAMETRA
float pp[10],pp_s[10];
//novi i stari(_s) podaci
//pp[0] - srednja vrijednost
//pp[1] - maksimalna vrijednost
//pp[2] - minimalna vrijednost
//pp[3] - srednja elektrolitska vrijednost
//pp[4] - efektivna vrijednost

float zbroj;//pomoćna varijabla za izračunavanje srednjih vrijednosti i slično

//--------------
//ZA FOURIEROVU ANALIZU
float xf, yf;
//pomocne varijeble za fourierovu transformaciju

float xa, xff;
//rješenja fourierove transformacije
//xa-amplituda, xff-faza

//--------------
//ZA PERIODU SEMPLIRANJA
float d_float,d_float_stari;
//priželjkivano vrijeme između semplinga

unsigned int d_int,d_int_stari;//maximalno 65535
//praktično vrijeme između sempliga(novo i staro)

byte delay0,delay1;
//donji i gornji byte podatka čekanja između uzoraka d_int
//čeka se d_int*4/frekvencija_mhz us (perioda sempliranja)
//d_int*4 takta mikroprocesora

//----------------
//ZA VREMENSKU PROVJERU
long int pocetak_serije_semplinga,kraj_serije_semplinga,
pocetak_serije_semplinga_stari,kraj_serije_semplinga_stari;
//podaci koji služe za testiranje trajanja jedne serije sempliranja
// serija traje cca. 127 do 255 semplinga , ovisno o ekranu ili želji programera

//-----------------------

//FUNKCIJE U ASSEMBLERU
extern "C"
{
void init_ADC(byte);
//početne postavke za ADC0

void init_and_read_ADC1(byte,byte,byte);
//početne postavke za ADC1

void rread_ADC(byte,byte,byte,byte,byte);//,byte,byte);
//serija mjerenja(uzorkovanja)
//ulazno podaci su gornji i donji byte poitera polja p,
//trig level-broj koji određuje početak serije kada mu se vrijednosti uzoraka približe "odozdo"
//gornji i donji byte vremena čekanja između uzorkovanja
//1. byte ide u R24 - gornji byte poitera
//2. byte ide u R22 - donji byte poitera
//3. byte ide u R20 - trig level, broj koji određuje početak serije mjerenja kada mu se vrijednosti uzoraka približe "odozdo"
//4. byte ide u R18 - gornji byte vremena čekanja između uzorkovanja
//5. byte ide u R16 - donji byte vremena čekanja između uzorkovanja
void rread0_ADC(byte,byte,byte,byte,byte);//,byte,byte);
//

}

//=================================

//=================================

//=================================

byte broj_parametara=8;
bool s_osciloskop,osciloskop=true;
bool prekid;
byte interrupt_pin=2;

void setup()
{
test=false;

pinMode(3, INPUT_PULLUP);

prekid=true;
if(prekid)
{
pinMode(2, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(2), hold, FALLING);
}
interrupts();

//SETUP,POCETNA VRIJEDNOST ZA ADC SPEED
speed_7_do_2_ADC=7;

//SETUP,SERIAL POCETAK
Serial.begin(9600);

//SETUP,ZA SAMOTESTIRANJE
if(samotestiranje_sa_pwm)
pinMode(pin_pwm_testnog_signala,OUTPUT);

//SETUP,POČETAK RADA SA EKRANOM
tft.initR(INITR_BLACKTAB);
tft.fillScreen(ST77XX_BLACK);
tft.setTextWrap(false);

//SETUP,POINTER
pt_start = &p[0]; //dobivam početnu adresu polja "p" u pt_start
gornja_adr_pt_p=(long)pt_start/256;
donja_adr_pt_p=(long)pt_start%256;

//SETUP,OFFSET
pola=136;
init_and_read_ADC1(gornja_adr_pt_p,donja_adr_pt_p ,speed_7_do_2_ADC ) ;
//ovaj podatak je ovisan o naponskom djelilu
// i offsetu operacionog pojačala
//pola=p[0][2];

//SETUP,TRIG LEVEL
trig_level=128;//135;
//razina na kojoj počinje sempliranje
//uz to da je trend uzlazni,
//vrijednost prilagođena varijali "pola"
//trig_level=p[0][2];

//SETUP,TEST PODACI
if((ispis_serial) and(test))
{
Serial.print("pt_start: ");
Serial.println((long) pt_start, DEC);
Serial.print(" na pt_start je vrijednost : ");
Serial.println((long) *pt_start, DEC);
Serial.print("analog1: ");
Serial.print(p[0]);
Serial.println(" ");
//Serial.println(analogRead(A1));
Serial.print("d_int: ");
Serial.println(d_int);
Serial.print("d_float: ");
Serial.println(d_float);
}

//SETUP,INIT_ADC
init_ADC( speed_7_do_2_ADC ) ;

//SETUP,NEKE POCETNE VRIJEDNOSTI
d_float=0.01;//početna nasumična vrijednost
d_int=d_float;
n_uzoraka=122;//početna nasumična vrijednost
delay0=d_int % 256 ;
delay1=d_int / 256 ;
test_signal=128;
}//-SETUP

//===========================

//===========================

//===========================

void loop(){

/*
if(broj_serija%2==1)
{
//ispis statistike
for (int i=0;i <= 7;i++)
{
//if(pp[i]!=pp_s[i])
{
tft.setCursor(pp_g_x[i],pp_g_y[i]);
tft.setTextColor(ST77XX_BLACK);
tft.print(pp_text[i]);
tft.print(pp_s[i]);
tft.println(pp_dim[i]);

tft.setCursor(pp_g_x[i],pp_g_y[i]);
tft.setTextColor(ST77XX_YELLOW);
tft.print(pp_text[i]);
tft.print(pp[i]);
tft.println(pp_dim[i]);
}
}
//tft.setCursor(0,0);
//tft.setTextColor(ST77XX_YELLOW);
//tft.print(char(229));//"Ă µ Ä ¦");
//tft.print(char(230));//"Ă u µ Ä ¦");

tft.drawPixel(6, pp_g_y[7]+2, ST77XX_YELLOW);
tft.drawPixel(7, pp_g_y[7]+1, ST77XX_YELLOW);
tft.drawPixel(8, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(9, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(10, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(11, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(12, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(13, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(14, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(15, pp_g_y[7], ST77XX_YELLOW);

if(ispis_serial)
{
tft.setCursor(pp_g_x[8],pp_g_y[8]);
tft.setTextColor(ST77XX_YELLOW);
tft.print(" +serial monitor!");
}
//-ispis statistike
}
*/

//LOOP,STARI TESTNI PODACI
d_int_stari=d_int;
d_float_stari=d_float;
n_uzoraka_stari=n_uzoraka;
broj_serija_stari=broj_serija;

//LOOP,EVENTUALNO TESTIRANJE SA PWM
if(samotestiranje_sa_pwm)
{
test_signal=test_signal+10;
if(test_signal > 200)test_signal=1;
analogWrite(pin_pwm_testnog_signala,test_signal);
}

//LOOP,P[100]
if((ispis_serial)and(test))
//podaci koji pomažu kod provjere programa
{
for(int i=0;i < n_mem;i++)//REZULTATI mjerenja
{
for(int j=0;j < 3;j++)//REZULTATI mjerenja
{
p[i]=100;
}
}
}

//*********************************

//LOOP,SERIJA MJERENJA
//LOOP,PRORAČUN ZA D_INT
if(n_uzoraka > n_graf1+tolerancija_graf1)
{
d_float=d_float*10.0;//(10*log(n_uzoraka-n+0.1));
d_int=d_float+0.1;
}
if((n_uzoraka < n_graf1-tolerancija_graf1))
{
d_float=(1-(n_graf1-n_uzoraka)/1.0/n_graf1)*d_float+0.01;
d_int=d_float+0.1;
}
//*********************************
pocetak_serije_semplinga_stari=pocetak_serije_semplinga;
kraj_serije_semplinga_stari=kraj_serije_semplinga;

//LOOP,SNIMANJE SERIJE OD 127 UZORAKA ILI MANJE
delay0=d_int%256;
delay1=d_int/256;
pocetak_serije_semplinga=micros();
noInterrupts();
//if(d_int!=0)
//rread_ADC(gornja_adr_pt_p,donja_adr_pt_p,speed_7_do_2_ADC,delay1+1,delay0+1);
//else
//rread0_ADC(gornja_adr_pt_p,donja_adr_pt_p,speed_7_do_2_ADC,delay1+1,delay0+1);

if(d_int!=0)
rread_ADC(gornja_adr_pt_p,donja_adr_pt_p,trig_level,delay1+1,delay0+1);
else
rread0_ADC(gornja_adr_pt_p,donja_adr_pt_p,trig_level,delay1+1,delay0+1);
interrupts();
kraj_serije_semplinga=micros();

//LOOP,PRORAČUN ZA N-UZORAKA
n_uzoraka=2;
while((n_uzoraka < n_mem)
and
// ((p[n_uzoraka+1][1]!=0)or
// (p[n_uzoraka+1][2]!=0)or
// (p[n_uzoraka+2][1]!=stop_podatak)or
// (p[n_uzoraka+2][2]!=stop_podatak))
((p[n_uzoraka-1] >= trig_level)or
(p[n_uzoraka] < trig_level))
)
n_uzoraka++;

//LOOP,PRORAČUN ZA BROJ SERIJA
broj_serija++;

//LOOP,ISPIS TEST
if(test)
{
tft.setTextColor(ST77XX_BLACK);
ispis_test(2,11,1,broj_serija_stari,d_int_stari,n_uzoraka_stari
,kraj_serije_semplinga_stari,pocetak_serije_semplinga_stari,d_float_stari);//broj,d,n_uz.
tft.setTextColor(ST77XX_YELLOW);
ispis_test(2,11,1, broj_serija,d_int,n_uzoraka
,kraj_serije_semplinga,pocetak_serije_semplinga,d_float);//broj,d,n_uz.
}
//LOOP,CRNI EKRAN ZA OSCILOSKOP
s_osciloskop=osciloskop;
osciloskop=digitalRead(3);
if(s_osciloskop!=osciloskop) tft.fillScreen(ST77XX_BLACK);

//LOOP,CRTANJE
crtam=false;
if
(
(n_uzoraka > n_graf1-tolerancija_graf1)
and
(n_uzoraka < n_graf1+tolerancija_graf1)
or
(broj_preskocenih_crtanja > 10) ) {
//{
crtam=true;

//LOOP,CRTANJE,OSCILOSKOP
if(osciloskop)
{
if(test)
{
tft.setCursor(1,1);
tft.setTextColor(ST77XX_BLACK);
tft.print(speed_7_do_2_ADC);
speed_7_do_2_ADC++;
if(speed_7_do_2_ADC > 7)speed_7_do_2_ADC =2;
tft.setCursor(1,1);
tft.setTextColor(ST77XX_YELLOW);
tft.print(speed_7_do_2_ADC);
}

//LOOP,CRTANJE,OSCILOSKOP,ISPIS_GRAF
ispis_graf();
broj_preskocenih_crtanja=0;

//LOOP,CRTANJE,OSCILOSKOP,ISPIS SERIAL TEST
if((ispis_serial) and(test))
{
Serial.print("dint,char(9),br_t_d: ");
Serial.print(d_int);
Serial.print(" ");
Serial.print(delay1);
Serial.print(" ");
Serial.print(delay0);
Serial.print(" ");
Serial.print(br_t_d);
Serial.print(" ");
Serial.print(cyc_cekaj);
Serial.println();
}

//LOOP,CRTANJE,OSCILOSKOP,STATISTIKA
statistika();
//LOOP,CRTANJE,OSCILOSKOP,ISPIS STATISTIKE
//if(broj_serija%2==1)
{
//ispis statistike
for (int i=0;i <= broj_parametara;i++)
{
if(((i!=8)and(i!=7))or(test))
{
tft.setCursor(pp_g_x[i],pp_g_y[i]);
tft.setTextColor(ST77XX_BLACK);
tft.print(pp_text[i]);
ppp1=pp_s[i];
pot=0;
pref="";
if(abs(ppp1) < 1){ppp1=ppp1*1000;pot--;}
if(abs(ppp1) < 1){ppp1=ppp1*1000;pot--;}
if(abs(ppp1) > 1000){ppp1=ppp1/1000.0;pot++;}
if(abs(ppp1) > 1000){ppp1=ppp1/1000.0;pot++;}
if(pot==1)pref="K";
if(pot==2)pref="M";
if(pot==0)pref="";
if(pot==-1)pref="m";
if(pot==-2)pref="u";
if(abs(ppp1) > 10)
tft.print(int(ppp1));
else
tft.print((ppp1));
tft.print(pref);
tft.println(pp_dim[i]);
tft.setCursor(pp_g_x[i],pp_g_y[i]);
tft.setTextColor(ST77XX_YELLOW);
tft.print(pp_text[i]);
ppp1=pp[i];
pot=0;
pref="";
if(abs(ppp1) < 1){ppp1=ppp1*1000;pot--;}
if(abs(ppp1) < 1){ppp1=ppp1*1000;pot--;}
if(abs(ppp1) >= 1000){ppp1=ppp1/1000.0;pot++;}
if(abs(ppp1) >= 1000){ppp1=ppp1/1000.0;pot++;}
if(pot==1)pref="K";
if(pot==2)pref="M";
if(pot==0)pref="";
if(pot==-1)pref="m";
if(pot==-2)pref="u";
if(abs(ppp1) > 10)
tft.print(int(ppp1));
else
tft.print((ppp1));
tft.print(pref);
tft.println(pp_dim[i]);
}
}
//tft.setCursor(0,0);
//tft.setTextColor(ST77XX_YELLOW);
//tft.print(char(229));//"Ă µ Ä ¦");
//tft.print(char(230));//"Ă u µ Ä ¦");
if(test)
{
tft.drawPixel(6, pp_g_y[7]+2, ST77XX_YELLOW);
tft.drawPixel(7, pp_g_y[7]+1, ST77XX_YELLOW);
tft.drawPixel(8, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(9, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(10, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(11, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(12, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(13, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(14, pp_g_y[7], ST77XX_YELLOW);
tft.drawPixel(15, pp_g_y[7], ST77XX_YELLOW);
}

{
tft.setCursor(4,150);
tft.setTextColor(ST77XX_YELLOW);
tft.print(" +serial monitor!");
}
//-ispis statistike
}

//LOOP,CRTANJE,OSCILOSKOP,ISPIS__UZORAKA_SERIAL
if(ispis_serial) ispis_uzoraka_serial(0);
}// osciloskop
else
{
//LOOP,CRTANJE,FREKVENTNA,STATISTIKA
statistika();
//LOOP,CRTANJE,FREKVENTNA,ISPIS__UZORAKA_SERIAL
if(ispis_serial) ispis_uzoraka_serial(0);

//LOOP,CRTANJE,FREKVENTNA,CRTAJ_FREKVENTNU
crtaj_i_pisi_frekventnu();

}////ELSE osciloskop

}//CRTANJE
//-LOOP,CRTANJE
else
//LOOP,PRESKAKANJE CRTANJA
{broj_preskocenih_crtanja++;}
//-LOOP,PRESKAKANJE CRTANJA

}//-LOOP

//======================================

//====================================

//======================================
//FUNKCIJA STATISTIKA, PRORAČUN STATISTIKE
void statistika()
{
pp_g_x[0]=1; pp_g_y[0]=65;
for(int i=1;i <= broj_parametara;i++)
{
pp_s[i-1]=pp[i-1];
pp_g_x[i]=pp_g_x[i-1]; pp_g_y[i]=pp_g_y[i-1]+deltay;
}
pp_text[0]=" T ="; pp_dim[0]="s";
pp_text[1]=" f ="; pp_dim[1]="Hz";
pp_text[2]=" Uav ="; pp_dim[2]="V";
pp_text[3]=" Umax ="; pp_dim[3]="V";
pp_text[4]=" Umin ="; pp_dim[4]="V";
pp_text[5]=" Uav-el ="; pp_dim[5]="V";
pp_text[6]=" Uef ="; pp_dim[6]="V";
pp_text[7]=" o ="; pp_dim[7]="";

//T
broj_parametra=0;
//br_t_d=4, br_t_bez_d=22;
cyc_u_memoriju=2;//6+4;
if(delay1==0)cyc_cekaj=2+1+(delay0-1)*4+3+ (2) +4;
else cyc_cekaj=2+1+(delay0-1)*4+3+ 2 +
(delay1)*(1+255*4+3+3) +4;
cyc_read1=3;//7+4;
obr_t_bez_d=cyc_read1+2+cyc_u_memoriju+5;
if(d_int==0)
{
pp[broj_parametra]=
(1.0*n_uzoraka*(obr_t_bez_d)/frekvencija_mhz);
}
else
{
pp[broj_parametra]=
(1.0*n_uzoraka*(1+cyc_read1+cyc_u_memoriju+cyc_cekaj+8)/frekvencija_mhz);
//pp[broj_parametra]=
//(1.0*n_uzoraka*(d_int*br_t_d+br_t_bez_d)/frekvencija_mhz);
//pp[broj_parametra]=
//(1.0*n_uzoraka*((d_int*cyc_cekaj)+br_t_bez_d)/frekvencija_mhz);
}
//f
broj_parametra=1;
pp[broj_parametra]=1.0/pp[0];

//UAV
broj_parametra=2;
zbroj=0;
for(int j=1;j <= n_uzoraka;j++)//REZULTATI mjerenja
{
zbroj=zbroj+ p[j]-pola;
}
pp[broj_parametra]=5.0*zbroj/(n_uzoraka)/mjerni_opseg;

//MAX
broj_parametra=3;
pp[broj_parametra]=0;//-pola;
for(int j=1;j <= n_uzoraka;j++)//REZULTATI mjerenja
{
if(p[j]-pola > pp[broj_parametra])
pp[broj_parametra]= p[j]-pola;
}
pp[broj_parametra]=5.0*pp[broj_parametra]/mjerni_opseg;

//MIN
broj_parametra=4;
pp[broj_parametra]=255;
for(int j=1;j <= n_uzoraka;j++)//REZULTATI mjerenja
{
if(p[j]-pola < pp[broj_parametra])
pp[broj_parametra]= p[j]-pola;
}
pp[broj_parametra]=5.0*pp[broj_parametra]/mjerni_opseg;

//AV_EL
broj_parametra=5;
zbroj=0;
for ( int i = 1; i <= n_uzoraka; i++ )
{
zbroj=zbroj+ abs(p[i]-pola) ;
}
pp[broj_parametra]=1.0*zbroj/n_uzoraka;
pp[broj_parametra]=5.0*pp[broj_parametra]/mjerni_opseg;

//EF
broj_parametra=6;
zbroj=0;
for ( int i = 1; i <= n_uzoraka; i++ )
{
zbroj=zbroj + (p[i]-pola)*(p[i]-pola) ;
}
pp[broj_parametra]=sqrt(1.0*zbroj/n_uzoraka);
pp[broj_parametra]=5.0*pp[broj_parametra]/mjerni_opseg;

//Ă
broj_parametra=7;
zbroj=0;
for ( int i = 1; i <= n_uzoraka; i++ )
{
zbroj=zbroj + 100.0 * (p[i]-pola-pp[2]) * (p[i]-pola-pp[2]) / 255 / 255 ;
}
pp[broj_parametra]=sqrt(1.0*zbroj/n_uzoraka);

}

//FUNKCIJA:ISPIS GRAF
void ispis_graf()
{
tft.drawLine(2, 2, 124, 2, ST77XX_BLUE);
tft.drawLine(2, visina_grafa/2, 124, visina_grafa/2, ST77XX_BLUE);
tft.drawLine(2, visina_grafa, 124, visina_grafa, ST77XX_BLUE);
tft.drawLine(2, 0, 2, visina_grafa, ST77XX_BLUE);
tft.drawLine(64, 0, 64, visina_grafa, ST77XX_BLUE);
tft.drawLine(124, 0, 124, visina_grafa, ST77XX_BLUE);
for(int i=1;i <= n_uzoraka;i++)
{
//tft.drawLine(0, i, p_g[i], i, ST77XX_BLACK);
tft.drawPixel(i, visina_grafa-p_g[i]+1, ST77XX_BLACK);
tft.drawPixel(i, visina_grafa-p_g[i]+0, ST77XX_BLACK);
p_g[i]=visina_grafa*(p[i])/(mjerni_opseg);//10.23;//random(125);
//p_g[i]=1.0*(p[i][2]-pola)/p_max*100;///2.55;//10.23;//random(125);
tft.drawPixel(i, visina_grafa-p_g[i]+1, ST77XX_GREEN);
tft.drawPixel(i, visina_grafa-p_g[i]+0, ST77XX_GREEN);
}
//brisanje eventulnog repa grafa
for(int i=n_uzoraka+1; i < n_graf2;i++)
{
//tft.drawLine(0, i, p_g[i], i, ST77XX_BLACK);
tft.drawPixel(i, visina_grafa-p_g[i]+1, ST77XX_BLACK);
tft.drawPixel(i, visina_grafa-p_g[i]+0, ST77XX_BLACK);
}
}

//-------------------------------------

//FUNKCIJA:ISPIS_TEST
void ispis_test(int x, int y,int text_size,int broj,int d_int,int n_uzoraka
,long int kraj_serije_semplinga, long int pocetak_serije_semplinga,float d_float)
{
tft.setTextSize(text_size);
tft.setCursor(x, y);
tft.print("broj serije:");
tft.print(broj);
tft.setCursor(x, y+10);
tft.print("d_int:");
tft.print(d_int);
tft.setCursor(x+60, y+10);
tft.print("/n_semp:");
tft.print(n_uzoraka);
tft.setCursor(x, y+20);
tft.println(kraj_serije_semplinga-pocetak_serije_semplinga);
tft.setCursor(x+60, y+20);
tft.println(d_float);
}

//-------------------------------------
//-------------------------------------

//FUNKCIJA:ISPIS_UZORAKA_SERIAL
void ispis_uzoraka_serial(int redni_broj_pocetnog_uzorka)
{
Serial.println( "========================================================");
Serial.println( " NOVA SERIJA UZORAKA");
Serial.println( "========================================================");

Serial.print("broj serije: ");
Serial.println(broj_serija);
Serial.println( "---------------------");
Serial.print("Broj uzoraka: ");
Serial.println( n_uzoraka);
for (int i=0;i <= broj_parametara;i++)
{
if(i==7)
Serial.print("Ă = ");
else
Serial.print(pp_text[i]);
Serial.print(pp[i]);
Serial.println(pp_dim[i]);
}
if(test)
{
Serial.print("Trajanje kompletne serije: ");
Serial.print(kraj_serije_semplinga-pocetak_serije_semplinga);
Serial.println(" µs");
}
Serial.println( "---------------------");
Serial.println( " VREMENSKI DIJAGRAM");
crtam_vremensku_na_serial();
Serial.println( "-----------");
Serial.println();
Serial.println( " POPIS UZORAKA");

Serial.print( "Broj uzorka");
Serial.print( "\t");
//Serial.print( "SPEED");
//Serial.print( "\t");
//Serial.print( "ADC_T_0");
//Serial.print( "\t");
//Serial.print( "ULO*64");
//Serial.print( "\t");
Serial.print( "vrijednost uzorka/U[V]");
//Serial.print( "\t");
//Serial.print( "trajanje_serije");
Serial.println( "\t");

for(int j=redni_broj_pocetnog_uzorka;j <= n_uzoraka+1;j++)//REZULTATI mjerenja
{
Serial.print("S");Serial.print(j); Serial.print(".");
Serial.print( "\t");
Serial.print( "\t");
//Serial.print(speed_7_do_2_ADC);
//for(int k=0;k < 3;k++)
//{
//Serial.print( "\t");
Serial.print( p[j]);
//}//k, 0,1,2 iz polja
Serial.print( "/");
Serial.print( (p[j]-pola)/255*5);
Serial.print( "V");
Serial.println( "\t");
//Serial.println(kraj_serije_semplinga-pocetak_serije_semplinga);
//Serial.println(analogRead(A0));
//analogWrite(13,analogRead(A0)/4);
if(j==n_uzoraka+1)Serial.println( "-----------");
}//j, 0-255 iz polja

}

//-------------------------------------

//FUNKCIJA:CRTAJ_I_PISI_FREKVENTNU
void crtaj_i_pisi_frekventnu()
{
double mjerilo=8;
double harmonik_mjerila=5;
double xf,yf,xa=0,xa0=0,xff=0,xff0=0,nulla=80,nullf=129;

Serial.println( "---------------------");
Serial.println( " AMPLITUDNO-FREKVENCIJSKA KARAKTERISTIKA");

float xa_max=crtam_amplitudno_frekvencijsku_na_serial();
delay(1000);
if(ispis_serial)
{
Serial.println("-----------------------");
Serial.print("Harmonik");
Serial.print("\t");
Serial.print("Amplituda");
Serial.print("\t");
Serial.println("Kut");
}
//---------------
//CRTAM FREKVENTNU
tft.fillScreen(ST77XX_BLACK);
//bijeli pravokutnici
if(!test)
{
tft.fillRoundRect(55, 5, 60, 55, 5, ST77XX_WHITE);
tft.fillRoundRect(55, 85, 60, 55, 5, ST77XX_WHITE);
}
//vodoravlne linije
tft.drawLine(0, nulla, 128, nulla, 31*2048);//ST77XX_RED);
tft.drawLine(0, nulla+1, 128, nulla+1, ST77XX_WHITE);//ST77XX_RED);
tft.drawLine(0, nullf, 128, nullf, 31*2048 + 31);//ST77XX_MAGENTA);
tft.drawLine(0, nullf+1, 128, nullf+1, ST77XX_WHITE);//ST77XX_RED);
//okomite linije A-f

tft.drawLine(2, nulla-4, 2, nulla+4, 31*2048);//ST77XX_RED);
tft.drawLine(2+1, nulla-4, 2+1, nulla+4, ST77XX_WHITE);//ST77XX_RED);
tft.drawLine(mjerilo*harmonik_mjerila, nulla-4, mjerilo*harmonik_mjerila, nulla+4, 31*2048);//ST77XX_RED);
tft.drawLine(mjerilo*harmonik_mjerila+1, nulla-4, mjerilo*harmonik_mjerila+1, nulla+4, ST77XX_WHITE);//ST77XX_RED);

//0
tft.setTextColor(ST77XX_RED);
tft.setCursor(2, nulla+5);
tft.print(0);
tft.print(".");
tft.setTextColor(ST77XX_WHITE);
tft.setCursor(2+1, nulla+5);
tft.print(0);
tft.print(".");
//40
tft.setTextColor(ST77XX_RED);
tft.setCursor(mjerilo*harmonik_mjerila, nulla+5);
tft.print(harmonik_mjerila);
tft.print(".");
tft.setTextColor(ST77XX_WHITE);
tft.setCursor(mjerilo*harmonik_mjerila, nulla+5);
tft.print(harmonik_mjerila);
tft.print(".");

//okomite linije fi-f
tft.drawLine(2, nullf-4, 2, nullf+4, 31*2048 + 31);//ST77XX_MAGENTA);
tft.drawLine(2+1, nullf-4, 2+1, nullf+4, ST77XX_WHITE);//ST77XX_RED);
tft.drawLine(mjerilo*harmonik_mjerila, nullf-4, mjerilo*harmonik_mjerila, nullf+4, 31*2048 + 31);//ST77XX_MAGENTA);
tft.drawLine(mjerilo*harmonik_mjerila+1, nullf-4, mjerilo*harmonik_mjerila+1, nullf+4, ST77XX_WHITE);//ST77XX_RED);
tft.setTextColor(ST77XX_MAGENTA);
tft.setCursor(0, nullf+5);
tft.print(0);
tft.print(".");
tft.setTextColor(ST77XX_WHITE);
tft.setCursor(0+1, nullf+5);
tft.print(0);
tft.print(".");

tft.setTextColor(ST77XX_MAGENTA);
tft.setCursor(mjerilo*harmonik_mjerila, nullf+5);
tft.print(harmonik_mjerila);
tft.print(".");
tft.setTextColor(ST77XX_WHITE);
tft.setCursor(mjerilo*harmonik_mjerila+1, nullf+5);
tft.print(harmonik_mjerila);
tft.print(".");

//for( int k=1;k < 32;k++)
//{
//tft.drawLine(0, k, 128, k, k*2048); //k*64); //k*2048);
//}

for(int k=1;k < n_uzoraka;k++)//n_uzoraka-65;k++)
{
xf=0;
yf=0;
for(int n=0;n < (n_uzoraka-1)/2;n++)
{
xf=xf+p[n]*cos(2*pi*k*n/n_uzoraka);
yf=yf-p[n]*sin(2*pi*k*n/n_uzoraka);
}
xa0=xa;
xa=polar_apsol(xf,yf);
if((k > 1)and(k < mjerilo*harmonik_mjerila*3))
{
tft.drawLine((k-1)*mjerilo, nulla-xa0/xa_max*nulla, k*mjerilo, nulla-xa/xa_max*nulla, ST77XX_RED);
tft.drawLine((k-1)*mjerilo, nulla-xa0/xa_max*nulla-1, k*mjerilo, nulla-xa/xa_max*nulla-1, ST77XX_WHITE);
tft.drawLine((k-1)*mjerilo, nulla-xa0/xa_max*nulla+1, k*mjerilo, nulla-xa/xa_max*nulla+1, ST77XX_RED);
}

//tft.drawLine((k), nulla, k, nulla-xa, ST77XX_RED);
//tft.drawPixel(k, 160-xa, ST77XX_RED);
//tft.drawPixel(k, 160-xa+1, ST77XX_RED);
xff0=xff;
xff=polar_kut(xf,yf,pi);

tft.drawLine((k-1)*mjerilo, nullf-5*xff0, k*mjerilo, nullf-5*xff, ST77XX_MAGENTA);
tft.drawLine((k-1)*mjerilo, nullf-5*xff0-1, k*mjerilo, nullf-5*xff-1, ST77XX_WHITE);
tft.drawLine((k-1)*mjerilo, nullf-5*xff0-2, k*mjerilo, nullf-5*xff-2, ST77XX_MAGENTA);

//tft.drawPixel(k, 80-10*xff, ST77XX_MAGENTA);
//tft.drawPixel(k, 80-10*xff+1, 123);//ST77XX_MAGENTA);

if(k < 6)
{
tft.setTextColor(ST77XX_RED);
tft.setCursor(60, k*10);
tft.print(k);
tft.print(". ");
tft.print(xa);
tft.setCursor(61, k*10);
tft.print(k);
tft.print(". ");
tft.print(xa);
tft.setTextColor(ST77XX_MAGENTA);
tft.setCursor(60, 80+k*10);
tft.print(k);
tft.print(". ");
tft.print(" ");
tft.print((int)(xff/pi/2*360));
tft.setCursor(61, 80+k*10);
tft.print(k);
tft.print(". ");
tft.print(" ");
tft.print((int)(xff/pi/2*360));
tft.drawPixel(103, 81+k*10, ST77XX_MAGENTA);
tft.drawPixel(104, 80+k*10, ST77XX_MAGENTA);
tft.drawPixel(104, 82+k*10, ST77XX_MAGENTA);
tft.drawPixel(105, 81+k*10, ST77XX_MAGENTA);
}
{
tft.setCursor(4,150);
tft.setTextColor(ST77XX_YELLOW);
tft.print(" +serial monitor!");
}

//if(ispis_serial)
{
Serial.print("H");
Serial.print(k);
Serial.print(".");
Serial.print("\t");
Serial.print("\t");
Serial.print(xa);
Serial.print("\t");
Serial.print("\t");
Serial.print((int)(xff/pi/2*360));
Serial.println("°");
}
}//k

}

//-------------------------------------

//FUNKCIJA:POLAR_APSOL,APSOLUTNA VRIJEDNOST
float polar_apsol(float x, float y)
{
float r;
r=sqrt(x*x+y*y);
return r;
}

//-------------------------------------

//FUNKCIJA:POLAR_KUT
float polar_kut(float x, float y, float pi)
{
float fi;
if(x!=0)
{
fi=atan(y/x);
if(x < 0)fi=fi+pi;
}
else
{
if(y > 0)fi=pi/2;
else{fi=-pi/2;}
}
return fi;
}

//----------------
//FUNKCIJA:HOLD , ZA INTERRUPT
void hold() {
tft.setCursor(2,2);
tft.setTextColor(ST77XX_YELLOW);
tft.print("HOLD");
tft.setCursor(2,3);
tft.setTextColor(ST77XX_YELLOW);
tft.print("HOLD");
while(!digitalRead(2))
{ }
tft.setCursor(2,2);
tft.setTextColor(ST77XX_BLACK);
tft.print("HOLD");
tft.setCursor(2,3);
tft.setTextColor(ST77XX_BLACK);
tft.print("HOLD");
}

//---------------------------

float crtam_amplitudno_frekvencijsku_na_serial()
{
int dim=50;
float xag[dim],xa_max=0;
for(int k=0;k < dim;k++)//mjerilo*harmonik_mjerila*3;k++)//n_uzoraka-65;k++)
{
xf=0;
yf=0;
for(int n=0;n < n_uzoraka-1;n++)
{
xf=xf+p[n]*cos(2*pi*k*n/n_uzoraka);
yf=yf-p[n]*sin(2*pi*k*n/n_uzoraka);
}
xag[k]=polar_apsol(xf,yf);
if(xag[k] > xa_max)xa_max=xag[k];
}

bool tg[dim];
for(int x=0;x < dim;x++)//n_uzoraka-65;k++)
{
tg[x]=false;
}
for(int y=19;y >= 0;y--)//n_uzoraka-65;k++)
{
Serial.print(y/20.0);
Serial.print("\t");
for(int k=0;k < dim;k++)//n_uzoraka-65;k++)
{
if((xag[k] >= (y)/20.0*xa_max)and(xag[k] < (y+1)/20.0*xa_max))
{

Serial.print("I");//char(5));//"A");
tg[k]=true;
}
else
{
if(tg[k]==true)
Serial.print("I");
else
Serial.print(" ");
}
}
Serial.println("");
}
//Serial.println(" 0 10 20 30 40 50");
Serial.print("\t");
Serial.print(0);
Serial.print("\t");
Serial.print(10);
Serial.print("\t");
Serial.print(20);
Serial.print("\t");
Serial.print(30);
Serial.print("\t");
Serial.print(40);
Serial.print("\t");
Serial.print(50);

return xa_max;
}
//-------------------------------
void crtam_vremensku_na_serial()
{
//iiiiiiiiiiiiiiiiiiiiiiiiiii
int dim=42;
float xag[dim],xa_max=0;
for(int k=0;k < dim;k++)//mjerilo*harmonik_mjerila*3;k++)//n_uzoraka-65;k++)
{
xf=0;
yf=0;
for(int n=0;n < n_uzoraka-1;n++)
{
xf=xf+p[n]*cos(2*pi*k*n/n_uzoraka);
yf=yf-p[n]*sin(2*pi*k*n/n_uzoraka);
}
xag[k]=polar_apsol(xf,yf);
if(xag[k] > xa_max)xa_max=xag[k];
xag[k]=0;
if(k*3 < n_uzoraka)
xag[k]=p[k*3];
xa_max=255;
}

bool tg[dim];
for(int x=0;x < dim;x++)//n_uzoraka-65;k++)
{
tg[x]=false;
}

for(int y=19;y >= 1;y--)//n_uzoraka-65;k++)
{
//Serial.print(y/20.0);
Serial.print(y*13.0/255*5-2.5);
Serial.print("V");
Serial.print("\t");
for(int k=0;k < dim;k++)//n_uzoraka-65;k++)
{
if((xag[k] >= (y)/20.0*xa_max)and(xag[k] < (y+1)/20.0*xa_max))
{

Serial.print("I");//char(5));//"A");
tg[k]=true;
for(int i=y;i >= 0;i--)//n_uzoraka-65;k++)
{
//tg[k][i]=true;
}
}
else
{
if(tg[k]==true)
Serial.print("I");
else
Serial.print(" ");
}
}
Serial.println("");
}
Serial.print(" ");
for(int i=0;i <= n_uzoraka;i++)
{
if(i%30==0)
{
Serial.print("~");
if(pp[0] < 0.001)
{
Serial.print(round( 1000000.0*i*pp[0]/n_uzoraka) );
Serial.print("us");
}
else if(pp[0] < 1)
{
Serial.print( round(1000.0*i*pp[0]/n_uzoraka) );
Serial.print("ms");
}
else
{
Serial.print( round(1.0*i*pp[0]/n_uzoraka) );
Serial.print("s");
}
Serial.print("\t");
}
}
Serial.println();
delay(1000);

//jjjjjjjjjjjjjjjjjjjjjjjj
}

06.10.2024. u 23:34 • 1 Komentara • Print • #

Opis uređaja

1. TEHNIČKE KARAKTERISTIKE
Ovaj osciloskop ima samo jedno područje mjerenja (-2,5V do 2,5V).
Okidanje (Triggger level i trigger slope) je fiksirano na 0V, uzlazno.
Preporučljive frekvencije koje se mogu mjeriti su 20Hz do cca. 5KHz.
Broj semplinga po periodi je 122-126 (ili manje za frekvencije veće od cca. 4.5KHz).
Ulazni otpor je 500 ohma.
Pored ekrana RB-TFT1.8-T može se koristiti i Serial monitor.
Ako Arduino Uno napajamo pomoću računala, treba dodatni oprez ako mjerimo neki izvor koji električki ne pliva u odnosu na računalo.
Napajanje može biti izvor od 5V; postoji i mogućnost napajanja preko USB priključka na raćunalo, ali onda se uglavnom moraju mjeriti naponi koji električki plivaju u odnosu na računalo.

---------------------------------------------------

2. EKRAN (osnovni parametri ekrana)
RB-TFT1,8-T
visina ekrana 1.8" (4,57 cm)
rezolucija 128(125) x 160 Pixel
napon naoajanja 3.3 V
napon logike 3.3 V
sučelje SPI
kompatibilnost Raspberry Pi, micro:bit, Arduino (3.3 V logic)
signalne veze sa mikokontrolerom su ostvarene preko djelila 1K-2,2K

---------------------------------------------------

3.OPIS HARDVERA

3.1. Ulaz
Ako između +5V i GND mikrokontrolera stavimo naponsko djelilo 1K+1K(za veći ulazni otpor može i 100K+100K), onda možemo postojećim potencijalima dati ove vrijednosti: -2,5V(inače je GND) ; 0V (usred djelila) i 2,5V(inače je 5V)

3.2. ADC
ADC je dio mikrokontrolera koji može pretvoriti ulazni napon(napon na A0) u broj. U ovom softveru se koristi samo jedan Byte za mjerenje tako da dobivamo brojeve 0-255 (za napone od 0-5V), ali zbog ulaznog naponskog djelila takve rezultate ćemo tumačiti kao brojeve od -128 do 127 (naponi od -2,5V do 2,5V)

3.3. Kondenzator na Uref
Kondenzator od 100nF služi za stabiliziranje napona kada ADC mjeri.

3.4. RB-TFT1,8-T
Ovaj ekran ima SPI sučelje za 3,3V ; ali zbog toga što nema povratnih informacija iz ekrana prema mikrokontroleru možemo jednostavno ostvariti komunikaciju tako da na sve kanale komunikacije stavimo naponsko djelilo 1K-2K2 , pa će onda svaki napon 5V iz mikrokontrolera prema ekranu biti smanjen na cca. 3,3V(!)

3.5. Osciloskop/Frekventni analizator
Na pinu 3 možemo pomoću sklopke mijenjati nočin rada, uređaj može biti osciloskop, ali i frekventni analizator.

3.6. Hold
Na ulazu 2 moženo zaustaviti promjenu slika i podataka.

3.7. Testiranje
3.7.1. Uređaj za testiranje (izveden pomoću LM324)
LM324 ima 4 operaciona pojačala, ali za ovaj uređaj koristimo samo 3; na izlazima se (respektivno prema shemi) pojavljuju izmjenični naponi pravokutnog, trokutastog i sinusnog oblika koji titraju oko napona 0V.
Potenciometar od 100K služi za mijenjanje frekvencije od cca. 60Hz do cca. 5KHz;
3.7.2. Testiranje pomoću neko digitalnog izlaza
Ako za neki digitalni izlaz damo PWM (kvazianalogni napon) izlaz, onda imamo na raspolaganju pravokutni napon frekvecije cca.500Hz, možemo ga upotrebiti za testiranje
3.7.3. Testiranje pomoću "žice u zraku"
Ako ulazni vodič jednim krajem ne spojimo nigdje (drugi kraj je utaknut u pin A0), onda postoji velika vjerojatnost da ćemo mjeriti napon frekvencije 50Hz.

---------------------------------------------------

4. OPIS SOFTVERA

4.1. Instalacija
Datoteke *.ino i *.S treba smjestiti u istoimenu mapu (npr. u mapu "instrument" treba smjetiti datoteku "instrument.ino" i datoteku "instrument.S")

4.2. Korištenje
Nakon pokretanja datoteke *.ino u Arduino okruženju treba "poslati" sadržaj u mikrokontroler (koji je spojen sa pripadajućim hardverom), pa zatim koristiti mikrokontroler kao instrument.

4.3. Detaljniji opis softvera
4.3.1. *.ino datoteka
Program se uglavnom sastoji od poziva datoteke *.S (za ostvarivanje seije uzoraka) i ovih funkcija:
void statistika()
void ispis_graf()
void ispis_test(int x, int y,int text_size,int broj,int d_int,int n_uzoraka
,long int kraj_serije_semplinga, long int pocetak_serije_semplinga,float d_float)
void ispis_uzoraka_serial(int redni_broj_pocetnog_uzorka)
void crtaj_i_pisi_frekventnu()
float polar_apsol(float x, float y)
float polar_kut(float x, float y, float pi)
void hold()
float crtam_amplitudno_frekvencijsku_na_serial()
void crtam_vremensku_na_serial()
Smisao svake funkcije je relativno jasan iz njezinog naziva.
4.3.2. *.S datoteka
Funkcije koje se koriste su najčešće:
init_ADC: - za početak rada sa ADC0
init_and_read_ADC1: - za mjerenje offseta kod napajanja operacionog pojačala LM324
rread0_ADC: - za mjerenje serije uzoraka sa višom frekvencijom
rread_ADC: - za mjerenje serije uzoraka sa nižom frekvencijom
read1_ADC: - za jedno mjerenje
u_memoriju: - za smještanje podataka u polje p
cekaj: - za čekanje programa do slijedećeg uzorka
Koriste se registri R16, R18, R20, R22, R24 za ulaz podataka
U programu se koriste registri R16 do R31

---------------------------------------------------

06.10.2024. u 23:22 • 0 Komentara • Print • #

četvrtak, 03.10.2024.

Sheme

1. Sheme za mjerenje i prikaz na Serial monitor

- osnovna shema za prvu brzu provjeru rada programa; dovoljno je instairati softver ( *. ino i *.S datoteke) , dovrsti napajanje na Arduino Uno i spojiti jedan vodič jednim krajem u A0 , a drugim krajem "u zraku", za dobivanje signala od 50Hz na Serial monitoru može se "pomoći" ulaznom naponu dodirivanjem slobodnog kraja vodiča prstima