Vilket MODBUS bibliotek använder du?

[TomasL]

Nu ska den vara 100% portabel att den till och med passar ALLA system.

När jag skriver C kod så skriver jag alltid för C89. Inte för att C89 är en bättre standard. Utan för att många system som finns idag, kompileras med äldre kompilatorer som ej har C11 eller högre.
...och dessutom är jag bäst på skriva kod här på forumet...sådeså!

Den jag länkade till är 100% portabel.

[DanielM]

Vad betyder evolution version då? Betyder det att man får bara testa den, inte använda den offentligt i kommersiella mjukvaror?

[TomasL]

Du får kontrollera licensen helt enkelt.

[DanielM]

Kontrollera?

Vad tror vi om detta bibliotek?
https://github.com/debevv/nanoMODBUS

Jag ser inte vart man sätter konfigurationen för USB eller liknande.

Ah! Här ser jag

Kod: Markera allt

    // my_transport_read() and my_transport_write() are implemented by the user 
    nmbs_platform_conf platform_conf;
    nmbs_platform_conf_create(&platform_conf);
    platform_conf.transport = NMBS_TRANSPORT_TCP;
    platform_conf.read = my_transport_read;
    platform_conf.write = my_transport_write;
    platform_conf.arg = conn;    // Passing our TCP connection handle to the read/write functions

[TomasL]

Kontrollera?

Ja, du får helt enkelt läsa licensen och se vad som tillåts

[DanielM]

Ska ge nanoModbus ett försök först! Den verkar vara anpassad för uC och stödjer in princip all hårdvara.

[DanielM]

Var en hjälte och skriv ett eget open source bibliotek!
Alla specar ligger ute fritt på organisationens hemsida.

Jag funderar på att skriva eget bibliotek.
Jag har testat nanoMODBUS nu och tycker det verkar buggigt. Ibland svarar den, ibland inte.
Ibland skickar den inge bytes, ibland skickar den 5 bytes när den ska skicka 9 bytes, ibland skickar den 15 bytes när den ska skicka 9 bytes. Alltså två register.

Är det någon som kan ge lite tips på hur jag ska börja? Jag har skrivit sådana bibliotek förut, men jag tänkte att man börjar först med dataramen.
Första bytet är adressen
Andra bytet är funktionskoden
Vad är resterande?

Kanske man ska testa TomasL förslag på bibliotek.
Har du Tomas någon exempelkod? Har tankat ned biblioteket nu.

[TomasL]

Första bytet är adressen
Andra bytet är funktionskoden
Vad är resterande?

Du får läsa standarden, så förstår du hr det funkar.

[TomasL]

Har du Tomas någon exempelkod?

Exempelkod på vad?, biblioteket är ju fullt med exempel.

[DanielM]

Första bytet är adressen
Andra bytet är funktionskoden
Vad är resterande?

Du får läsa standarden, så förstår du hr det funkar.

Vi säger så här!

Här har jag en kod för att läsa från DMA. Detta är en callback som anropas med korrekt argument. När min DMA tar emot data så kommer end_index att förlytta sig till 0 till ny position. Vi säger t.ex. att den flyttar sig till 8 om jag skickar 8 bytes. Alltså betyder detta att current_index och end_index är inte lika.

Då börjar jag jämföra current_index + count med totala mängden data som kan lagras. Om den inte överstiger så läser jag datat via memory copy.
Men här är kruxet! Oavsett om DMA får data eller inte, så läses denna funktion med count = 1. Alltså den vill veta vad senaste byte är på positionen byte0.
Är detta enligt standarden eller nanoMODBUS som bara är så? Vi säger om första positionen är 0. Jaha? Detta betyder att adressen är 0. Men vad ska modbus göra då?

Notera! Variabeln end_index vandrar från 0 till 500 och sedan börjar den om igen från 0 då DMA är en cirkulär buffer.

Kod: Markera allt

#define UART_RX_DATA_SIZE 500
uint8_t UART_RX_DATA[UART_RX_DATA_SIZE];
uint16_t current_index = 0;

int32_t UART_read(const char port[], uint8_t* buf, uint16_t count, int32_t byte_timeout_ms) {
	/* Get the end index */
	uint16_t end_index = (UART_RX_DATA_SIZE - hdma_usart1_rx.Instance->CNDTR);

	/* If current index is the same as end index, then no data has been received */
	if(current_index == end_index){
		return 0;
	}

	/* If current index and the count data is less or equal as the total data size buffer */
	if(current_index + count <= UART_RX_DATA_SIZE){
		memcpy(buf, UART_RX_DATA + current_index, count);
		current_index += count;
		return count;
	}

	/* If current index and the count data is more than the total data size buffer */
	if(current_index + count > UART_RX_DATA_SIZE){
		uint16_t count_right = UART_RX_DATA_SIZE - current_index;
		memcpy(buf, UART_RX_DATA + current_index, count_right);
		uint16_t count_left = count - count_right;
		memcpy(buf, UART_RX_DATA, count_left);
		current_index = count_left;
		return count;
	}

	/* This should not occur */
	return 0;
}

[TomasL]

Förstår inte riktigt vad du håller på med, vad har detta med MODBUS att göra?

[DanielM]

Jag tänkte bara fråga om det är enligt standard att en modbusmjukvara läser ständigt 1 byte hela tiden bara för att kolla om det har kommit in något värde som är högre än adressen 0?

[pfyra]

Jag har inte kollat, men libbet är antagligen inte knutet till någon hårdvara och är antagligen uppbyggt genom att du ska mata 1 byte i taget till det.

Meddelandena är typ 10 bytes eller så i grundutförande så 500 bytes är att ta i. Enklast är det nog om du DMA:ar till starten av buffern hela tiden och gör en ny mottagning efter varje meddelande.

Modbus i sig är trivialt och du kan antagligen ersätta libbet med i princip en switch-sats och crc-koll så har du full koll på vad som händer.

[DanielM]

Jag ska forska lite mera i nanoMODBUS. Det är väldigt enkelt att använda faktiskt. Jag har gjort ett extra lager för nanoMODBUS om det är någon som vill ha min .c kod.

[TomasL]

Vore bra om du läste igenom och lärde dig standarden så du får någon liten kunskap om hur det skall fungera.
Normalt sett så läser man in hela telegrammet, och därefter kontrollerar om det är korrekt.

Finns ingen anledning att köra DMA på Modbus RTU, då meddelanden normalt sett är väldigt korta.
Jag har en Interruptrutin som hanterar både RX och TX