Svenska ElektronikForumet

Ok då var det dags att lägga upp mitt senaste projekt,
som består av två enheter, HACS (Home Automation Central System) och WTSUP (Wireless Touch Screen Unit Pad).

Support lista (routern):
* Ethernet - TCP klient (HACS kan koppla upp mot en extern server) / server (ifrån extern nätverksenhet så som PC)
* 433 MHz RF sändare för styrning av trådlösa strömbrytare av typ, fixed code och NEXA "självlärande" koder
* 433 MHz RF mottagare (ej implementerad i mjukvara ännu), skulle kunna användas för att "routa" om befintliga fjärrkontrollers funtioner, samt att trådlösa termometrar/väderstationer skulle kunna stödas.
* 2x nRF24L01 2 Mbit RF transceivers, billiga trådlösa enheter med färdigt kontrollsystem, och har automatisk återsändning samt adressering (ca 20:- för en enhet) dessa använder jag för att styra andra prylar som kräver stabilare/snabbare data-överföring, WTSUP använder nRF24L01. Kopplas in via 4pin-SPI, de har även en interrupt-utgång.
* Radiotronics Wi.FS24-100ST, som kör Freestar protokollet, men kan uppdateras till Zigbee. Dessa moduler använde jag tidigare men de är ganska dyra (200:-) de är också långsamma 250 kbit/s radio-trafik men kör över UART på 19200 bit/s.

HACS använder PIC18F97J60 som är en PIC-micro med inbyggd ethernet-PHY (det behövs bara en RJ-45 + magnetics) för att få en komplett nätverksenhet, mjukvaran finns tillgängligt via "Microchip Solutions" som TCPIP-Demo App MDD.

Denna mjukvara har jag sedan byggt på så att ovan support-lista är uppfylld.
Mjukvaran är byggd så att jag jag kan "routa" meddelande mellan de olika systemen.
t.ex.
TCP-server -> nRF24L01, nRF24L01 -> TCP-klient
nRF24L01 -> WiFs24, WiFs24 -> nRF24L01

433 MHz systemet kopplar bara mot trådlösa strömbrytare och inga egentliga meddelande skickas över detta system.

HACS-meddelande som skickas till HACS är uppbyggda enligt föjande modell:
[system att skicka över samt eventuell adress] [data att skicka till mottagaren] [end of message terminator]

HACS-meddelanden som skickas ifrån HACS är uppbyggda enligt föjande modell:
[data att skicka till mottagaren] [källan för detta HACS-meddelande]

Källan för HACS-meddelande anger vart ifrån meddelandet skickades, detta används då källan gör en förfrågan till en enhet i systemet, och när den tillfrågade enheten svarar så skickas [källan för detta HACS-meddelande] + svardata till HACS.

T.ex.
En PC-klient öppnar en TCP-socket och skickar nRF24_A_TXWANA:[nrf dest addr]=[data]
HACS tolkar sedan detta som att data ska skickas med hjälp av nRF24 enhet A till [nrf dest addr]
sedan tas nRF24_A_TXWANA:[nrf dest addr]= bort och [källan för detta HACS-meddelande] läggs till i slutet med seperator tecknet '|'
det som sedan skickas till dest addr är
[data]|TCPC_[socketnr]
denna dest addr tolkar sedan [data] och om en respons behövs så plockas TCPC_[socketnr] ut och respons datat samt [end of message terminator] läggs till i slutet:
TCPC_[socketnr]:[respons data][end of message terminator]
detta skickas sedan tillbaka till HACS som tolkar detta med att skicka [respons data] över den eventuella öppna TCP-socket.

