Fork-Heńka... czyli jak sobie poradzić z DDS za pomocą ARDUINO

[DA_KAR]

(19-10-2014 13:18)SQ6IYY napisał(a):  Nek żyje Zlomek lub Zlomek żyje w celu ćwiczeń krok 10Hz i większe numerki(nosze okularki)

Też noszę okulary i powiększyłem numerki.
Tylko zabawa połowiczna bo nie mam enkodera i DDS-a
(nie zdążyły przyjść w piątek, może w poniedziałek).
Brak też stabilizatora 3,3V , połączyłem szeregowo
czerwoną diodę i dwie prostownicze, wyszło 3,2V. Działa!
Chętnie się jeszcze pobawię.

[SQ9MDD]

Przygotowaliśmy już projekt do pracy z jednopasmowym transceiverem, i teraz w planach było zajęcie się sposobem wyświetlania danych. Aby zadbać o efekt końcowy skorzystamy z bliźniaczej do dotychczas używanej biblioteki obsługi LCD.
Jest to biblioteka graficzna, będzie nam łatwiej narysować s-metr i inne elementy graficzne naszej syntezy. Sposób użycia nowej bibllioteki, zasadniczo nie wiele się różni od tej bazowej.
Po pierwsze musimy podłączyć właściwą bibliotekę.
Zamiast:

Kod:

#include <LCD5110_Basic.h>

Mamy:

Kod:

#include <LCD5110_Graph.h>

Następnie inicjalizacja:

Kod:

LCD5110 myGLCD(7,6,5,3,4);

Noi samo uzycie też musi być wywoływane inaczej:

Kod:

myGLCD.setFont(SmallFont);                     //ustawiamy czcionkę
  sprintf(buffor,"%08lu",step_value);         //konwersja danych do wyświetlenia (ładujemy krok syntezy do stringa i na ekran)
  myGLCD.print(buffor,CENTER,8);                 //wyświetlamy dane na lcd (8 oznacza drugi rząd)
  myGLCD.update();

Na uwagę zwraca myGLCD.update(); jest to znacząca zmiana w bibliotece podstawowej nie musieliśmy tego uzywać.

Poniżej w załączeniu wersja ze zmienioną biblioteką, od tej chwili będziemy mogli łatwo rysować na naszym wyświetlaczu.

W następnym odcinku przedstawię implementację prostego wskaźnika S-Metr autorstwa Rysia SP6IFN za którego namową zmieniliśmy bibliotekę obsługi LCD.

[SQ9MDD]

Dobra Panowie, no nie wytrzymam dłużej bo miałem chwilę dzisiaj rano i napisałem trochę kodu, tak to wygląda:





Po zmianie biblioteki do obsługi wyświetlacza LCD możemy rysować na nim linie okręgi kwadraty itd.
Prace zacząłem od zmiany sposobu wyświetlenia częstotliwości, następnie dodałem funkcję która rysuje stałe elementy wyświetlacza przy starcie procesora, a na koniec dodałem s-metr którego autorem jest Rysio SP6IFN.

Uwagę należy zwrócić na funkcję rysowania s-metra zbyt częste jej odpalenie, lub zbyt mocne rozbudowanie, może spowodować błędy w działaniu enkodera. Po prostu procesor będzie zajęty rysowaniem i nie zauważy ruchu enkodera, który nie jest obsługiwany w przerwaniach.

Ponizej kod po poprawkach, oczywiście każdy może dowolnie przerysować sobie wyświetlacz po swojemu. Wszystkie funkcje starałem się detalicznie opisać tak by nie było problemu z identyfikacją co jaka część kodu robi.

Kod:

