• Witaj na Forum Arduino Polska! Zapraszamy do rejestracji!
  • Znajdziesz tutaj wiele informacji na temat hardware / software.
Witaj! Logowanie Rejestracja


Ocena wątku:
  • 0 głosów - średnia: 0
  • 1
  • 2
  • 3
  • 4
  • 5
Przerobienie programu
#1
Jak przerobić te dwa programy na jedno? może ktoś pomoże podpowie robiac samemu wyszło że zatrzymuje sie na nadawaniu a wyświetlacz cisza?  czyli sumować by nadając dane były też widzialne na wyświetlaczu dodatkowym ic2. 

Kod:
/*
  uncoment if you are using VW
*/

#define NAV

//data pin 4
//clk  pin 3
//ena  pin 2

//WRITE TO CLUSTER
#define FIS_WRITE_ENA 2
#define FIS_WRITE_ENAINT 0
#define FIS_WRITE_CLK 3
#define FIS_WRITE_DATA 4
#define FIS_WRITE_PULSEW 50
#define FIS_WRITE_STARTPULSEW 100
#define FIS_WRITE_START 0xF0 //something like address, first byte is always 15
//END WRITE TO CLUSTER

//#define BINCODE 000011111011111010101010101110111011011010111100101100111010101010111101101011001011001110110000101010011011111010110100101101101011111010010011
//                000011111011111010101010101110111011011010111100101100111010101010111101101011001011001110110000101010011011111010110100101101101011111010010011

//int BINCODE[144]={
//0,0,0,0,1,1,1,1,
//1,0,1,1,1,1,1,0,
//1,0,1,0,1,0,1,0,
//1,0,1,1,1,0,1,1,
//1,0,1,1,0,1,1,0,
//1,0,1,1,1,1,0,0,
//1,0,1,1,0,0,1,1,
//1,0,1,0,1,0,1,0,
//1,0,1,1,1,1,0,1,
//1,0,1,0,1,1,0,0,
//1,0,1,1,0,0,1,1,
//1,0,1,1,0,0,0,0,
//1,0,1,0,1,0,0,1,
//1,0,1,1,1,1,1,0,
//1,0,1,1,0,1,0,0,
//1,0,1,1,0,1,1,0,
//1,0,1,1,1,1,1,0,
//1,0,0,1,0,0,1,1};

//WRITE TO CLUSTER
String FIS_WRITE_line1 = "FIS PROTOCOL EMULATOR BY KOVO"; //upper line 8characters are static, more then 8 will rotate
String FIS_WRITE_line2 = "HTTP://KOVO-BLOG.BLOGSPOT.SK"; //lover line 8characters are static, more then 8 will rotate
String FIS_WRITE_sendline1 = "        ";
String FIS_WRITE_sendline2 = "        ";
long FIS_WRITE_rotary_position_line1 = -8;
long FIS_WRITE_rotary_position_line2 = -8;
char FIS_WRITE_CHAR_FROM_SERIAL;
int FIS_WRITE_line = 1;
long FIS_WRITE_last_refresh = 0;
int FIS_WRITE_nl = 0;
volatile uint8_t FIS_WRITE_ACKSTATE = 0;
//END WRITE TO CLUSTER

//WRITE TO CLUSTER
void FIS_WRITE_sendTEXT(String FIS_WRITE_line1, String FIS_WRITE_line2);
void FIS_WRITE_sendByte(int Bit);
void FIS_WRITE_startENA();
void FIS_WRITE_stopENA();
void FIS_WRITE_ACK();
//END WRITE TO CLUSTER

void setup() {
 //WRITE TO CLUSTER
 pinMode(FIS_WRITE_ENA, OUTPUT);
 digitalWrite(FIS_WRITE_ENA, LOW);
 pinMode(FIS_WRITE_ENA, INPUT);
 digitalWrite(FIS_WRITE_ENA, LOW); //disable pullup https://www.arduino.cc/en/Reference/DigitalWrite
 attachInterrupt(FIS_WRITE_ENAINT, FIS_WRITE_ACK, FALLING);
 pinMode(FIS_WRITE_CLK, OUTPUT);
 digitalWrite(FIS_WRITE_CLK, HIGH);
 pinMode(FIS_WRITE_DATA, OUTPUT);
 digitalWrite(FIS_WRITE_DATA, HIGH);
 Serial.begin(9600);
 //END WRITE TO CLUSTER
}

