ATNEL tech-forum

Re: Błędna konwersja ATOI

2020-01-07T08:21:28+01:00

Wspaniale działa ! Dziękuje bardzo za pomoc !

Statystyki: Napisane przez RychuER — 7 sty 2020, o 08:21

Re: Błędna konwersja ATOI

2020-01-07T01:42:00+01:00

No to popraw jeszcze funkcję USART_PutInt(), bo pewnie to ona temu winna.
Napisz sobie bliźniaczą funkcję np USART_PutLONG(), w której zamiast itoa będzie ltoa.

Statystyki: Napisane przez anshar — 7 sty 2020, o 01:42

Re: Błędna konwersja ATOI

2020-01-07T01:18:57+01:00

Niestety to nie pomaga już próbowałem tej opcji wciąż dostaje liczbę z minusem :/

Statystyki: Napisane przez RychuER — 7 sty 2020, o 01:18

Re: Błędna konwersja ATOI

2020-01-07T01:17:27+01:00

No to zamiast atoi daj atol

Statystyki: Napisane przez anshar — 7 sty 2020, o 01:17

Re: Błędna konwersja ATOI

2020-01-07T01:15:56+01:00

Bardzo przepraszam za zamieszanie to po prostu moje gapiostwo, zgodnie z dokumentacją funkcja atoi konwertuje ciąg strnigów do zmiennej typu int, a więc przekroczenie 32 767 powoduje że przekraczam jej zakres
Dlatego jednak moje pytanie brzmi nieco inaczej ponieważ już nie mogę sobie przypomnieć żadnego sposobu na zamianę liczby ze znakiem na jej odpowiednik bez...
Niestety rzutowanie na uint16_t nie pomaga :/

Oto kod po poprawkach:

[syntax=c]void Frame_Check(void)
{
safemode = 0;
USART_PutS("\r\n");
Slave_Adress[0] = Data_buffer[0];
Slave_Adress[1] = '\0';
Slave = atoi(Slave_Adress);
USART_PutInt(Slave, 10);

if(Slave == SLAVE_ADRESS)
{
USART_PutS("\r\n");
PWM_Data[0] = Data_buffer[1];
PWM_Data[1] = Data_buffer[2];
PWM_Data[2] = Data_buffer[3];
PWM_Data[3] = '\0';
PWM = atoi(PWM_Data);
USART_PutInt(PWM, 10);
USART_PutS("\r\n");

PULSE_ON[0] = Data_buffer[4];
PULSE_ON[1] = Data_buffer[5];
PULSE_ON[2] = Data_buffer[6];
PULSE_ON[3] = Data_buffer[7];
PULSE_ON[4] = Data_buffer[8];
PULSE_ON[5] = '\0';
Pulse_ON = atoi(PULSE_ON);
USART_PutInt(Pulse_ON, 10);
USART_PutS("\r\n");

PULSE_OFF[0] = Data_buffer[9];
PULSE_OFF[1] = Data_buffer[10];
PULSE_OFF[2] = Data_buffer[11];
PULSE_OFF[3] = Data_buffer[12];
PULSE_OFF[4] = Data_buffer[13];
PULSE_OFF[5] = '\0';
Pulse_OFF = atoi(PULSE_OFF);
USART_PutInt(Pulse_OFF, 10);
}
}[/syntax]

Gdybym teraz tylko zamienił typ z int na uint16_t sprawa byłaby załatwiona

Statystyki: Napisane przez RychuER — 7 sty 2020, o 01:15

Re: Błędna konwersja ATOI

2020-01-07T01:05:50+01:00

No i super!
Można na przykład tak:
[syntax=c]#include
#include

typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;

uint8_t pulse_off_1;
uint16_t pulse_off_2, pulse_off; //pulse_off_2 też musi być 16 bitowa :)

int main(void)
{
pulse_off_1 = 65;
pulse_off_2 = 535;
pulse_off = pulse_off_1 * 1000 + pulse_off_2;

printf("%d\n",pulse_off);

return 0;
}[/syntax]

Statystyki: Napisane przez anshar — 7 sty 2020, o 01:05

Re: Błędna konwersja ATOI

2020-01-07T00:36:02+01:00

Dziękuje bardzo za cenne rady, okazało się że pomogła zmiana typu z uint8_t na uint16_t tablic które posiadały co najmniej 4 elementy.

Oto efekt pracy w terminalu:

Jednak w tej sytuacji pojawia się inny problem w jaki sposób powinienem dokonać połączenia wartości 8 i 16 bitowej w taki sposób aby móc przekazać ja dalej do funkcji?

Oto kod:
[syntax=c]void Frame_Check(void)
{
safemode = 0;
USART_PutS("\r\n");

Slave_Adress[0] = Data_buffer[0];
Slave_Adress[1] = '\0';
Slave = atoi((const char *)Slave_Adress);
USART_PutInt(Slave, 10);

if(Slave == SLAVE_ADRESS)
{
USART_PutS("\r\n");
PWM_Data[0] = Data_buffer[1];
PWM_Data[1] = Data_buffer[2];
PWM_Data[2] = Data_buffer[3];
PWM_Data[3] = '\0';
PWM = atoi(PWM_Data);
USART_PutInt(PWM, 10);
USART_PutS("\r\n");

PULSE_ON_3[0] = Data_buffer[4];
PULSE_ON_3[1] = Data_buffer[5];
PULSE_ON_3[2] = Data_buffer[6];
PULSE_ON_3[3] = '\0';
PULSE_ON_2[0] = Data_buffer[7];
PULSE_ON_2[1] = Data_buffer[8];
PULSE_ON_2[2] = '\0';
Pulse_ON_1 = atoi(PULSE_ON_3);
Pulse_ON_2 = atoi(PULSE_ON_2);[/b]
Pulse_ON = ((Pulse_ON_2 << 8) | Pulse_ON_1); //KONWERSJA
USART_PutInt(Pulse_ON_1, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_ON_2, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_ON, 10);
USART_PutS("\r\n");

PULSE_OFF_3[0] = Data_buffer[9];
PULSE_OFF_3[1] = Data_buffer[10];
PULSE_OFF_3[2] = Data_buffer[11];
PULSE_OFF_3[3] = '\0';
PULSE_OFF_2[0] = Data_buffer[12];
PULSE_OFF_2[1] = Data_buffer[13];
PULSE_OFF_2[2] = '\0';
Pulse_OFF_1 = atoi(PULSE_OFF_3);
Pulse_OFF_2 = atoi(PULSE_OFF_2);
Pulse_OFF = ((Pulse_OFF_2 << 8)| Pulse_OFF_1); //KONWERSJA
USART_PutInt(Pulse_OFF_1, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_OFF_2, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_OFF, 10);
}
}[/syntax]

W kodzie zaznaczyłem moje próby konwersji, jednak jak widać nie udolne ponieważ dostaje tylko pierwszy fragment tablicy zamiast pełnej wartości np 65500. Czy jest na to jakiś sprytny sposób?

Statystyki: Napisane przez RychuER — 7 sty 2020, o 00:36

Re: Błędna konwersja ATOI

2020-01-07T00:08:59+01:00

Wejdź sobie na dowolną stronę z kompilatorem C np https://rextester.com/l/c_online_compiler_gcc
Wklej sobie ten kod poniżej, przeanalizuj, a później porównaj ze swoim.
Oczywiście to tylko fragment, odpowiednik Twojego kodu. Kolejne zmienne trzeba potraktować podobnie.

[syntax=c]#include
#include

typedef __uint16_t uint16_t;

char pwm_data[4];
uint16_t pwm;

int main(void)
{
pwm_data[0] = '5';
pwm_data[1] = '0';
pwm_data[2] = '0';
pwm_data[3] = '\0';

pwm = atoi(pwm_data);

printf("%d\n",pwm);

return 0;
}[/syntax]

Dodam jeszcze, że powołujesz:
volatile char Data_buffer[14]; //tablica 14 elementowa
a tutaj:
Data_Ready = USART_Read(Data_buffer, 16);
dajesz 16? Rozumiem, że to 16 znaków?

Przyjęło się, że zmienne pisze się małymi literami. Łatwiej się analizuje kod.

Te volatile i rzutowanie na const char* jest niepotrzebne.

Daj znać czy sobie poradziłeś.
Pozdrawiam

Statystyki: Napisane przez anshar — 7 sty 2020, o 00:08

Błędna konwersja ATOI

2020-01-06T22:02:31+01:00

Witam,

próbuje dokonać konwersji mojej ramki danych dla przykładu są to tego typu dane przesłane jako ASCII:
50012544200255.
Jednak przy próbie konwersji dane początkowe zostają skonwertowane poprawnie, niestety pozostała część już nie.