//**************************************************​**********************//
// Złomek - kumpel Heńka, projekt pogladowy obsługi DDS AD9850,
// wyświetlacza nokii 5110 i jakiegoś enkodera.
// Projekt otwarty http://sp-hm.pl/thread-2164.html
// SQ9MDD - początkowy szkielet programu v 1.0.0 - 1.0.5
// SP6IFN - przejście na bibliotekę graficzną i parę zmian 1.0.5 s-metr
// S_____ -
//
//**************************************************​**********************//
/* CHANGELOG (nowe na górze)
2014.10.20 - v.1.0.6 przepisany sposób wyświetlania danych (pozostał jeden znany bug do poprawki)
wyczyszczone komentarze, dodanie s-metra według pomysłu Rysia SP6IFN
2014.10.20 - v.1.0.5 wymiana biblioteki wyświetlacza LCD
2014.10.19 - v.1.0.4 wprowadzamy pośrednią kilka zmiennych do sekcji konfiguracji
drobne czyszczenie kodu, poprawki w komentarzach
2014.10.15 - v.1.0.3 limit czestotliwości górnej i dolnej
przeniesienie wysyłania częstotliwości do DDS do osobnej funkcji
2014.10.14 - v.1.0.2 zmiana kroku syntezy
2014.10.12 - początek projektu wspólnego na sp-hm.pl
wymiana biblioteki wyświetlacza lcd na LCDD5110 basic
2014.05.22 - pierwsza wersja kodu warsztaty arduino w komorowie.  
*/
//**************************************************​**********************//

//podłączamy bibliotekę syntezera
#include <AH_AD9850.h>

//podłączamy bibliotekę enkodera
#include <RotaryEncoder.h>;

//podłączamy bibliotekę do obsługi wyświetlacza
#include <LCD5110_Graph.h>

//inicjalizujemy komunikację z syntezerem
//syntezer   - arduino
//CLK        - PIN 8
//FQUP       - PIN 9
//BitData    - PIN 10
//RESET      - PIN 11
AH_AD9850 AD9850(8, 9, 10, 11);

// inicjalizujemy wyświetlacz
// lcd    - arduino
// sclk   - PIN 7
// sdin   - PIN 6
// dc     - PIN 5
// reset  - PIN 3
// sce    - PIN 4
LCD5110 myGLCD(7,6,5,3,4);
extern uint8_t TinyFont[];          //czcionka z biblioteki.....dodałem małe fonty (SP6IFN)
extern uint8_t SmallFont[];         //czcionka z biblioteki
extern uint8_t MediumNumbers[];     //czcionka z biblioteki

//inicjalizujemy enkoder
//AO - w lewo
//A1 - w prawo
//nalezy pamiętać o kondensatorach (100nF) pomiędzy liniami encodera a masą
RotaryEncoder encoder(A0,A1,5,6,1000);  

//**************************************************​**************************************************​*************************
//zmienne do modyfikacji każdy ustawia to co potrzebuje
const int kontrast = 70;                     //kontrast wyświetlacza
const int pulses_for_groove = 2;             //ilość impulsów na ząbek enkodera zmienić w zależności od posiadanego egzemplarza
const int step_input = A2;                   //wejście do podłączenia przełącznika zmiany kroku
const long low_frequency_limit = 3500000;    //dolny limit częstotliwości
const long high_frequency_limit = 3800000;   //górny limit częstotliwości
const long start_frequency = 3715000;        //częstotliwość startowa
const long posrednia = -8000000;             //częstotliwość pośredniej, każdy dobiera swoją w zależności od konstrukcji radia
long step_value = 100;                       //domyślny krok syntezy
int s_metr_port = A5;                        //wejście dla s-metra
const long s_metr_update_interval = 100;     //interwał odświeżania s-metra w msec
//**************************************************​**************************************************​*************************

//zmienne wewnętrzne,
//jeśli nie trzeba proszę nie modyfikować
char buffor[] = "              ";            //zmienna pomocnicza do wyrzucania danych na lcd
long frequency = start_frequency;            //zmienna dla częstotliwości, wstawiamy tam częstotliwość od której startujemy
int enc_sum = 0;                             //zmienna pomocnicza do liczenia impulsów z enkodera
long s_metr_update_time = 0;                 //zmienna pomocnicza do przechowywania czasu następnego uruchomienia s-metra

//funkcja do obsługi wyświetlania zmiany częstotliwości
void show_frequency(){
  long f_prefix = frequency/1000;            //pierwsza część częstotliwości dużymi literkami
  long f_sufix = frequency%1000;             //obliczamy resztę z częstotliwości
  sprintf(buffor,"%lu",f_prefix);            //konwersja danych do wyświetlenia (ładujemy częstotliwość do stringa i na ekran)
  myGLCD.setFont(MediumNumbers);             //ustawiamy czcionkę dla dużych cyfr  
  myGLCD.print(buffor,13,10);                //wyświetlamy duże cyfry na lcd
  sprintf(buffor,".%03lu",f_sufix);          //konwersja danych do wyświetlenia (ładujemy częstotliwość do stringa i na ekran)
  myGLCD.setFont(SmallFont);                 //ustawiamy małą czcionkę
  myGLCD.print(buffor,60,19);                //wyświetlamy małe cyfry na lcd
  myGLCD.update();                           //wysyłamy dane do bufora wyświetlacza
}