void loop() {
 //WRITE TO CLUSTER
 if (Serial.available()) {
   FIS_WRITE_CHAR_FROM_SERIAL = (char)Serial.read();
   Serial.print(FIS_WRITE_CHAR_FROM_SERIAL);
   if (FIS_WRITE_CHAR_FROM_SERIAL == '\n') {
     FIS_WRITE_nl = 1;
     if (FIS_WRITE_line == 1) {
       FIS_WRITE_line = 2;
     } else {
       FIS_WRITE_line = 1;
     }
   } else {
     if (FIS_WRITE_line == 1) {
       if (FIS_WRITE_nl) {
         FIS_WRITE_nl = 0;
         FIS_WRITE_line1 = "";
         FIS_WRITE_rotary_position_line1 = -8;
       }
       FIS_WRITE_line1 += FIS_WRITE_CHAR_FROM_SERIAL;
     } else {
       if (FIS_WRITE_nl) {
         FIS_WRITE_nl = 0;
         FIS_WRITE_line2 = "";
         FIS_WRITE_rotary_position_line2 = -8;
       }
       FIS_WRITE_line2 += FIS_WRITE_CHAR_FROM_SERIAL;
     }
   }

 }

 int FIS_WRITE_line1_length = FIS_WRITE_line1.length();
 int FIS_WRITE_line2_length = FIS_WRITE_line2.length();




 //do rotary and refresh each 0.5second
 //refresh cluster each 5s
 if ((millis() - FIS_WRITE_last_refresh) > 500 && (FIS_WRITE_line1_length > 0 || FIS_WRITE_line2_length > 0)) {
   if (FIS_WRITE_line1_length > 8) {
     FIS_WRITE_sendline1 = "        ";
     for (int i = 0; i < 8; i++) {
       if (FIS_WRITE_rotary_position_line1 + i >= 0 && (FIS_WRITE_rotary_position_line1 + i) < FIS_WRITE_line1_length) {
         FIS_WRITE_sendline1[i] = FIS_WRITE_line1[FIS_WRITE_rotary_position_line1 + i];
       }
     }
     if (FIS_WRITE_rotary_position_line1 < FIS_WRITE_line1_length) {
       FIS_WRITE_rotary_position_line1++;
     } else {
       FIS_WRITE_rotary_position_line1 = -8;
       FIS_WRITE_sendline1 = "        ";
     }
   } else {
     FIS_WRITE_sendline1 = FIS_WRITE_line1;
   }
   if (FIS_WRITE_line2_length > 8) {
     FIS_WRITE_sendline2 = "        ";
     for (int i = 0; i < 8; i++) {
       if (FIS_WRITE_rotary_position_line2 + i >= 0 && (FIS_WRITE_rotary_position_line2 + i) < FIS_WRITE_line2_length) {
         FIS_WRITE_sendline2[i] = FIS_WRITE_line2[FIS_WRITE_rotary_position_line2 + i];
       }
     }
     if (FIS_WRITE_rotary_position_line2 < FIS_WRITE_line2_length) {
       FIS_WRITE_rotary_position_line2++;
     } else {

       FIS_WRITE_rotary_position_line2 = -8;
     }
   } else {
     FIS_WRITE_sendline2 = FIS_WRITE_line2;
   }
   // Serial.println("refresh");
   //FIS_WRITE_sendTEXT(FIS_WRITE_sendline1,FIS_WRITE_sendline2);
   FIS_WRITE_last_refresh = millis();
   //end refresh
 }
 if (FIS_WRITE_ACKSTATE) {
   FIS_WRITE_ACKSTATE = 0;
   FIS_WRITE_sendTEXT(FIS_WRITE_sendline1, FIS_WRITE_sendline2);
 }
 //END WRITE TO CLUSTER
}

//WRITE TO CLUSTER

void FIS_WRITE_ACK() {
 detachInterrupt(FIS_WRITE_ENAINT);
 FIS_WRITE_ACKSTATE = 1;
};