Oto kod:
[syntax=c]//Zmienne wykorzystywane przy obsłudze ramki danych
volatile uint8_t safemode;
volatile char Data_buffer[14];
volatile char Slave_Adress[2];
volatile char PWM_Data[4];
volatile char PULSE_ON_3[4];
volatile char PULSE_ON_2[3];
volatile char PULSE_OFF_3[4];
volatile char PULSE_OFF_2[3];
volatile uint8_t Slave;
volatile uint8_t PWM;
volatile uint8_t Pulse_ON_1;
volatile uint8_t Pulse_ON_2;
volatile uint8_t Pulse_OFF_1;
volatile uint8_t Pulse_OFF_2;
volatile uint16_t Pulse_ON;
volatile uint16_t Pulse_OFF;
////////////////////////////////////////////////////

void Frame_Check(void);

int main(void)
{
PORTA = 0xFF; //Podciągnięcie portu A do VCC
PWM_Init(); //Inicjalizacja PWM
Timer1_Init(); //Inicjalizacja Timer'a 1 w trybie CTC
i2c_init();
USART_Init(__UBRR); //Inicjalizacja układu USART

sei(); //Włączenie globalnych przerwań

uint8_t Data_Ready;

while (1)
{
Data_Ready = USART_Read(Data_buffer, 16);
if(Data_Ready != 0)
{
Frame_Check();
USART_PutS("\r\n");
USART_PutS("ACK");
}
if(Data_Ready == 0)
{
//safemode = 1;
}
}
}

void Frame_Check(void)
{
safemode = 0;
USART_PutS("\r\n");

Slave_Adress[0] = Data_buffer[0];
Slave_Adress[1] = 0;
Slave = atoi((const char *)Slave_Adress);
USART_PutInt(Slave, 10);

if(Slave == SLAVE_ADRESS)
{
USART_PutS("\r\n");
PWM_Data[0] = Data_buffer[1];
PWM_Data[1] = Data_buffer[2];
PWM_Data[2] = Data_buffer[3];
PWM_Data[3] = 0;
PWM = atoi((const char *)PWM_Data);
USART_PutInt(PWM, 10);
USART_PutS("\r\n");

PULSE_ON_3[0] = Data_buffer[4];
PULSE_ON_3[1] = Data_buffer[5];
PULSE_ON_3[2] = Data_buffer[6];
PULSE_ON_3[3] = 0;
PULSE_ON_2[0] = Data_buffer[7];
PULSE_ON_2[1] = Data_buffer[8];
PULSE_ON_2[2] = 0;
Pulse_ON_1 = atoi((const char *)PULSE_ON_3);
Pulse_ON_2 = atoi((const char *)PULSE_ON_2);
Pulse_ON = (uint16_t)((Pulse_ON_2 << 8) | Pulse_ON_1);
USART_PutInt(Pulse_ON_1, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_ON_2, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_ON, 10);
USART_PutS("\r\n");

PULSE_OFF_3[0] = Data_buffer[9];
PULSE_OFF_3[1] = Data_buffer[10];
PULSE_OFF_3[2] = Data_buffer[11];
PULSE_OFF_3[2] = 0;
PULSE_OFF_2[0] = Data_buffer[12];
PULSE_OFF_2[1] = Data_buffer[13];
PULSE_OFF_2[2] = 0;
Pulse_OFF_1 = atoi((const char *)PULSE_OFF_3);
Pulse_OFF_2 = atoi((const char *)PULSE_OFF_2);
Pulse_OFF = (uint16_t)((Pulse_OFF_2 << 8 )| Pulse_OFF_1);
USART_PutInt(Pulse_OFF_1, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_OFF_2, 10);
USART_PutS("\r\n");
USART_PutInt(Pulse_OFF, 10);
}
}[/syntax]

A oto efekt pracy w terminalu:

Jak widać wartość 5 oraz 1 zostają przekonwertowane poprawnie, następnie wartość 65555 również nie zostaje przekonwertowana, jednak gdy próbuje połączyć owe zmienne 8 bitowe w jedną 16-sto uzyskuje nie poprawny wynik. Co może być tego powodem?

Również udało mi się zauważyć, że końcowe dwa elementy 45 oraz 55 są poprawnie odczytane problem dotyczy tylko wartości ich poprzedzających.

Statystyki: Napisane przez RychuER — 6 sty 2020, o 22:02