//funkcja do wyświetlania aktualnego kroku syntezera za pomocą podkreślenie odpowiedniej cyfry
void show_step(){
       myGLCD.clrLine(0,28,83,28);          //czyszczę cała linię gdzie wyświetlam podkreślenie
       myGLCD.clrLine(0,29,83,29);          //czyszczę druga linię tak samo podkreśliniki są grube na dwa piksele
  switch(step_value){                       //przełącznik reaguje na bieżącą wartość kroku syntezy
     case 100:
        myGLCD.drawLine(69, 28, 82, 28);    //pokreślam 100Hz
        myGLCD.drawLine(69, 29, 82, 29);    //pokreślam 100Hz
     break;
    case 1000:
        myGLCD.drawLine(51, 28, 59, 28);    //pokreślam 1kHz
        myGLCD.drawLine(51, 29, 59, 29);    //pokreślam 1kHz      
    break;
    case 10000:
        myGLCD.drawLine(39, 28, 47, 28);    //pokreślam 10kHz
        myGLCD.drawLine(39, 29, 47, 29);    //pokreślam 10kHz      
    break;
    case 100000:
        myGLCD.drawLine(27, 28, 35, 28);    //pokreślam 100kHz
        myGLCD.drawLine(27, 29, 35, 29);    //pokreślam 100kHz      
    break;    
  }
myGLCD.update();  //jak już ustaliliśmy co rysujemy to wysyłamy to do LCD
}

//funkcja ustawiająca częstotliwość DDS-a
void set_frequency(int plus_or_minus){
  if(plus_or_minus == 1){                                                        //jeśli na plus to dodajemy
    frequency = frequency + step_value;                                          //częstotliwość = częstotliwość + krok    
  }  
  else if(plus_or_minus == -1){                                                  //jeśli na minus to odejmujemy
    frequency = frequency - step_value;                                          //częstotliwość = częstotliwość - krok    
  }
  frequency = constrain(frequency,low_frequency_limit,high_frequ​ency_limit);     //limitowanie zmiennej
  long frequency_to_dds = abs(posrednia + frequency);                            //a tutaj obliczam częstotliwość wynikową
  AD9850.set_frequency(frequency_to_dds);                                        //ustawiam syntezę na odpowiedniej częstotliwości  
  //Serial.println(frequency_to_dds);                                            //wypluwanie na rs-232 częstotliwości generatora (debugowanie)
}

//wskaźnik s-metra by nie przeszkadzał w pracy enkodera zrobiony jest na pseudo współdzieleniu czasu.
//każdorazowe wykonanie tej funkcji przestawia czas następnego jej wykonania o czas podany w konfiguracji domyślnie 100msec
void show_smetr(){                                
  if(millis() >= s_metr_update_time){                              //sprawdzam czy już jest czas na wykonanie funkcji
     myGLCD.clrLine(1, 45, 83, 45);                                //czyścimy stare wskazanie s-metra linia pierwsza
     myGLCD.clrLine(1, 46, 83, 46);                                //czyścimy stare wskazanie s-metra linia druga
     int s_value = analogRead(A5);                                 //czytamy wartość z wejścia gdzie jest podpięty sygnał s-metra
     int s_position = map(s_value,0,1023,1,83);                    //przeskalowuję zakres z wejścia analogowego na szerokość wyświetlacza
     myGLCD.drawLine(1, 45, s_position, 45);                       //rysuję nową linię wskazania s metra
     myGLCD.drawLine(1, 46, s_position, 46);                       //rysuję nową linię wskazania s metra
     myGLCD.update();                                              //wysyłam dane do bufora wyświetlacza
     s_metr_update_time = millis() + s_metr_update_interval;       //ustawiam czas kolejnego wykonania tej funkcji
  }
}

