Пт апр 17, 2020 16:43:28
Пт апр 17, 2020 18:06:07
#include <SPI.h>
#include <avr/pgmspace.h>
#define ST7735_CS A3
#define ST7735_RST A4
#define ST7735_A0 6
#define ENC_CLK 2
#define ENC_DT A5
#define ENC_SW 3
#define W_CLK 7
#define FQ_UD 8
#define DATA 9
#define RESET A2
#define DAC 4
#define HWRST_SET digitalWrite(ST7735_RST,HIGH)
#define HWRST_RESET digitalWrite(ST7735_RST,LOW)
#define ST7735_COMMAND digitalWrite(ST7735_A0,LOW)
#define ST7735_DATA digitalWrite(ST7735_A0,HIGH)
#define ST7735_SELECT digitalWrite(ST7735_CS,LOW)
#define ST7735_UNSELECT digitalWrite(ST7735_CS,HIGH)
#define INP_VAL A0
#define pulseHigh(pin) {digitalWrite(pin, HIGH); digitalWrite(pin, LOW); }
String serial_readline = "";
const int bSize = 64;
char Buffer[bSize];
long freq = 35000000;
const uint16_t scr_width = 128;
const uint16_t scr_height = 128;
const uint16_t OffSetX = 2;
const uint16_t OffSetY = 1;
int enc_FreqStep = 1;
volatile unsigned long previousMillis;
long currentMillis;
const byte En_speed_1 = 50;
const byte En_speed_2 = 100;
const int Step_int_1 = 100;
const int Step_int_2 = 10;
long enc_StepMultip = 1;
int enc_ALast;
int enc_AVal;
float vin = 0; //Volts rounded
String freq_string_hz;
String freq_string_khz;
String freq_string_mhz;
long debouncing_time = 500;
volatile unsigned long last_micros;
char const Font7x11[] PROGMEM =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // space 0x20 32
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x08, 0x08, // ! 0x21 33
0x12, 0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // " 0x22 34
0x48, 0x48, 0x24, 0x7f, 0x24, 0x24, 0x12, 0x7f, 0x12, 0x09, 0x09, // # 0x23 35
0x08, 0x3e, 0x49, 0x09, 0x09, 0x3e, 0x48, 0x48, 0x49, 0x3e, 0x08, // $ 0x24 36
0x47, 0x25, 0x27, 0x10, 0x10, 0x08, 0x08, 0x04, 0x72, 0x52, 0x71, // % 0x25 37
0x06, 0x09, 0x09, 0x09, 0x26, 0x22, 0x25, 0x29, 0x11, 0x29, 0x46, // & 0x26 38
0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ' 0x27 39
0x08, 0x04, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x04, 0x08, // ( 0x28 40
0x04, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, // ) 0x29 41
0x00, 0x08, 0x2a, 0x1c, 0x2a, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // * 0x2A 42
0x00, 0x00, 0x00, 0x08, 0x08, 0x3e, 0x08, 0x08, 0x00, 0x00, 0x00, // + 0x2B 43
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0c, 0x04, // , 0x2C 44
0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, // - 0x2D 45
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, // . 0x2E 46
0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x04, 0x04, 0x04, 0x02, 0x02, // / 0x2F 47
0x1c, 0x22, 0x51, 0x51, 0x49, 0x49, 0x49, 0x45, 0x45, 0x22, 0x1c, // 0 0x30 48
0x08, 0x0c, 0x0a, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, // 1 0x31 49
0x1e, 0x21, 0x40, 0x40, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x7f, // 2 0x32 50
0x1f, 0x20, 0x40, 0x40, 0x20, 0x1e, 0x20, 0x40, 0x40, 0x20, 0x1f, // 3 0x33 51
0x30, 0x28, 0x24, 0x22, 0x21, 0x7f, 0x20, 0x20, 0x20, 0x20, 0x20, // 4 0x34 52
0x7f, 0x01, 0x01, 0x01, 0x1f, 0x20, 0x40, 0x40, 0x40, 0x20, 0x1f, // 5 0x35 53
0x38, 0x04, 0x02, 0x01, 0x1d, 0x23, 0x41, 0x41, 0x41, 0x22, 0x1c, // 6 0x36 54
0x7f, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x04, 0x02, // 7 0x37 55
0x1c, 0x22, 0x41, 0x41, 0x22, 0x1c, 0x22, 0x41, 0x41, 0x22, 0x1c, // 8 0x38 56
0x1c, 0x22, 0x41, 0x41, 0x41, 0x62, 0x5c, 0x40, 0x20, 0x10, 0x0e, // 9 0x39 57
0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, // : 0x3A 58
0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x08, 0x04, // ; 0x3B 59
0x00, 0x40, 0x30, 0x0c, 0x02, 0x01, 0x02, 0x0c, 0x30, 0x40, 0x00, // < 0x3C 60
0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, // = 0x3D 61
0x00, 0x01, 0x06, 0x18, 0x20, 0x40, 0x20, 0x18, 0x06, 0x01, 0x00, // > 0x3E 62
0x3e, 0x41, 0x40, 0x40, 0x30, 0x08, 0x08, 0x08, 0x00, 0x08, 0x08, // ? 0x3F 63
0x1c, 0x22, 0x41, 0x49, 0x55, 0x55, 0x55, 0x39, 0x01, 0x02, 0x3c, // @ 0x40 64
0x08, 0x14, 0x14, 0x22, 0x22, 0x41, 0x41, 0x7f, 0x41, 0x41, 0x41, // A 0x41 65
0x1f, 0x21, 0x21, 0x21, 0x1f, 0x21, 0x41, 0x41, 0x41, 0x21, 0x1f, // B 0x42 66
0x3c, 0x42, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x42, 0x3c, // C 0x43 67
0x1f, 0x22, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x22, 0x1f, // D 0x44 68
0x7f, 0x01, 0x01, 0x01, 0x1f, 0x01, 0x01, 0x01, 0x01, 0x01, 0x7f, // E 0x45 69
0x7f, 0x01, 0x01, 0x01, 0x3f, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // F 0x46 70
0x3c, 0x42, 0x01, 0x01, 0x01, 0x79, 0x41, 0x41, 0x41, 0x42, 0x3c, // G 0x47 71
0x41, 0x41, 0x41, 0x41, 0x7f, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, // H 0x48 72
0x1c, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x1c, // I 0x49 73
0x1e, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x0e, // J 0x4A 74
0x21, 0x11, 0x09, 0x05, 0x03, 0x03, 0x05, 0x09, 0x11, 0x21, 0x41, // K 0x4B 75
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x7f, // L 0x4C 76
0x41, 0x63, 0x55, 0x55, 0x49, 0x49, 0x41, 0x41, 0x41, 0x41, 0x41, // M 0x4D 77
0x41, 0x41, 0x41, 0x43, 0x43, 0x45, 0x49, 0x51, 0x51, 0x61, 0x41, // N 0x4E 78
0x1c, 0x22, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x22, 0x1c, // O 0x4F 79
0x1f, 0x21, 0x41, 0x41, 0x41, 0x21, 0x1f, 0x01, 0x01, 0x01, 0x01, // P 0x50 80
0x1c, 0x22, 0x41, 0x41, 0x41, 0x41, 0x41, 0x49, 0x51, 0x22, 0x5c, // Q 0x51 81
0x1f, 0x21, 0x41, 0x41, 0x41, 0x21, 0x1f, 0x09, 0x11, 0x21, 0x41, // R 0x52 82
0x1c, 0x22, 0x41, 0x01, 0x02, 0x1c, 0x20, 0x40, 0x41, 0x22, 0x1c, // S 0x53 83
0x7f, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, // T 0x54 84
0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x22, 0x1c, // U 0x55 85
0x41, 0x41, 0x22, 0x22, 0x22, 0x22, 0x14, 0x14, 0x14, 0x08, 0x08, // V 0x56 86
0x41, 0x41, 0x41, 0x41, 0x49, 0x49, 0x49, 0x55, 0x55, 0x63, 0x41, // W 0x57 87
0x41, 0x22, 0x22, 0x14, 0x08, 0x08, 0x08, 0x14, 0x22, 0x22, 0x41, // X 0x58 88
0x41, 0x41, 0x22, 0x14, 0x14, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, // Y 0x59 89
0x7f, 0x40, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x01, 0x7f, // Z 0x5A 90
0x1c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x1c, // [ 0x5B 91
0x01, 0x02, 0x02, 0x04, 0x04, 0x04, 0x08, 0x08, 0x08, 0x10, 0x10, // \ 0x5C 92
0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e, // ] 0x5D 93
0x08, 0x14, 0x22, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ^ 0x5E 94
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, // _ 0x5F 95
0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ` 0x60 96
0x00, 0x00, 0x00, 0x3e, 0x41, 0x40, 0x7e, 0x41, 0x41, 0x61, 0x5e, // a 0x61 97
0x01, 0x01, 0x01, 0x1d, 0x23, 0x41, 0x41, 0x41, 0x41, 0x23, 0x1d, // b 0x62 98
0x00, 0x00, 0x00, 0x3c, 0x42, 0x01, 0x01, 0x01, 0x01, 0x42, 0x3c, // c 0x63 99
0x40, 0x40, 0x40, 0x5c, 0x62, 0x41, 0x41, 0x41, 0x41, 0x62, 0x5c, // d 0x64 100
0x00, 0x00, 0x00, 0x1c, 0x22, 0x41, 0x7f, 0x01, 0x01, 0x42, 0x3c, // e 0x65 101
0x1c, 0x04, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, // f 0x66 102
0x00, 0x00, 0x00, 0x5e, 0x61, 0x41, 0x61, 0x5e, 0x40, 0x21, 0x1e, // g 0x67 103
0x01, 0x01, 0x01, 0x3d, 0x43, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, // h 0x68 104
0x08, 0x08, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, // i 0x69 105
0x00, 0x10, 0x00, 0x18, 0x10, 0x10, 0x10, 0x10, 0x10, 0x12, 0x0c, // j 0x6A 106
0x01, 0x01, 0x01, 0x21, 0x11, 0x09, 0x07, 0x09, 0x11, 0x21, 0x41, // k 0x6B 107
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0c, // l 0x6C 108
0x00, 0x00, 0x00, 0x25, 0x5b, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, // m 0x6D 109
0x00, 0x00, 0x00, 0x1d, 0x23, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, // n 0x6E 110
0x00, 0x00, 0x00, 0x1c, 0x22, 0x41, 0x41, 0x41, 0x41, 0x22, 0x1c, // o 0x6F 111
0x00, 0x00, 0x00, 0x1f, 0x21, 0x41, 0x41, 0x21, 0x1f, 0x01, 0x01, // p 0x70 112
0x00, 0x00, 0x00, 0x2c, 0x32, 0x21, 0x21, 0x21, 0x32, 0x2c, 0x20, // q 0x71 113
0x00, 0x00, 0x00, 0x3d, 0x43, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // r 0x72 114
0x00, 0x00, 0x00, 0x3e, 0x41, 0x01, 0x0e, 0x30, 0x40, 0x41, 0x3e, // s 0x73 115
0x00, 0x04, 0x04, 0x3e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x38, // t 0x74 116
0x00, 0x00, 0x00, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x31, 0x2e, // u 0x75 117
0x00, 0x00, 0x00, 0x41, 0x41, 0x22, 0x22, 0x14, 0x14, 0x08, 0x08, // v 0x76 118
0x00, 0x00, 0x00, 0x41, 0x41, 0x41, 0x49, 0x49, 0x49, 0x49, 0x36, // w 0x77 119
0x00, 0x00, 0x00, 0x41, 0x22, 0x14, 0x08, 0x08, 0x14, 0x22, 0x41, // x 0x78 120
0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x24, 0x38, 0x10, 0x08, 0x06, // y 0x79 121
0x00, 0x00, 0x00, 0x7f, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x7f, // z 0x7A 122
0x18, 0x08, 0x08, 0x08, 0x04, 0x06, 0x04, 0x08, 0x08, 0x08, 0x18, // { 0x7B 123
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, // | 0x7C 124
0x0c, 0x08, 0x08, 0x08, 0x10, 0x30, 0x10, 0x08, 0x08, 0x08, 0x0c, // } 0x7D 125
0x00, 0x00, 0x00, 0x00, 0x04, 0x0a, 0x51, 0x20, 0x00, 0x00, 0x00, // ~ 0x7E 126
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
}; // 0x7F 127
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x0400
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define VIOLET 0xEC1D
#define AQUA 0x07FF
void setup()
{
switchToExtQuartz();
pinMode(ST7735_RST, OUTPUT);
pinMode(ST7735_CS, OUTPUT);
pinMode(ST7735_A0, OUTPUT);
pinMode(ENC_CLK, INPUT_PULLUP);
pinMode(ENC_DT, INPUT_PULLUP);
pinMode(ENC_SW, INPUT_PULLUP);
pinMode(FQ_UD, OUTPUT);
pinMode(W_CLK, OUTPUT);
pinMode(DATA, OUTPUT);
pinMode(RESET, OUTPUT);
SPI.begin();
ST7735_init();
ST7735_Clear(BLACK);
pinMode(DAC, ANALOG);
analogReference(INTERNAL4V096);
analogReadResolution(12);
Serial.begin(115200);
attachInterrupt(0, checkEncoder, CHANGE);
}
void checkEncoder() {
byte enc_DT;
enc_AVal = digitalRead(ENC_CLK);
enc_DT = digitalRead(ENC_DT);
enc_FreqStep = 1;
if (!enc_AVal && enc_ALast) {
currentMillis = millis();
if (currentMillis - previousMillis < En_speed_1) enc_FreqStep = Step_int_1;
else if (currentMillis - previousMillis < En_speed_2) enc_FreqStep = Step_int_2;
else enc_FreqStep = 1;
previousMillis = currentMillis;
if (enc_DT) {
freq = freq + enc_FreqStep * enc_StepMultip;
if (freq >= 40000000) freq = 40000000;
sendFrequency(freq);
} else {
freq = freq - enc_FreqStep * enc_StepMultip;
if (freq <= 0) freq = 0;
sendFrequency(freq);
}
}
enc_ALast = enc_AVal;
}
void tfr_byte(byte data)
{
for (int i = 0; i < 8; i++, data >>= 1) {
digitalWrite(DATA, data & 0x01);
pulseHigh(W_CLK);
}
}
void sendFrequency(double frequency) {
int32_t freq = frequency * 4294967295 / 125000000;
for (int b = 0; b < 4; b++, freq >>= 8) {
tfr_byte(freq & 0xFF);
}
tfr_byte(0x000);
pulseHigh(FQ_UD);
}
float readInVoltage()
{
vin = 0;
for (int i = 0; i < 12; i++)
{
vin = vin + ((float)analogRead(INP_VAL) / 4096 * 4.096);
}
vin = vin / 12;
return vin;
}
void printInfo() { //вывод информации на экран
String vol_str = "IN: " + String(readInVoltage(), 6) + "V";
ST7735_PutStr7x11(0, 0, vol_str.c_str(), YELLOW, BLACK);
String fr_str = "000000000" + String(freq) + "Hz";
fr_str = "Fr: " + fr_str.substring(fr_str.length() - 10);
if (enc_StepMultip == 1000000) {
ST7735_HLine(32, 46, 27, AQUA);
ST7735_HLine(47, 94, 27, BLACK);
}
if (enc_StepMultip == 1000) {
ST7735_HLine(48, 70, 27, AQUA);
ST7735_HLine(72, 94, 27, BLACK);
ST7735_HLine(32, 46, 27, BLACK);
}
if (enc_StepMultip == 1) {
ST7735_HLine(72, 94, 27, AQUA);
ST7735_HLine(32, 71, 27, BLACK);
}
ST7735_PutStr7x11(0, 15, fr_str.c_str(), YELLOW, BLACK);
}
void loop()
{
if (digitalRead(ENC_SW) == LOW) {
if ((long)(micros() - last_micros) >= debouncing_time * 1000) { //защита от дребезга контактов
if (digitalRead(ENC_SW) == LOW)
{
ST7735_HLine(0, 127, 27, BLACK);
if (enc_StepMultip == 1) enc_StepMultip = 1000;
else if (enc_StepMultip == 1000) enc_StepMultip = 1000000;
else enc_StepMultip = 1;
}
last_micros = micros();
}
}
while (Serial.available() > 0)
{
memset(Buffer, 0, bSize);
Serial.readBytesUntil('\n', Buffer, bSize);
serial_readline = String(Buffer);
if (serial_readline.startsWith("GET "))
{
freq = (long)serial_readline.substring(4).toFloat();
sendFrequency(freq);
Serial.println(readInVoltage(), 6);
}
Serial.flush();
}
printInfo();
}
/*************************************************************************************************************
Драйвер lcg 1.44" 128X128 ST7735 VER 1.0. на красной плате
************************************************************************************************************/
uint16_t RGB565(uint8_t R, uint8_t G, uint8_t B)
{
return ((R >> 3) << 11) | ((G >> 2) << 5) | (B >> 3);
}
void ST7735_PutChar7x11(uint16_t X, uint16_t Y, uint8_t chr, uint16_t color, uint16_t bgcolor)
{
uint16_t i, j;
uint8_t buffer[11];
uint8_t CH = color >> 8;
uint8_t CL = (uint8_t)color;
uint8_t BCH = bgcolor >> 8;
uint8_t BCL = (uint8_t)bgcolor;
memcpy_P(buffer, &Font7x11[(chr - 32) * 11], 11);
ST7735_AddrSet(X, Y, X + 7, Y + 11);
ST7735_DATA;
for (i = 0; i < 11; i++)
{
for (j = 0; j < 7; j++)
{
if ((buffer[i] >> j) & 0x01)
{
ST7735_write(CH);
ST7735_write(CL);
}
else
{
ST7735_write(BCH);
ST7735_write(BCL);
}
}
ST7735_write(BCH);
ST7735_write(BCL);
}
for (i = 0; i < 8; i++)
{
ST7735_write(BCH);
ST7735_write(BCL);
}
}
void ST7735_PutStr7x11(uint8_t X, uint8_t Y, char *str, uint16_t color, uint16_t bgcolor)
{
while (*str)
{
ST7735_PutChar7x11(X, Y, *str++, color, bgcolor);
if (X < scr_width - 8) {
X += 8;
} else if (Y < scr_height - 12) {
X = 0;
Y += 12;
} else {
X = 0;
Y = 0;
}
};
}
void ST7735_Clear(uint16_t color)
{
uint16_t i;
uint8_t CH, CL;
CH = color >> 8;
CL = (uint8_t)color;
ST7735_AddrSet(0, 0, (scr_width - 1), (scr_height - 1));
ST7735_DATA;
for (i = 0; i < (scr_width * scr_height); i++) {
ST7735_write(CH);
ST7735_write(CL);
}
}
void ST7735_AddrSet(uint16_t XS, uint16_t YS, uint16_t XE, uint16_t YE)
{
XS = XS + OffSetX;
XE = XE + OffSetX;
YS = YS + OffSetY;
YE = YE + OffSetY;
ST7735_cmd(0x2a);
ST7735_DATA;
ST7735_write(XS >> 8);
ST7735_write(XS);
ST7735_write(XE >> 8);
ST7735_write(XE);
ST7735_cmd(0x2b);
ST7735_DATA;
ST7735_write(YS >> 8);
ST7735_write(YS);
ST7735_write(YE >> 8);
ST7735_write(YE);
ST7735_cmd(0x2c);
}
void ST7735_HWRST()
{
HWRST_RESET;
HWRST_SET;
}
void ST7735_data(uint8_t data)
{
ST7735_DATA;
ST7735_write(data);
}
void ST7735_SWRST()
{
ST7735_cmd(0x01);
ST7735_data(0x01);
}
void ST7735_write(uint8_t data)
{
ST7735_SELECT;
SPI.transfer(data);
ST7735_UNSELECT;
}
void ST7735_cmd(uint8_t cmd)
{
ST7735_COMMAND;
ST7735_write(cmd);
}
void ST7735_Pixel(uint16_t X, uint16_t Y, uint16_t color)
{
ST7735_AddrSet(X, Y, X, Y);
ST7735_DATA;
ST7735_write(color >> 8);
ST7735_write((uint8_t)color);
}
void ST7735_HLine(uint16_t X1, uint16_t X2, uint16_t Y, uint16_t color)
{
uint16_t i;
uint8_t CH = color >> 8;
uint8_t CL = (uint8_t)color;
ST7735_AddrSet(X1, Y, X2, Y);
ST7735_DATA;
for (i = 0; i <= (X2 - X1); i++)
{
ST7735_write(CH);
ST7735_write(CL);
}
}
void ST7735_VLine(uint16_t X, uint16_t Y1, uint16_t Y2, uint16_t color)
{
uint16_t i;
uint8_t CH = color >> 8;
uint8_t CL = (uint8_t)color;
ST7735_AddrSet(X, Y1, X, Y2);
ST7735_DATA;
for (i = 0; i <= (Y2 - Y1); i++)
{
ST7735_write(CH);
ST7735_write(CL);
}
}
void ST7735_Line(int16_t X1, int16_t Y1, int16_t X2, int16_t Y2, uint16_t color)
{
int16_t dX = X2 - X1;
int16_t dY = Y2 - Y1;
int16_t dXsym = (dX > 0) ? 1 : -1;
int16_t dYsym = (dY > 0) ? 1 : -1;
if (dX == 0)
{
if (Y2 > Y1) ST7735_VLine(X1, Y1, Y2, color); else ST7735_VLine(X1, Y2, Y1, color);
return;
}
if (dY == 0)
{
if (X2 > X1) ST7735_HLine(X1, X2, Y1, color); else ST7735_HLine(X2, X1, Y1, color);
return;
}
dX *= dXsym;
dY *= dYsym;
int16_t dX2 = dX << 1;
int16_t dY2 = dY << 1;
int16_t di;
if (dX >= dY)
{
di = dY2 - dX;
while (X1 != X2)
{
ST7735_Pixel(X1, Y1, color);
X1 += dXsym;
if (di < 0)
{
di += dY2;
}
else
{
di += dY2 - dX2;
Y1 += dYsym;
}
}
}
else
{
di = dX2 - dY;
while (Y1 != Y2)
{
ST7735_Pixel(X1, Y1, color);
Y1 += dYsym;
if (di < 0)
{
di += dX2;
}
else
{
di += dX2 - dY2;
X1 += dXsym;
}
}
}
ST7735_Pixel(X1, Y1, color);
}
void ST7735_Rect(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, uint16_t color)
{
ST7735_HLine(X1, X2, Y1, color);
ST7735_HLine(X1, X2, Y2, color);
ST7735_VLine(X1, Y1, Y2, color);
ST7735_VLine(X2, Y1, Y2, color);
}
void ST7735_FillRect(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2, uint16_t color)
{
uint16_t i;
uint16_t FS = (X2 - X1 + 1) * (Y2 - Y1 + 1);
uint8_t CH = color >> 8;
uint8_t CL = (uint8_t)color;
ST7735_AddrSet(X1, Y1, X2, Y2);
ST7735_DATA;
for (i = 0; i < FS; i++)
{
ST7735_write(CH);
ST7735_write(CL);
}
}
void ST7735_init() {
ST7735_HWRST();
ST7735_SWRST();
ST7735_cmd(0x11);
delay(20);
ST7735_cmd(0xB4);
ST7735_data(0x03);
ST7735_cmd(0x3a);
ST7735_data(0x05);
ST7735_cmd(0x36);
ST7735_data(0x8);
ST7735_cmd(0x29);
}
void switchToExtQuartz() {
bitSet(PMCR, PMCE);
bitSet(PMCR, OSCMEN);
asm("nop");
asm("nop");
asm("nop");
bitSet(PMCR, PMCE);
bitClear(PMCR, CLKFS);
bitSet(PMCR, CLKSS);
asm("nop");
asm("nop");
asm("nop");
}
Пт апр 17, 2020 22:40:37
Сб апр 18, 2020 06:21:16
Сб апр 18, 2020 07:36:02
Сб апр 18, 2020 07:48:28
Сб апр 18, 2020 08:35:59
enum {Start_Gkch, Stop_Gkch, Fr0, Fr1, Step, Set_fr, Out_ADC, V1,
V5, A0, A2, SpeedMax, SpeedMin, SetFzad, Izm_Fk, Get_Fzg,
A3, A4, SET_PAUZ, FKM, END_FUN};
Сб апр 18, 2020 08:42:30
Сб апр 18, 2020 09:45:33
Сб апр 18, 2020 10:41:48
Сб апр 18, 2020 11:20:37
uint8_t Flag_Prog[COUNT_MF]
Fun[Fr0]=fr0;
Fun[Fr1]=fr1;
Fun[Step]=step;
Fun[Start_Gkch]=start_gkch;
Fun[Stop_Gkch]=stop_gkch;
Fun[V5]=v5;
Fun[V1]=v1;
Fun[A0]=a0;
Fun[A2]=a2;
Fun[A3]=a3;
Fun[A4]=a4;
if(crc==data)
{
Flag_Prog[kod_command >> 3] |= (1 << (kod_command & 0x07));
}
while (1)
{
for(i=0, mf=0; mf < COUNT_MF; mf++)
{
if(Flag_Prog[mf] == 0){i+=8; continue;}
for(sdvig = 0x01; sdvig != 0 ;sdvig <<= 1,i++)
{
if(Flag_Prog[mf] & sdvig)
{
Flag_Prog[mf] &= ~sdvig;
Fun[i]();
}
}
}
if(f_izm !=0 )
{
f_izm = 0;
GkchExe ();
}
}
enum {Start_Gkch, Stop_Gkch, Fr0, Fr1, Step, Set_fr, Out_ADC, V1,
V5, A0, A2, SetFzad, Izm_Fk, Get_Fzg, A3, A4,
SET_PAUZ, FKM, V4, END_FUN};
static void v5(void)
{
ADMUX &= ~(1<<REFS1);
send_OK(V5);
}
static void v1(void)
{
ADMUX |= (1<<REFS1);
send_OK(V1);
}
Сб апр 18, 2020 11:36:45
Сб апр 18, 2020 13:22:22
Сб апр 18, 2020 13:37:21
float readInVoltage()
{
vin = 0;
vout = 0;
for (int i = 0; i < 12; i++)
{
vin = vin + ((float)analogRead(INP_VAL) / 4095 * 4.096);
vout = vout + ((float)analogRead(INP_OUT) / 4095 * 4.096);
}
//Коэфф. передачи. Если нужно в dB пишем vin = 20*log10((vin / 12)/(vout / 12))
vin = (vin / 12)/(vout / 12);
return vin;
}
Сб апр 18, 2020 13:50:01
for (int i = 0; i < 12; i++)
{
vin = vin + ((float)analogRead(INP_VAL) / 4095 * 4.096);
vout = vout + ((float)analogRead(INP_OUT) / 4095 * 4.096);
}
Сб апр 18, 2020 14:05:11
Сб апр 18, 2020 14:14:08
Сб апр 18, 2020 14:22:34
Вот нюансы:
1. Время измерения на одной частоте и суммарное при проходе всех частот увеличится в 2 раза.
2. При переключении входов АЦП (между vin и vout)необходимо делать задержку перед следующим измерение, еще увеличит время развертки.
Как вариант делать измерение vin 1 раз через 10, 20 измерений vout.
Естественно необходимо записывать vout в память, для 1000 частот необходимо 2000 байт.
Сб апр 18, 2020 14:59:23
Как вариант делать измерение vin 1 раз через 10, 20 измерений vout.
Естественно необходимо записывать vout в память, для 1000 частот необходимо 2000 байт.
Поясните последние мысли... Зачем?
Сб апр 18, 2020 19:24:37
Например 10 раз сняли АЧХ фильтра и 1 раз выход генератора. И так в цикле.
При этом мы не делаем одновременно 2 измерения vin и vout. Соответственно время сканирования не увеличивается в 2 раза.
3. ВАХ диодов детекторов нелинейная и показание АЦП не соответствуют истинной амплитуде. Как эту нелинейность учитывать в расчетах?