Ok nog med text, här kommer några bilder på min föredetta WTSUP (skärmen slutade att fungera efter att jag tappade den i golvet), skärmen som används är på 2.8",
jag har dock köpt och börjat bygga en ny prototyp som använder en 4.3" TFT med Touch,
(Köpt på eBay som färdig modul med 4.3" TFT + SSD1963 + 4-pin touch + TouchController IC). WTSUP använder i grunden en Atmel AT32UC3B0256 + ett micro-SD kort.
WTSUP använder ett egetutvecklat GUI-system där själva GUI-strukturen lagras som vanliga windows-filer (FAT16) på SD-kortet. Bilderna lagras som BMP filer.
Mjukvaran är baserad på Atmel:s "USB - SD-card mass storage" - exempel, som gör att när jag vill göra förändringar i GUI:t så ändrar jag filerna direkt i PC:n, WTSUP-startas sedan om för att läsa in GUI:t igen.

Eftersom denna MCU bara har 32 kByte i RAM så går sidbytena i GUI:t ganska långsamt, och för att lösa detta så har jag börjat(nästan slutfört en design+layout) som använder AT32UC3A0512 istället, denna MCU har stöd för externt SD-RAM upp till 128 MByte. Jag kommer bara att använda ett 32 Mbyte minne men har räknat på det och det räcker för att lagra 85 st 480 x 272 x 24-bit bilder (den befintliga skärmen är på 480 x 272) denna design mäter 5 x 5 cm (jag kommer använda iteadstudio).
Har planer på att använda en 7" TFT med touch och SSD1963 ifrån eBay (50 USD) har designat kortet med tanke på anslutningen till denna display, men med en enkel adaptor så stöds alla skärmar som har 16-bit + RD + WR + CS + RS.

Verkar vara ett seriöst projekt.

Bra jobbat

Tråden kommer följas med intresse.

Har du nå planer att dela med dig av koden och layouten när du är klar ?

Kan du berätta mer om GUI miljön ur programmeringssynpunkt? API, miniexempel, återställande av grafik "under" ett fönster, multitask hantering osv.

Ok det tog lång tid att svara på detta , men jag har varit lite upptagen med PCB-design.
Har tänkt att jag ska skicka iväg flera olika kort och därmed spara på frakten.
En sak som jag inte har sagt tidigare är att jag har tänkt använda det nya kortet till HACS också,
och gör därmed ett expansions-kort med en ethernet PHY som kopplas in på RMII kontakten nere till vänster.
bild på nuvarande layout eftersom det även finns en inbyggd 16-bit DAC i AT32UC3A som delar pinnar med RMII
denna DAC har jag tänkt att använda för att spela upp lite ljud, då man använder funktionerna i GUI:t,
mest bara för att det finns möjlighet, och för att jag vill testa DAC:en.
och eftersom ethernet PHY bara tar en tredjedel av det maximala 5x5cm kortet så kommer
det bli yta över för ett litet expansionskort till och detta kommer innehålla de få komponenter
som behövs för att buffra signalerna ifrån DAC:en, det bästa hade varit om jag kunde använda
en liten högtalare ifrån en gammal mobil och sätta denna på samma kort.
Den sista mönsterkort ytan kommer användas till en LCD-adapter, så huvudkortet passar in på
min nuvarande LCD.

Angående GUI miljön och API:t så har jag definerat en "GUI_object" struct som följer:

// 7+32+32+2*4+1+2*3+1 = 87 bytes/control
typedef struct {
char strImage[7]; // image root name
char strText[32]; // Text to show with control
char strCmdMsg[32]; // command message if present
U16 u16_xPos; // control position
U16 u16_yPos; // control position
U16 u16_width; // used to know touch area
U16 u16_height; // used to know touch area
U8 u8_type; // type of control
U16 u16_maxValue; // if control is bi-state this is 1
U16 u16_minValue; // if control is bi-state this is 0
U16 u16_value; // control status/value
U8 u8_execFunction; // function to execute when control is used
}GUI_object;

u8_execFunction sätts till någon av följande:
#define GUI_FUNK_TYPE_NONE 0x00
#define GUI_FUNK_TYPE_PAGESEL 0x01
#define GUI_FUNK_TYPE_ZIGBEE_SEND 0x02
#define GUI_FUNK_TYPE_SET_PAINT_SIZE 0x06

strCmdMsg[] innehåller eventuella parametrar som funktionen ska använda.

u8_type kan sättas till någon av följande:
// GUI control types (MSB nibble defines ground type and LSB nibble defines subtype)
#define GUI_CTRL_GNDTYPE_STATIC 0x10
#define GUI_CTRL_GNDTYPE_BUTTON 0x20
#define GUI_CTRL_GNDTYPE_CHECK 0x30
#define GUI_CTRL_GNDTYPE_MOVABLE 0x40

#define GUI_CTRL_TYPE_BACKGROUND_IMAGE 0x00
#define GUI_CTRL_TYPE_IMAGE (GUI_CTRL_GNDTYPE_STATIC | 0x00)
#define GUI_CTRL_TYPE_LABEL (GUI_CTRL_GNDTYPE_STATIC | 0x01)
#define GUI_CTRL_TYPE_COLORSEL (GUI_CTRL_GNDTYPE_STATIC | 0x02)
#define GUI_CTRL_TYPE_OFF_SCREEN_TABS (GUI_CTRL_GNDTYPE_STATIC | 0x03)
#define GUI_CTRL_TYPE_IMAGEBUTTON (GUI_CTRL_GNDTYPE_BUTTON | 0x00)
#define GUI_CTRL_TYPE_TEXTBUTTON (GUI_CTRL_GNDTYPE_BUTTON | 0x01)
#define GUI_CTRL_TYPE_CHECKBOX (GUI_CTRL_GNDTYPE_CHECK | 0x00)
#define GUI_CTRL_TYPE_CHECKBUTTON (GUI_CTRL_GNDTYPE_CHECK | 0x01)
#define GUI_CTRL_TYPE_CHECKIMAGEBUTTON (GUI_CTRL_GNDTYPE_CHECK | 0x02)
#define GUI_CTRL_TYPE_RADIOBUTTON (GUI_CTRL_GNDTYPE_CHECK | 0x03)
#define GUI_CTRL_TYPE_IMAGERADIOBUTTON (GUI_CTRL_GNDTYPE_CHECK | 0x04)
#define GUI_CTRL_TYPE_SLIDER_VERTICAL (GUI_CTRL_GNDTYPE_MOVABLE | 0x00)
#define GUI_CTRL_TYPE_SLIDER_HORIZONTAL (GUI_CTRL_GNDTYPE_MOVABLE | 0x01)
#define GUI_CTRL_TYPE_SCROLL_VERTICAL (GUI_CTRL_GNDTYPE_MOVABLE | 0x02)
#define GUI_CTRL_TYPE_SCROLL_HORIZONTAL (GUI_CTRL_GNDTYPE_MOVABLE | 0x03)

Kort beskrivning av GUI-hanteringen:
Vid första start så läses Main.GUI ifrån SD-kortet, och lagras i ett "GUI_control"-struct array,
efter det så går programmet igenom detta array och "skriver ut" GUI:t på skärmen,
i detta skede så läses också de olika bilderna ifrån SD-kortet.

När en eventuell touch har skett så anropas det en funktion som kollar igenom "GUI_control"-arrayt
och med hjälp av u16_xPos, u16_yPos, u16_width och u16_height så avgörs det vilket objekt som har tryckts på
och om objektet har en funktion så exekveras denna.
om objektet t.ex. är en knapp så läses "ned-tryckt"-bilden ifrån SD-kortet och visas,
när knappen sedan släpps så läses och visas "upp" bilden.

Angående multitasking så använder jag DMA:n för att skicka kommandon till
"Zigbee" som använder det slöa UART @ 19200 bit/s,
detta görs genom att ha en buffert där det aktuella kommandot stoppas in
sedan så anropas DMA:n som automatiskt skickar datat ut över UART.

Fönster använder/har jag inte använt ännu, min första skärm var bara 2.8" och 320x240 upplösning.
Däremot används flera sidor, och dessa ritas upp ifrån GUI-filen (jag har en GUI-fil för varje sida)
för enkelhets skull så används en bakgrundsbild som täcker hela skärmen och läses in först vid sid-byte.

För själva GUI-uppbyggnaden så har jag gjort ett program i C# (använde detta som projekt-uppgift för min C#-kurs)
notera det är en kontroll till höger, denna änvänds för att editera parametrar för de olika GUI-objekten, skulle bara säga att
denna finns redan tillgänglig och färdig i .NET framework.
Själva GUI-objekten är pictureboxes där innehållet ritas ut för hand. Och för att tillägga så har jag även börjat på en Android-app som även läser dessa GUI-filer,
det var dock länge sedan jag gjorde något med denna app sist.

GUI koden finns bifogad nedan
notera att koden i Main som anropar GUI funktionerna är bort-kommenterade
och finns i slutet på main-loopen. Jo jag kommer ge ut koden/layouten när jag är klar.