//tutaj rysujemy domyślne elementy ekranu będziemy to robić raz,
//tak by nie przerysowywać całego ekranu podczas pracy syntezy
void show_template(){
  myGLCD.setFont(TinyFont);                           //najmniejsza czcionka
  myGLCD.print("S1.3.5.7.9.+20.40.60.", CENTER, 38);  //opis dla s-metra
  myGLCD.drawRect(0, 44, 83, 47);                     //rysujemy prostokąt dla s-metra podając koordynaty narożników
  myGLCD.update();                                    //i wypluwamy to na lcd
}

// setup funkcja odpalana przy starcie
void setup(){  
  pinMode(s_metr_port,INPUT);
  Serial.begin(9600);                     //uruchamiam port szeregowy w celach diagnostycznych      
  myGLCD.InitLCD(kontrast);               //odpalamy lcd ustawiamy kontrast
  pinMode(step_input,INPUT_PULLUP);       //inicjalizujemy wejście zmiany kroku i podciągamy je do plusa
  set_frequency(0);                       //odpalamy syntezer i ustawiamy częstotliwość startową
  delay(1000);                            //sekunda opóźnienia  
  show_frequency();                       //pokazujemy częstotliwość na lcd
  show_step();                            //pokazujemy krok syntezy
  show_template();                        //pokazujemy domyślne stałe elementy LCD
}

void loop(){  
  int enc = encoder.readEncoder();        //czytamy wartość z encodera
  if(enc != 0) {                          //jeśli wartość jest inna niż zero sumujemy
    enc_sum = enc_sum + enc;              //jeden ząbek encodera to +2 lub -2 tutaj to zliczam
    //Serial.println(enc);                //wyrzucamy na port rs-232 wartość licznika enkodera (debugowanie)
  }

  //obsługa klawisza zmiany kroku
  if(digitalRead(step_input) == LOW){     //sprawdzanie czy przycisk jest wcisnięty
    delay(100);                           //odczekajmy 100msec
    if(digitalRead(step_input) == LOW){   //jeśli klawisz nadal jest wcisnięty (czyli nie są to zakłócenia)
      switch(step_value){                 //za pomocą instrukcji swich zmieniamy krok
      case 100000:                        //jeśli krok jest 100kHz ustaw 100Hz
        step_value = 100;
        break;
      case 10000:                         //jeśli krok jest 10kHz ustaw 100kHz
        step_value = 100000;
        break;
      case 1000:                          //jeśli krok jest 1kHz ustaw 10kHz
        step_value = 10000;
        break;
      case 100:                           //jeśli krok jest 100Hz ustaw 1kHz
        step_value = 1000;
        break;
      }
    }
    show_step();                          //pokazuję zmianę kroku na lcd
    delay(300);                           //zwłoka po zmianie kroku 300msec
  }

  //jesli zaliczyliśmy ząbek dodajemy lub odejmujemy do częstotliwości wartość kroku (na razie na sztywno 100Hz)
  if(enc_sum >= pulses_for_groove){
    set_frequency(1);                     //wywołuję funkcje zmiany częstotliwości z parametrem +
    show_frequency();                     //drukuję częstotliwość na wyświetlaczu za pomocą gotowej funkcji
    enc_sum = 0;                          //reset zmiennej zliczającej impulsy enkodera
  }
  if(enc_sum <= -(pulses_for_groove)){
    set_frequency(-1);                    //wywołuję funkcje zmiany częstotliwości z parametrem -
    show_frequency();                     //drukuję częstotliwość na wyświetlaczu za pomocą gotowej funkcji      
    enc_sum = 0;                          //reset zmiennej zliczającej impulsy enkodera
  }  
  delayMicroseconds(5);                   //małe opóźnienie dla prawidłowego działania enkodera
  show_smetr();
}

//testowanie ilości dostępnego RAMU
/*
int freeRam () {
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
*/

Ciekaw jestem waszych postępów w pracach. Może macie jakieś poprawki zmiany itp.

[SP9MRN]

Złomek wygląda super. ;-)
Proponuję tylko odwrócić kolejność ustawiania kroku, bo naturalnym jest coraz dokładniejsze wstrajanie się w stację - czyli krok powinien się zmniejszać a nie zwiększać.