void FIS_WRITE_sendTEXT(String FIS_WRITE_line1, String FIS_WRITE_line2) {

 Serial.println(FIS_WRITE_line1);
 Serial.println(FIS_WRITE_line2);
 int FIS_WRITE_line1_length = FIS_WRITE_line1.length();
 int FIS_WRITE_line2_length = FIS_WRITE_line2.length();
 if (FIS_WRITE_line1_length <= 8) {
   for (int i = 0; i < (8 - FIS_WRITE_line1_length); i++) {
     FIS_WRITE_line1 += " ";
   }
 }
 if (FIS_WRITE_line2_length <= 8) {
   for (int i = 0; i < (8 - FIS_WRITE_line2_length); i++) {
     FIS_WRITE_line2 += " ";
   }
 }
#ifdef NAVI
 uint8_t FIS_WRITE_CRC = 0x81;
#else
 uint8_t FIS_WRITE_CRC = (0xFF ^ FIS_WRITE_START);
#endif

 FIS_WRITE_startENA();
#ifdef NAVI
 FIS_WRITE_sendByte(0x81);
 FIS_WRITE_sendByte(0x12);
 FIS_WRITE_CRC ^= 0x12;
 FIS_WRITE_sendByte(0xF0);
 FIS_WRITE_CRC ^= 0xF0;
#else
 FIS_WRITE_sendByte(0xFF ^ FIS_WRITE_START);
#endif

 for (int i = 0; i <= 7; i++)
 {
   if (FIS_WRITE_line1[i] > 96) FIS_WRITE_line1[i] = FIS_WRITE_line1[i] - 32;
#ifdef NAVI
   FIS_WRITE_sendByte(FIS_WRITE_line1[i]);
   FIS_WRITE_CRC ^= FIS_WRITE_line1[i];
#else
   FIS_WRITE_sendByte(0xFF ^ FIS_WRITE_line1[i]);
   FIS_WRITE_CRC += FIS_WRITE_line1[i];
#endif

 }
 for (int i = 0; i <= 7; i++)
 {
   if (FIS_WRITE_line2[i] > 96) FIS_WRITE_line2[i] = FIS_WRITE_line2[i] - 32;
#ifdef NAVI
   FIS_WRITE_sendByte(FIS_WRITE_line2[i]);
   FIS_WRITE_CRC ^= FIS_WRITE_line2[i];
#else
   FIS_WRITE_sendByte(0xFF ^ FIS_WRITE_line2[i]);
   FIS_WRITE_CRC += FIS_WRITE_line2[i];
#endif

 }
#ifdef NAVI
 FIS_WRITE_sendByte(FIS_WRITE_CRC-1  );
#else
 FIS_WRITE_sendByte(FIS_WRITE_CRC % 0x100);
#endif
 FIS_WRITE_stopENA();

}

void FIS_WRITE_sendByte(int Byte) {
 static int iResult[8];
 for (int i = 0; i <= 7; i++)
 {
   iResult[i] = Byte % 2;
   Byte = Byte / 2;
 }
 for (int i = 7; i >= 0; i--) {
   switch (iResult[i]) {
     case 1: digitalWrite(FIS_WRITE_DATA, HIGH);
       break;
     case 0: digitalWrite(FIS_WRITE_DATA, LOW);
       break;
   }
   digitalWrite(FIS_WRITE_CLK, LOW);
   delayMicroseconds(FIS_WRITE_PULSEW);
   digitalWrite(FIS_WRITE_CLK, HIGH);
   delayMicroseconds(FIS_WRITE_PULSEW);
 }
}

void FIS_WRITE_startENA() {
 pinMode(FIS_WRITE_ENA, INPUT);
 digitalWrite(FIS_WRITE_ENA, LOW); //disable pullup
 while (!digitalRead(FIS_WRITE_ENA)) {
   pinMode(FIS_WRITE_ENA, OUTPUT);
   digitalWrite(FIS_WRITE_ENA, HIGH);
   delayMicroseconds(FIS_WRITE_STARTPULSEW);
   digitalWrite(FIS_WRITE_ENA, LOW);
   delayMicroseconds(FIS_WRITE_STARTPULSEW);
   digitalWrite(FIS_WRITE_ENA, HIGH);
 }
}

void FIS_WRITE_stopENA() {
 digitalWrite(FIS_WRITE_ENA, LOW);
 pinMode(FIS_WRITE_ENA, INPUT);
 digitalWrite(FIS_WRITE_ENA, LOW); //disable pullup
 attachInterrupt(FIS_WRITE_ENAINT, FIS_WRITE_ACK, FALLING);
}
//END WRITE TO CLUSTER



