Svenska ElektronikForumet

Bra idé. Då ser man hur projektet växer.

Jag kommer inte på så mycket mer att skriva för stunden,
men jag läser tråden med stort intresse.

Har du tänkt hitta på ett eget XML-schema eller använda t ex PLCOpens som filformat?

Nej jag har ett eget upplägg. T.ex. ser schemat för ett bibliotek ut såhär för
tillfället. indcont_library.xsd

PLCOpen kände jag inte till. Det verkar ju inte helt dumt att ha ett
standardiserat filformat. Ev. byter jag till det en vacker dag.

Hur kommer det sig att du känner till PLCOpen?

Lines of code: 3596 (+331)
Maintainability index: 78 (vet inte hur den beräknas men 100 är bra och 0 är dåligt)

Jag har använt IEC 61131-3-språken

Nåja, verkligheten håller jag på att börja med ett skolprojekt för att utvärdera SoftPCS (www.infoteam.de) och speciellt hur det klarar av att importera XML-filer skapade med externa verktyg.

Meningen är att det skall gå att generera överförbar kod med specialutvecklade verktyg och att programmen sedan skall kunna verifieras och köras i SoftPCS SoftPLC, med alla de möjligheter där finns.

Så jag har alltså följt denna tråd med intresse...

Nu har mitt program spottat ut sina första rader kod

Det är inte mycket
men det är en början! "Kod" för globala variabler blir ungefär såhär.

Tanken är att programmet ska generera kod som sedan Microchips c-
kompilator ska kunna kompilera till kod som går att skicka rakt ner i en PIC.

globals.c

Kod: Markera allt

//-------------------------------------------------------------------------
// Includes
//-------------------------------------------------------------------------
#include "project.h"


//-------------------------------------------------------------------------
// Global variables
//-------------------------------------------------------------------------
bool bSomeShit;
bool bAnother;


//-------------------------------------------------------------------------
// GlobalsInit()
//-------------------------------------------------------------------------
void GlobalsInit()
{
	bSomeShit = true;
	bAnother = false;
}//GlobalsInit()

globals.h

Kod: Markera allt

#ifndef GLOBALS_H
#define GLOBALS_H


//-------------------------------------------------------------------------
// Function declarations
//-------------------------------------------------------------------------
void GlobalsInit();


//-------------------------------------------------------------------------
// Expose globals
//-------------------------------------------------------------------------
extern bool bSomeShit;
extern bool bAnother;

#endif

Sen har jag jobbat vidare liite med fbd-editorn. Så här ser fönstret ut för att
ansluta en pinne på ett funktionsblock. Fönstret sorterar automatiskt bort
variabler/anslutningar med fel datatyp eller riktning.
Bild

Lines of code: 3913 3596 (+317)
Maintainability index: 77 (-1)

Sitter och funderar lite på hur översättningen av fbd till C-kod ska gå till.
Känner att jag behöver få ner tankarna på papper och tänkte då att jag lika
gärna kan skriva ett inlägg om det.

Den enda koden som egentligen finns blir för grund-funktionsblocken
(and,or,SR m.fl.), den koden skrivs i ASM. Koden som översättaren(fb->C)
genererar blir i princip bara datatypsdefinitioner och funktionsanrop till
grundfunktionsblocken.

Ett funktionsblock defineras med ett namn i bibliotek. Blocket kan
instansieras med ett unikt namn i andra fb och i vanliga program.

Ett fb översätts till en funktion i C. Ingångarna blir parametrar. Utgångarna
består av medlemmar i en datatyp som deklareras för varje typ av
funktionsblock. En variabel deklareras med denna datatyp för varje instans
av funktionsblocket. Till de anslutningar som utgången har skickas
värden(om systemdatatyp)/pekare(om sammansatt datatyp) från den
sammansatta variabeln.

Ett exempel
Följande fbd(functionblockdiagram)
Bild

Översätts till denna c-kod:

Kod: Markera allt

typedef struct {
	bool out1;
} AND_OUTPUT;

AND_OUTPUT AND1_OUTPUT;
AND_OUTPUT AND2_OUTPUT;

AND( a, b, &AND1_OUTPUT );
AND( AND1_OUTPUT.out1, c, &AND2_OUTPUT );
d = AND2_OUTPUT.out1;

Nu har jag tagit mig i kragen och skrivit lite kod för att visa
variabelanslutningar på funktionsblock, tidigare visades bara anslutningar
funktionsblock emellan. Så här ser det ut:

Bild

Lines of code: 4230 (+317, det var exakt 317 förra gången också

)
Maintainability index: 76 (-1, börja bli dags att kolla hur den beräknas nu)

Jag är imponerad.

Det verkar gå stadigt framåt, fast det inte är några lätta problem att få struktur på. Ser ut att bli ett trevligt system att jobba med när det blir klart.

Tack

Har du erfarenhet av PLC-programmering? Det vore nice att ha några som
kunde prova mitt program lite sen när det börjar bli färdigt...

Jag har faktiskt köpt 2st böcker för att lära mig lite mer om strukturering
m.m. mjukvaruprojekt.
Code complete 2nd editon
Refactoring. Improving the Design of Existing Code

Jag har börjat skriva lite kod för översättning av fbd till C-kod, men jag har
det inte helt klart för mig hur det ska fungera. Men ju mer kod jag skriver
desto mer brukar problemet/lösningen framgå.

Jag höll på mycket förrut då jag åkte runt och utbildade folk i PLC teknik bl.a. Då var man väl några år före, nu har jag inte följt med så mycket vad som hänt de senaste 10åren. C-programmering är inte riktigt min grej heller, jag är lite mera maskinnära.

Har du någon nytta av min hjälp ställer jag naturligtvis upp. Det är nyttigt att få tänka till ibland.

Ett mycket intressant projekt. Det skall bli roligt att se hur det utvecklas.

Har skrivit en, PLC Micro-1 från IDEC, simulator med hiss, pumpstation och tvättmaskin. Använde Delphi.
Det var bara att skriva t.ex.
lod 1
and 2
out 201
o.s.v. ....

Var du med och utvecklade Micro-1?

Hittade en bra artikeln om de "metrics" som Visual Studio beräknar. Det kan
vara så att min maintainability index sjunker p.g.a. av mängden kod ökar.
Inte mycket att göra åt m.a.o. Så här står det:

"Lines of code: At each level, this is a measure of the total number of
executable lines of code. This excludes white space, comments, braces and
the declarations of members, types and namespaces themselves. Lower is
typically better."

"Maintainability index: At the member and type level, this is an index from
0 to 100 indicating the overall maintainability of the member or type. At the
namespace and assembly level, this is an average of the maintainability
index of all types contained within it. This index is based on several other
metrics, including Halstead Volume (which factors in the number and use of
operands and operators), Cyclomatic Complexity and Lines of Code. A low
number indicates code that is complex and hard to maintain."

>Var du med och utvecklade Micro-1?

Jag? Nej tyverr inte.

Kul att se att A* används till något vettigt.
För er som inte vet vad A* är för något har jag en länk.
http://www.gamedev.net/reference/articl ... le2003.asp

Håller på med ett liknande projekt och det där med automatisk tråddragning var en bra idé.

Jag har programmerat mycket med PLC:n; men som tidigare sagt, jag höll mig till ladder. Annars hade jag gärna betatestat.

Svenska ElektronikForumet

Programmable logic controller (genomgång av sw på s. 6)