I jeszcze jedno - ponieważ smeter zabiera trochę czasu procesora, to dobrze jest go trochę zoptymalizować. Doczytałem kiedyś, że map() jest jedną z paskudniejszych funkcji arduino. Jeżeli nie najwolniejszą.
Dlaczego? - bo żeby zrobić mapowanie to mnoży i dzieli. a arduino tak naprawdę, to szybko potrafi dzielić wyłącznie przez 2
Zatem lepiej zrezygnować z paru pikseli, zostawić ich 80 i zastosować szybkie przesunięcie zamiast mapowania:
(>>7 to przesunięcie liczby binarnej o 7 pozycji czyli tak naprawdę podzielenie przez 128)

old:
int s_position = map(s_value,0,1023,1,83);

new:
int_position = (s_value*10)>>7

czyli w przetłumaczonej na ludzki język wersji (uawga tylko dla ludzi nie dla procesora):
int_position = (s_value*10)/128 - to tak żeby sobie sprawdzić :-)

zwykle jest tak, że przy atmegowej dokładności przetwornika analogowo cyfrowego możemy sobie pozwolić na zaokrąglenia
Teraz, jak jeszcze kodu jest mało to nie ma większej wagi, ale jak się funkcji namnoży, to skracanie rzeczy dziejących się "stale" może mieć znaczenie.

MAc
mrn

PS
mam nadzieję, że się gdzieś nie walnąłem :-)

[SQ9MDD]

Co racja to racja, mówisz i masz... poprawka w załączeniu

[SP6IFN]

No i właśnie na tym to polega, co dwie głowy to nie jedna. Właśnie czegoś nowego się dowiedziałem.
Rysio!
PS.cytat: mam nadzieję, że się gdzieś nie walnąłem :-)...koniec cyt.
A jednak.......ale po poprawce i tak nie działa, nie rysuje linii....no bo jak ma to zrobić.
Ryszard, chyba dałeś wersję 6 ponownie, bo nie widzę zmian.
PS2. No, teraz chodzi...i kod krótszy.

[SQ9MDD]

Niewątpliwie ">>" zajmuje mniej czasu procesora ale z drugiej strony póki co się mieścimy a dla celów szkoleniowych czystszy zapis jest lepszy. Więc na razie zostanie.
Jeśli chodzi o map, by inni mieli pojęcie jak działa to jest tak, taki zapis:

Kod:

int out = map(input,0,1023,0,50);

jest równoważny temu:

Kod:

int out = (50 * input) / 1023;

Czyli map realizuje dwie operacje, dodatkowym problemem funkcji map jest obcinanie reszty z tego dzielenia, zamiast zaokrąglania.

Więc wartość 5,9 zostanie pokazana jako 5.
Takich niuansów można znaleźć więcej zachęcam do czytania na ten temat.

Grunt to się dobrze bawić No to teraz czekamy na rozwój sytuacji u kolegów

P.S. Wadliwy plik podmieniony

[SP6IFN]

Tak mi przyszło jeszcze na myśl, że w obecnym zapisie bardzo łatwo można niejako "zmienić czułość miernika". Wystarczy zmienić odpowiednio jedną z liczb w obecnym zapisie.
Rysio!

[SQ9MDD]

Jasne że można, można też doprowadzić sygnał liniowy i przemapować go w krzywej kilku punktowej. Albo zaprojektować krzywą dowolnie dopasowaną do charakterystyki sygnału.

Taki example znalazłem dla czujnika temperatury NTC 10K :

Kod:

//tablica konwersji wejscie analogowe na temp,
//ktoś zaprojektował ładną krzywą dla NTC 10k
const int temps[] PROGMEM = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
86, 87, 88, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 102, 103, 104, 105, 106, 107, 108, 109, 110,
111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 124, 125, 126, 127, 128, 129, 130, 131, 132,
133, 134, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 143, 144, 145, 146, 147, 148, 149, 150, 151, 151, 152, 153,
154, 155, 156, 157, 158, 159, 159, 160, 161, 162, 163, 164, 165, 166, 167, 167, 168, 169, 170, 171, 172, 173, 174, 175,
175, 176, 177, 178, 179, 180, 181, 182, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 193, 194, 195, 196,
197, 197, 198, 199, 200, 201, 202, 203, 204, 205, 205, 206, 207, 208, 209, 210, 211, 212, 212, 213, 214, 215, 216, 217,
218, 219, 220, 220, 221, 222, 223, 224, 225, 226, 227, 228, 228, 229, 230, 231, 232, 233, 234, 235, 235, 236, 237, 238,
239, 240, 241, 242, 243, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255, 256, 257, 258, 259, 260,
260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 279, 280, 281,
282, 283, 284, 285, 286, 287, 288, 289, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 301, 302, 303,
304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326,
327, 328, 329, 330, 331, 332, 333, 334, 335, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349,
350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373,
374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 392, 393, 394, 395, 396, 397, 398,
399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 422, 423, 424,
425, 426, 427, 428, 429, 430, 432, 433, 434, 435, 436, 437, 438, 439, 441, 442, 443, 444, 445, 446, 448, 449, 450, 451,
452, 453, 455, 456, 457, 458, 459, 460, 462, 463, 464, 465, 466, 468, 469, 470, 471, 472, 474, 475, 476, 477, 479, 480,
481, 482, 484, 485, 486, 487, 489, 490, 491, 492, 494, 495, 496, 498, 499, 500, 501, 503, 504, 505, 507, 508, 509, 511,
512, 513, 515, 516, 517, 519, 520, 521, 523, 524, 525, 527, 528, 530, 531, 532, 534, 535, 537, 538, 539, 541, 542, 544,
545, 547, 548, 550, 551, 552, 554, 555, 557, 558, 560, 561, 563, 564, 566, 567, 569, 570, 572, 574, 575, 577, 578, 580,
581, 583, 585, 586, 588, 589, 591, 593, 594, 596, 598, 599, 601, 603, 604, 606, 608, 609, 611, 613, 614, 616, 618, 620,
621, 623, 625, 627, 628, 630, 632, 634, 636, 638, 639, 641, 643, 645, 647, 649, 651, 653, 654, 656, 658, 660, 662, 664,
666, 668, 670, 672, 674, 676, 678, 680, 683, 685, 687, 689, 691, 693, 695, 697, 700, 702, 704, 706, 708, 711, 713, 715,
718, 720, 722, 725, 727, 729, 732, 734, 737, 739, 741, 744, 746, 749, 752, 754, 757, 759, 762, 764, 767, 770, 773, 775,
778, 781, 784, 786, 789, 792, 795, 798, 801, 804, 807, 810, 813, 816, 819, 822, 825, 829, 832, 835, 838, 842, 845, 848,
852, 855, 859, 862, 866, 869, 873, 877, 881, 884, 888, 892, 896, 900, 904, 908, 912, 916, 920, 925, 929, 933, 938, 942,
947, 952, 956, 961, 966, 971, 976, 981, 986, 991, 997, 1002, 1007, 1013, 1019, 1024, 1030, 1036, 1042, 1049, 1055, 1061,
1068, 1075, 1082, 1088, 1096, 1103, 1110, 1118, 1126, 1134, 1142, 1150, 1159, 1168, 1177, 1186, 1196, 1206, 1216, 1226,
1237, 1248, 1260, 1272, 1284, 1297, 1310, 1324, 1338, 1353, 1369, 1385, 1402, 1420, 1439, 1459, 1480, 1502 };

A w pętli loop:

Kod:

int temp_raw = analogRead(pomiar_temp_input)-238;        //odczyt danych z czujnika  
  int temp = pgm_read_word(&temps[temp_raw]);              //kalibracja miernika temp (rezystancyjny 10K)
  int a = temp/10;
  int b = temp%10;
  Serial.print(a);
  Serial.print(".");
  Serial.print(b);

Posługując się czymś takim można zaprojektować i wpisać w program krzywą konwersji napięcia na skalę na przykład w db.

[SP9MRN]

przemapować do pokazywania to połowa zabawy :-) Można bowiem przemapować i z wyjścia pwm napędzić nim ARW o własnej fikuśnej charakterystyce :-)
(no, ale do tego to naprawdę trzeba szybko).

Rysiek, nie mam teraz ardu podpiętego - mógłbyś zobaczyć czy się coś w ramie w istotny sposób zmienia przy map i shifcie?

MAc
mrn