Kod:
// do not forget to put pull down resistor on enable line
// pull up on data/clk line is made usng internal pullup


#define FIS_READ_intCLK 1 //interupt on FIS_READ_CLK line
#define FIS_READ_CLK 3 //clk pin 3 - int1
#define FIS_READ_DATA 11 //data pin 11
#define FIS_READ_ENA 2 //enable pin 2 int0
#define FIS_READ_intENA 0 //interupt on FIS_READ_ENA line

#include <LiquidCrystal.h>

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

volatile uint8_t FIS_READ_adr=0;
volatile uint64_t FIS_READ_msg1=0;
volatile uint64_t FIS_READ_msg2=0;
volatile uint8_t FIS_READ_cksum=0;
volatile uint8_t FIS_READ_msgbit=0;
volatile uint8_t FIS_READ_newmsg1=0;
volatile uint8_t FIS_READ_newmsg2=0;
volatile uint8_t FIS_READ_adrok=0;
volatile uint8_t FIS_READ_cksumok=0;
volatile uint8_t FIS_READ_tmp_cksum=0;
volatile uint8_t FIS_READ_lcd_ack=1; //tell everyone on bus, we are here!

volatile uint64_t prev_update = 0;

void FIS_READ_read_data_line(){ //fired on falling edge
   if(!FIS_READ_adrok){
     FIS_READ_read_adr();
   }
   else if (!FIS_READ_newmsg1){
     FIS_READ_read_msg1();
   }
   else if (!FIS_READ_newmsg2){
     FIS_READ_read_msg2();
   }
   else if (!FIS_READ_cksumok){
     FIS_READ_read_cksum();
   }
}

void FIS_READ_read_cksum(){
 if(digitalRead(FIS_READ_DATA)){
   FIS_READ_cksum = (FIS_READ_cksum<<1) | 0x00000001;
   FIS_READ_msgbit++;
 }
 else
 {
   FIS_READ_cksum = (FIS_READ_cksum<<1);
   FIS_READ_msgbit++;
 }
 if (FIS_READ_msgbit==8)
 {
   FIS_READ_newmsg1=0;
   FIS_READ_newmsg2=0;
   FIS_READ_adrok=0;
   FIS_READ_tmp_cksum=(0xFF^FIS_READ_adr);
   for (int i=56;i>=0;i=i-8){
     FIS_READ_tmp_cksum=FIS_READ_tmp_cksum+(0xFF^((FIS_READ_msg1>>i) & 0xFF))
       +(0xFF^((FIS_READ_msg2>>i) & 0xFF));
   }
   if (!FIS_READ_cksumok){//d we display what we reveived last time?
   if((FIS_READ_tmp_cksum%256)==FIS_READ_cksum){
   FIS_READ_cksumok=1;
   } else {
     FIS_READ_msg1 = 0x00000000;
     FIS_READ_msg2 = 0x00000000;
     FIS_READ_cksumok=0;
   }
   FIS_READ_msgbit=0;
   }
 }

}

void FIS_READ_read_msg1(){
 if(digitalRead(FIS_READ_DATA)){
   FIS_READ_msg1 = (FIS_READ_msg1<<1) | 0x00000001;
   FIS_READ_msgbit++;
 }
 else
 {
   FIS_READ_msg1 = (FIS_READ_msg1<<1);
   FIS_READ_msgbit++;
 }
 if (FIS_READ_msgbit==64)
 {
   FIS_READ_newmsg1=1;
   FIS_READ_msgbit=0;
 }
}

void FIS_READ_read_msg2(){
 if(digitalRead(FIS_READ_DATA)){
   FIS_READ_msg2 = (FIS_READ_msg2<<1) | 0x00000001;
   FIS_READ_msgbit++;
 }
 else
 {
   FIS_READ_msg2 = (FIS_READ_msg2<<1);
   FIS_READ_msgbit++;
 }
 if (FIS_READ_msgbit==64)
 {
   FIS_READ_newmsg2=1;
   FIS_READ_msgbit=0;
 }
}

void FIS_READ_read_adr(){
 if(digitalRead(FIS_READ_DATA)){
   FIS_READ_adr = (FIS_READ_adr<<1) | 0x00000001;
   FIS_READ_msgbit++;
 }
 else
 {
   FIS_READ_adr = (FIS_READ_adr<<1);
   FIS_READ_msgbit++;
 }
 if (FIS_READ_msgbit==8)
 {
   FIS_READ_adrok=1;
   FIS_READ_msgbit=0;
 }
}



