/*
Projekt: Photovoltaik-Präsentation "solar" mit MSP430
Detail: Gemeinsame Kopfdatei
060704 erstellt
*/
#ifndef _SOLAR_H_
#define _SOLAR_H_
// Gemeinsam für alle Module
#include <io.h>
#include <signal.h>
#include <iomacros.h>
#include <stddef.h> // NULL, size_t
// Anzahl von Array-Elementen
#define elemof(x) (sizeof(x)/sizeof(*(x)))
// Dummy-Makro für absichtlich vergessenes "break"
#define nobreak
#define CPUCLK 8000000L // 8 MHz Taktfrequenz des MSP430
typedef unsigned char BYTE; // Ein Byte ist ein Oktett:-)
typedef unsigned short WORD;
typedef int INT; // Lieblingsmaschinentyp, bei ATmega = BYTE
typedef unsigned UINT;
typedef enum {false,true} bool; // sofern kein C++
/*============*
*== main.c ==*
*============*/
void Idle(void); // Idle-Prozedur
/*===============*
*== tableau.c ==* die LED-Anzeigen betreffend:
*===============*/
/************************************************************************
* Ein Tableau hat 64 LEDs.
* Die ersten 32 bilden die vier Siebensegmentanzeigen, v.r.n.l.
* Die Bitzuordnung ist regulär mit Bit 0 -> Segment A,
* Bit 1 -> Segment B usw. Gesetzte Bits bedeuten leuchtende Segmente.
* Daran folgen 32 LEDs für den Bargraf, ebenfalls v.r.n.l.
************************************************************************/
#define NUMTABLEAUS 9
typedef BYTE TTableau[8]; // Jedes Byte entspricht 8 LEDs
// Bitspeicher als Backup für die insgesamt 64*9 = 576 LEDs;
// Es gibt 9 Tableaus auzusteuern
extern TTableau TablLeds[NUMTABLEAUS];
// Für jedes Tableau kann eine Stelle hervorgehoben werden
extern BYTE TablHiliteDigit[NUMTABLEAUS];
// Anoden-Zuordnung in "natürlicher" Form
extern const BYTE SHL[8]; // anstelle "1<<x" "SHL[x]" benutzen!
extern const unsigned long SHLD[32];
void TablInit(void);
void TablSetBright(unsigned x);
void TablStrOut(INT nTableau, char*s);
void TablDecimalOut(INT nTableau, int Value, INT Decimals);
unsigned long TablCalcBargraf(INT nFrom, INT nTo, INT nPeak);
unsigned long TablGetBargraf(INT nTableau);
void TablSetBargraf(INT nTableau, unsigned long bits);
#define TablLampentest(AllOn) memset(TablLeds,(AllOn)?0xFF:0,sizeof(TablLeds))
extern volatile unsigned TickCount; // Millisekunden seit Controller-Reset
#define GetTickCount() TickCount // wie Windows
void Sleep(unsigned ms); // wie Windows
/*===============*
*== display.c ==*
*===============*/
BYTE DispFlags;
#define DISPLAY_FAILED 0x80 // Code für Display-Versagen
#define DispFailed() (DispFlags&DISPLAY_FAILED)
void DispInit(void);
void DispDataWrite(WORD addr, const BYTE*data, unsigned len);
void DispDataFill(WORD addr, BYTE fill, unsigned len);
void DispDataRead(WORD addr, BYTE*data, unsigned len);
void DispPrintf(int x, int y, const char*template,...);
#define FONT_X 6 // Zurzeit eingesteller Font: 6x8 (alternativ 8x8)
#define FONT_Y 8
#define TEXT_X 40 // alternativ 30 (Font 8x8) oder 32 (wie das?)
#define TEXT_Y 16 // Verfügbare Zeilen des Textmodus'
#include "graphics.h"
typedef struct pointtype POINT, TPoint, *PPoint;
typedef const TPoint *PCPoint;
typedef struct{
TPoint pos; // Ausgangsposition für LineTo
COLORREF color;// Linienfarbe (schwarz (00) oder weiß (FF))
BYTE penwidth; // für breite Linien
unsigned linestyle;// für gestrichelte Linien
BYTE rop2; // binärer Rasteroperationskode (für Linien)
BYTE rop3; // ternärer Rasteroperationskode (für Füllflächen? und BitBlt)
BYTE pattern[8]; // Füllmuster
int pen:1; // Stift nutzen
int brush:1; // Füllung nutzen
int transparent:1;// keine Hintergrundfarbe bei unterbrochenen Linien und Text
struct viewporttype viewport;
unsigned ba; // BAsisadresse
}TGrafDC;
// _alle_ Rasteroperationskodes (binär) - als Untermenge der ternären ROPs:
enum { R2_BLACK =0x00, /* 0 */
R2_NOTMERGEPEN =0x05, /* DPon */
R2_MASKNOTPEN =0x0A, /* DPna */
R2_NOTCOPYPEN =0x0F, /* Pn */
R2_MASKPENNOT =0x50, /* PDna */
R2_NOT =0x55, /* Dn */
R2_XORPEN =0x5A, /* DPx */
R2_NOTMASKPEN =0x5F, /* DPan */
R2_MASKPEN =0xA0, /* DPa */
R2_NOTXORPEN =0xA5, /* DPxn */
R2_NOP =0xAA, /* D */
R2_MERGENOTPEN =0xAF, /* DPno */
R2_COPYPEN =0xF0, /* P */
R2_MERGEPENNOT =0xF5, /* PDno */
R2_MERGEPEN =0xFA, /* DPo */
R2_WHITE =0xFF}; /* 1 */
/* _einige_ Rasteroperationskodes (ternär): Ergebnis aus Tabelle
P S D rop-idx Beisp.
0 0 0 Bit0 0
0 0 1 Bit1 0
0 1 0 Bit2 1
0 1 1 Bit3 1
1 0 0 Bit4 1
1 0 1 Bit5 1
1 1 0 Bit6 1
1 1 1 Bit7 1
Beispiel: Index=FC, Opcode=PSo */
enum { //PATCPY,PATAND,PATOR,PATXOR,DSTINV,DSTSET,DSTRES,DSTNOP};
BLACKNESS = 0x00, /* 0 */
NOTSRCERASE = 0x11, /* DSon */
NOTSRCCOPY = 0x33, /* Sn */
SRCERASE = 0x44, /* SDna */
DSTINVERT = 0x55, /* Dn */
PATINVERT = 0x5A, /* DPx */
SRCINVERT = 0x66, /* DSx */
SRCAND = 0x88, /* DSa */
MERGEPAINT = 0xBB, /* DSno */
MERGECOPY = 0xC0, /* SPa */
SRCCOPY = 0xCC, /* S */
SRCPAINT = 0xEE, /* DSo */
PATCOPY = 0xF0, /* P */
PATPAINT = 0xFB, /* DPSnoo*/
WHITENESS = 0xFF};/* 1 */
extern TGrafDC GrafDC;
void DataPuts(WORD addr, const char*str, size_t len);
void OutScanline(int xa, int xe, int y, BYTE pattern, BYTE*data);
void GrafInternalLine(int xa, int ya, int xe, int ye);
void drawpolypoly(int numpoly, const int*numpt, const POINT*pt);
void fillpolypoly(int numpoly, const int*numpt, const POINT*pt);
// der Rest wie Windows-API
typedef void (*TGrafLineDDAProc)(int x, int y, int param);
void GrafLineDDA(int xa,int ya,int xe,int ye,TGrafLineDDAProc proc,int param);
void GrafPolyline(const POINT*pt, int numpt);
bool GrafPolyPolygon(const POINT*pt, const int*numpt, int numpoly);
bool GrafPolygon(const POINT*pt, int numpt);
void GrafRectangle(int left, int top, int right, int bottom);
void GrafCreateSolidBrush(BYTE pattern[8], COLORREF color);
BYTE Inp_Tasten(void); // Tastenabfrage (8 Tasten)
BYTE Inp_Schalter(void);// Nockenschalterabfrage
/*===============*
*== analog.c ==*
*===============*/
#define N_CH 8 // 8 Kanäle: 3x Spannung, 3x Strom, Referenz-U, Temparatur
#define N_AVG 8 // Zur Verringerung von Rauschen wird ein Mittelwert gebildet.
void ADU_Init(void);
//#define ADU_Get(Kanal) (ADC12MEM[(Kanal)])
int ADU_Get(int Kanal);
extern void DAU_Init(void);
#define DAU_Put(Kanal,Value) ((&DAC12_0DAT)[Kanal]=Value)
#define DAU_Get(Kanal) (&DAC12_0DAT)[Kanal]
// Relais
void Rel_SetState(INT what, bool state);
bool Rel_GetState(INT what);
/*=============*
*== ser0.c ==*
*=============*/
enum { fOutX=1, // Flusskontrolle beim Senden (zum PC)
fInX=2, // Flusskontrolle beim Empfang (vom PC)
fXoffSent=4, // bei Unterschreitung von LOWATER ein XON senden
fCRLF=8, // Textmodus: Übersetzung von 0A->0D0A
fOutConv=16, // Zeichenkodes >=80h bei Ausgabe konvertieren
fInConv=32, // Zeichenkodes >=80h bei Eingabe konvertieren
fUTF8=64};
extern BYTE Ser0Flags;
void Ser0Init(void);
int getchar(void);
int putchar(int);
bool kbhit(void);
// betreffend XON/XOFF-Protokoll und Pufferung
//void ClearOutputBuffer(void);
//void ClearInputBuffer(void);
void TransmitCommChar(char); // wie Windows-Funktion
/*==============*
*== vt100.c ==*
*==============*/
#define ESC "\033" /* das Escape-Zeichen */
#define CSI ESC"[" /* die sog. CSI-Sequenz */
char AnsiGetKey(void);
void AnsiGotoXY(INT x, INT y);
void AnsiSetColor(BYTE color);
void AnsiDrawChars(char c, INT count);
void AnsiDrawRectangle(INT x, INT y, INT w, INT h, char c);
void AnsiSaveCursor(void);
void AnsiRestoreCursor(void);
char Visible(char c); // konvertiert Steuerzeichen zu '_'
enum {TERMMODE_ANSI=1, // Bits in TermMode
TERMMODE_VT100=2};
extern BYTE TermMode; // vorgefundener Terminal-Typ
extern BYTE TermTaster; // Virtueller(!) Status der 8 Tasten
extern BYTE TermSchalter; // Virtueller(!) Status Nockenschalter
void TermInit(void);
void TermDrawValue(INT y, int val, INT nk, unsigned long bar, int hex);
void TermDrawDisplayMirror(INT x, INT y, const char*text);
int TermChar2KeyBit(char c);
void TermDrawTaster(INT i);
void TermSetTaster(BYTE NewState);
void TermDrawSchalter(void);
void TermSetSchalter(BYTE NewState);
void TermDrawRelais(INT i);
void TermDrawDAU0(void);
void TermDrawDrehstrich(void);
#endif//_SOLAR_H_
| Detected encoding: ANSI (CP1252) | 4
|
|
|