void FIS_READ_detect_ena_line_rising(){
   //init all again
   FIS_READ_msgbit=0;
   FIS_READ_newmsg1=0;
   FIS_READ_newmsg2=0;
   FIS_READ_adrok=0;
   FIS_READ_cksumok=0;
   FIS_READ_tmp_cksum=0;
   attachInterrupt(FIS_READ_intCLK,FIS_READ_read_data_line,FALLING);//data are valid on falling edge of CLK
   attachInterrupt(FIS_READ_intENA,FIS_READ_detect_ena_line_falling,FALLING); //if enable changed to low, data on data line are no more valid
}

void FIS_READ_detect_ena_line_falling(){
 detachInterrupt(FIS_READ_intCLK);//enable is low, data on data line are no more valid
 detachInterrupt(FIS_READ_intENA);
 attachInterrupt(FIS_READ_intENA,FIS_READ_detect_ena_line_rising,RISING);
}

void setup() {
 lcd.begin(16,2);
 lcd.home();
 lcd.print("FIS cluster");
 lcd.setCursor(0,1);
 lcd.print("reader");
 delay (2000);
 lcd.clear();
 Serial.begin(9600);
 pinMode(FIS_READ_CLK,INPUT_PULLUP);
 pinMode(FIS_READ_DATA,INPUT_PULLUP);
 pinMode(FIS_READ_ENA,INPUT);//no pull up! this is inactive state low, active is high
 digitalWrite(FIS_READ_ENA,LOW);//disable pullup
 attachInterrupt(FIS_READ_intENA,FIS_READ_detect_ena_line_rising,RISING);
}

void loop() {
 if(FIS_READ_cksumok){ //whole packet received and checksum is ok    
   lcd.home();
   Serial.write("\n");
  // lcd.clear();
   for(int i=56;i>=0;i=i-8){
     int c = (0xFF^((FIS_READ_msg1>>i) & 0xFF));
     if (c == 102 ) c=95;
     lcd.write(c);
     Serial.write(c);
   }
   lcd.setCursor(0,1);
   Serial.write("\n");
   for(int i=56;i>=0;i=i-8){
     int c = (0xFF^((FIS_READ_msg2>>i) & 0xFF));
     if (c == 102 ) c=95;
     lcd.write(c);
     Serial.write(c);  
   }
   FIS_READ_cksumok=0;
   prev_update=millis();
   FIS_READ_lcd_ack=1;
 } else {
   if ((millis() - prev_update) > 500 ){ //leave text for 1000ms
     lcd.clear();
     FIS_READ_lcd_ack=1;
     prev_update=millis();
   }
 }
 if (FIS_READ_lcd_ack){
   detachInterrupt(FIS_READ_intENA);
   detachInterrupt(FIS_READ_intCLK);
   pinMode(FIS_READ_ENA,INPUT);
   digitalWrite(FIS_READ_ENA,LOW);//disable pullup
   if (!digitalRead(FIS_READ_ENA)){
       pinMode(FIS_READ_ENA,OUTPUT);
       delay(1);
       digitalWrite(FIS_READ_ENA,HIGH);
       delay(3);
       digitalWrite(FIS_READ_ENA,LOW);
       FIS_READ_lcd_ack=0;
   }
 pinMode(FIS_READ_ENA,INPUT);
 digitalWrite(FIS_READ_ENA,LOW);//disable pullup
 //delay(50);
 attachInterrupt(FIS_READ_intENA,FIS_READ_detect_ena_line_rising,RISING);
 }
}
Arduino zostało wymyślone po to, by robić dobrze jedną prostą rzecz – migać diodą. 
 
Odpowiedź
#2
Opisz działanie tych programów. Co robią konkretne funkcje, do czego służą pętle. Jakie peryferia wykorzystują.
Ja rozumiem, że wszyscy znamy zagraniczny język, ale z czystej przyzwoitości możesz się trochę wysilić.
Na czym miało by polegać to "przerobienie w jedno"?
Jeśli masz problem z kodem lub sprzętem, zadaj pytanie na forum. Nie odpowiadam na PW, jeśli nie dotyczą one spraw forum lub innych tematów prywatnych.

[Obrazek: SsIndaG.jpg]
 
Odpowiedź
#3
    Jest wyświetlacz w aucie  i jest połączony z radiem który na wyświetlaczu dodatkowym wyświetla to co w radiu  można sterować  znakami tutaj akurat 2x8znaków jedna linia data,clk.ena. Pierwszy kod symuluje sygnał cyfrowy dla wyświetlacza   gdzie można dodać swoje napisy itd.  Drugi kod czyta ten sygnał cyfrowy z radia i wyświetla na wyświetlaczu w arduino.  A ja chciał bym połączyć te dwa programy  żeby czytało i emulowało.
Arduino zostało wymyślone po to, by robić dobrze jedną prostą rzecz – migać diodą. 
 
Odpowiedź
#4
(02-06-2018, 07:23)Jarewa0606 napisał(a): A ja chciał bym połączyć te dwa programy  żeby czytało i emulowało.

Gdzie sens? Gdzie logika?

Napisz co chcesz osiągnąć, bo widzę, ze próbujesz jakieś karkołomne rozwiązania. Nie analizowałem programu ale może okazać się, że sie nie da. Jak będę miał wolną chwilę to zerknę czy się nie mylę.
 
Odpowiedź
#5
(01-06-2018, 11:20)Jarewa0606 napisał(a): Jak przerobić te dwa programy na jedno? może ktoś pomoże podpowie robiac samemu wyszło że zatrzymuje sie na nadawaniu a wyświetlacz cisza?  czyli sumować by nadając dane były też widzialne na wyświetlaczu dodatkowym ic2. 
Tak przeglądając widzę użycie funkcji blokujących. Jak nadajesz to nie możesz w tym czasie odbierać dlatego program się blokuje.
 
Odpowiedź
#6
Photo 
Dziękuje za zainteresowanie..

Może jeszcze jedno zapytam bo w tym  programie jest  2x8 znaków czy łatwiej to przerobić czy pisać nowy na 1x7? gdzie dwa pierwsze znaczą coś innego 4 następne ciąg górnej lini  na wyświetlaczu graficznym a ostatni inny znak.

Kod:
{0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x60}, /* 100.1 FM Stereo 1-6 */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x70}, /* 100.1 FM Stereo 1-7 */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x80}, /* 100.1 FM Stereo 1-8 */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xA0}, /* 100.1 FM Stereo 1-M */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xB0}, /* 100.1 FM Stereo 1-U */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xD0}, /* 100.1 FM Stereo 1-F */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xE0}, /* 100.1 FM Stereo 1-/^ (M) */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x01}, /* 100.1 FM Stereo */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x02}, /* 100.1 FM Stereo */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x04}, /* 100.1 FM Stereo */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x08}, /* 100.1 FM Stereo */
   {0x1a, 0x02, 0x3A, 0x3B, 0x3C, 0x3D, 0x00}, /* DRS.T FM Stereo */
   {0x1a, 0x02, 0x3E, 0x3F, 0x30, 0x30, 0x00}, /* ) 0.0 FM Stereo */
   {0x1A, 0x00, 0x3D, 0x31, 0x36, 0x34, 0x00}, /* T16.4 FM */
   {0x1A, 0x02, 0x3D, 0x31, 0x34, 0x35, 0x00}, /* T14.5 FM Stereo */
   {0x1A, 0x00, 0x3D, 0x32, 0x33, 0x31, 0xA0}, /* T23.1 FM 1-M */
   {0x1E, 0x00, 0x3D, 0x30, 0x30, 0x30, 0xB0}, /* T00.0 FM 2-U */
   {0x1A, 0x00, 0x30, 0x32, 0x33, 0x31, 0x00}, /* 23.1  FM */
   {0x1A, 0x00, 0x32, 0x34, 0x31, 0x34, 0xD0}, /* 241.4 FM 1-F */
   {0x8e, 0x00, 0x3A, 0x30, 0x31, 0x3D, 0x00}, /* D01T  AM */
   {0x8e, 0x00, 0x3D, 0x3F, 0x3F, 0x3F, 0x00}, /* T     AM */
   {0x8e, 0x00, 0x3F, 0x3D, 0x3F, 0x3F, 0x00}, /*  T    AM */
   {0x8e, 0x00, 0x3F, 0x3F, 0x3D, 0x3F, 0x00}, /*   T   AM */
   {0x8e, 0x00, 0x3F, 0x3F, 0x3F, 0x3D, 0x00}, /*    T  AM */
   {0x8e, 0x00, 0x31, 0x3F, 0x3F, 0x3F, 0x00}, /* 1     AM */
   {0x8e, 0x00, 0x3F, 0x31, 0x3F, 0x3F, 0x00}, /*  1    AM */
   {0x8e, 0x00, 0x3F, 0x3F, 0x31, 0x3F, 0x00}, /*   1   AM */
   {0x8e, 0x00, 0x3F, 0x3F, 0x3F, 0x31, 0x00}, /*    1  AM */
   {0x1E, 0x00, 0x3F, 0x31, 0x33, 0x37, 0xB0}, /*  13.7 FM 2-U */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0x90}, /* 100.1 FM Stereo 1-9 */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xC0}, /* 100.1 FM Stereo 1-V */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xF0}, /* 100.1 FM Stereo 1-  */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xCF}, /* 100.1 FM Stereo 1-V */
   {0x1a, 0x02, 0x31, 0x30, 0x30, 0x31, 0xFF}, /* 100.1 FM Stereo 1-  */
   {0x11, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 U   */
   {0x13, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 FM  */
   {0x15, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 U   */
   {0x17, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 FM  */
   {0x1A, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 FM  */
   {0x1C, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 U   */
   {0x1F, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 FM  */
   {0x21, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 1001  U   */
   {0x22, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 1001  AM  */
   {0x23, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 1001  AM  */
   {0x24, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 1001  M   */
   {0x25, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 1001  M   */
   {0x26, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 1001  AM  */
   {0x2F, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 1001  AM  */
   {0x11, 0x00, 0x30, 0x31, 0x32, 0x32, 0xC0}, /* 12.2 U V */
   {0x00, 0x00, 0x30, 0x31, 0x32, 0x32, 0xC0}, /* 122 M */
   {0x00, 0x00, 0x30, 0x39, 0x39, 0x39, 0x00}, /* 999 M   */
   {0x11, 0x00, 0x31, 0x30, 0x30, 0x31, 0x00}, /* 100.1 U   */
   {0x04, 0x00, 0x31, 0x30, 0x31, 0x33, 0x00}, /* 1013   M */
   {0x04, 0x00, 0x32, 0x36, 0x30, 0x36, 0x00}, /* 2606   M */
   {0x14, 0x00, 0x30, 0x32, 0x33, 0x31, 0x00}, /* 23.1 U   */
   {0x14, 0x00, 0x30, 0x32, 0x33, 0x31, 0xD0}, /* 23.1 UF  */
   {0x1A, 0x00, 0x32, 0x34, 0x31, 0x3D, 0xD0}, /* 241.T FM 1-F */
   {0x11, 0x00, 0x32, 0x34, 0x31, 0x3D, 0xD0}, /* 241.T UF */
   {0x11, 0x00, 0x32, 0x34, 0x31, 0x30, 0xD0}, /* 241.0 UF */
   {0x14, 0x00, 0x30, 0x32, 0x33, 0x31, 0xA0}, /* 23.1 M  ? */
   {0x14, 0x00, 0x30, 0x32, 0x33, 0x31, 0xE0}, /* 23.1   ? */

   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x00}, /* 1 M */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x01}, /* 1 M1 */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x09}, /* 1 M9 */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x0A}, /* 1 MM */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x0B}, /* 1 MU */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x0C}, /* 1 MV */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x0D}, /* 1 MF */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x0E}, /* 1 M (half M) */
   {0x04, 0x00, 0x30, 0x30, 0x30, 0x31, 0x0F}, /* 1 M_ (space) */


Załączone pliki Miniatury
       
Arduino zostało wymyślone po to, by robić dobrze jedną prostą rzecz – migać diodą. 
 
Odpowiedź
#7
(02-06-2018, 21:04)Jarewa0606 napisał(a): Dziękuje za zainteresowanie..

Może jeszcze jedno zapytam bo w tym  programie jest  2x8 znaków czy łatwiej to przerobić czy pisać nowy na 1x7? gdzie dwa pierwsze znaczą coś innego 4 następne ciąg górnej lini  na wyświetlaczu graficznym a ostatni inny znak.
Możesz przetłumaczyć na polski?
 
Odpowiedź
  


Skocz do:


Przeglądający: 1 gości