Kev Mann
Test
Dependencies: mbed-dev-OS5_10_4
Revision 0:014fad4dfb9d, committed 2020-08-07
- Comitter:
- kevman
- Date:
- Fri Aug 07 07:24:21 2020 +0000
- Commit message:
- Test
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Main/Dac8532.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,166 @@
+/*
+-------------------------------------------------------------------------------
+Programm Name: DaMethoden.C
+Version: 1.0
+Sprache: C
+Compiler: CrossStudio Ver. 2.0
+Autor: PS
+Copyright: PS
+
+
+Funktion: Init und Io fuer den D/A Wandler
+
+28.10.2012:
+
+-------------------------------------------------------------------------------*/
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+// Private Definitionen
+/** Max buffer length */
+
+
+// Rev B und C
+
+
+// Private Variablen
+
+int nDCounter;
+unsigned char Low, High;
+
+
+
+
+/*-------------------------------------------------------------------------------
+Initialisieren der Pins fuer den DA Wandler
+-------------------------------------------------------------------------------*/
+int InitDac(void)
+{
+ int i;
+/*
+Initialisieren der Pins fuer den D/A Zugriff:
+ Mosi = 0; // Mosi für den D/A Wandler
+ CsDac = 1; // CS für den D/A Wandler, 0 = Cs aktiv, (low active)
+ Sck = 0; // SCK für den D/A Wandler
+
+*/
+ DacCs = 0;
+ DacSck = 1;
+ DacMosi = 0;
+
+ for(i=0;i<3;i++)
+ {
+ DacSck = 0;
+ DacSck = 1; // D23 bis D21 auf 0
+ }
+ DacMosi = 1; // D20 auf 1, load DAC A
+ DacSck = 0;
+ DacSck = 1;
+ DacMosi = 0;
+
+ for(i=4;i<24;i++)
+ {
+ DacSck= 0;
+ DacSck = 1; // D19 bis D0 auf 0
+ }
+ Low = 0x00;
+ High = 0x00;
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+Testen des D/A Wandlers
+-------------------------------------------------------------------------------*/
+int TestDac(void)
+{
+ Low++;
+ SpiSendDa (0, 0);
+ if(Low == 0xFF)
+ {
+ High++;
+ }
+ return(true);
+}
+/* ********************************************************************
+macht das komplette Out fuer 24 Bit
+ ***********************************************************************/
+int SpiSendDa (uint8_t Channel, uint16_t Mode)
+{
+ uint32_t WData0, WData1,WData2;
+ uint16_t n;
+ uint32_t Mask;
+ uint32_t tmp;
+
+ DacSck = 0;
+ DacCs = 0;
+
+ // 2016-06 UFa: Aenderungen aufgrund HW-Revision
+ short_delay(1);
+
+ n = 0;
+ WData0 = 0x10;
+ WData1 = High;
+ WData2 = Low;
+ Mask = 0x0800000;
+ tmp = 0;
+ tmp = ((WData0 << 16) | (WData1 << 8) | (WData2));
+ for(n=0;n<24;n++)
+ {
+ DaSckUp();
+ short_delay(1);
+ if(tmp & Mask)
+ DaMosiUp();
+ else
+ DaMosiDown();
+ short_delay(1);
+ DaSckDown();
+ short_delay(1);
+ Mask >>= 1;
+ }
+ // 2016-06 UFa: Aenderungen aufgrund HW-Revision
+ DacCs = 1;
+ DacSck = 1;
+ short_delay(1);
+
+ return (0);
+}
+
+/*-------------------------------------------------------------------------------
+Berechnen der Daten an den DA Wandler. Wird erst mal für die Anschlussbox berechnet,
+bei der jeweils 2 Kanäle auf einen Ausgang addiert werden
+-------------------------------------------------------------------------------*/
+void CalcDa(double SourceVal, UINT8 Chn)
+{
+// DigitalOut CsTest(PTC16); // nur wegen dekativierung durch Ethernet. Ich hoffe, das wird wieder anders
+ unsigned int OutValue;
+ double Counts;
+ double SrcVal;
+
+
+ SrcVal = SourceVal;
+
+ Counts = SrcVal * 13.107;
+
+ OutValue = (uint16_t)(Counts);
+
+ Low = OutValue;
+ High = (OutValue >> 8);
+ SpiSendDa(0,1);
+}
+
+/*-------------------------------------------------------------------------------
+Senden der Daten an den DA Wandler
+-------------------------------------------------------------------------------*/
+void SendDataDa(void)
+{
+ SpiSendDa(0,3);
+}
+
+
+
+
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Main/Dac8532.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,15 @@ +/*------------------------------------------------------------------------------- +Programm Name: Dac8532.H +Version: 1.0 +Sprache: C +Compiler: mbed OS 5.8 +Autor: PS +Copyright: PS +Funktion: Dac Variablen und Methoden + +-------------------------------------------------------------------------------*/ + +extern int InitDac(void); +extern int TestDac(void); +extern int SpiSendDa (uint8_t Channel, uint16_t Mode); +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Main/Headers.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,93 @@ +/*------------------------------------------------------------------------------- +Programm Name: Headers.h +Version: 1.0 +Sprache: C +Compiler: CrossStudio Ver. 2.0 +Autor: PS +Copyright: PS + + +Funktion: Enthält alle relevanten Header +28.10.2012: +-------------------------------------------------------------------------------*/ +// #define PGU_TOUCH 1 +// #define PGU_BI_TOUCH 1 +// #define PGU_EDUCATION 1 +#define PGU_RPA 1 +// #define PGU_LTR 1 +// #define SINE_GEN 1 // wird fuer den Sinusgenerator definiert +// #define ECN 1 // wird fuers ECN definiert +// #define TOUCH_DISPLAY 1 // aktiviert die Display und Touch Methoden +#define ADC_24BIT 1 +// #define DAC_32BIT 1 +// #define DO_AUTO_START 1 +// #define USE_RTC 1 // wenn die eingebaute Uhr verwendet wird + + +#include <string.h> +#include <iostream> +#include <math.h> +#include <stdio.h> +#include <algorithm> +#include "mbed.h" +// #include "MK64FK12.h" +///mbed-dev_577/features/FEATURE_LWIP/lwip-interface/ +// #include "EthernetInterface.h" +#include "SDBlockDevice.h" +#include "FATFileSystem.h" + + + +#include "FT_DataTypes.h" +#include "Chip1768.h" +#include "AdRead.h" +#include "Dio.h" +#ifndef PGU_RPA + #include "Calibration.h" +#endif +#include "OpenIni.h" +#include "OpenDevId.h" +#ifndef PGU_RPA + #include "OpenAutoStart.h" + #include "RunAutoStart.h" +#endif +#include "Struct.h" +#ifndef PGU_RPA + #include "MethGlobals.h" +#endif +#include "Dac8532.h" +#include "InitMain.h" +#ifndef PGU_RPA + #include "SwitchMode.h" + #include "RwConfig.h" + #include "RwParameter.h" + #include "TftGetSetParaValues.h" + #include "RwSeqFile.h" + #include "CalcGenValues.h" + #include "RwMwFile.h" + #include "RwHeaderFile.h" +#endif + +#include "EcmTel.h" + + +#include "LoopTimer.h" +#include "RpaSerial.h" + +// #include "EthGlobals.h" + +#ifndef PGU_RPA + #include "SequenzMethoden.h" + #include "SwitchRanges.h" +#endif +#include "SendTelToHost.h" +#include "Globals.h" + +#ifndef PGU_RPA + #include "TftServices.h" +#endif +#include "SdGlobals.h" +#include "IfGlobals.h" +#include "AdGlobals.h" +#include "SdCard.h" +// #include "Threads.h"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Main/main.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,322 @@
+/*-------------------------------------------------------------------------------
+Programm Name: Main.C
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Main Funktionen
+04.08.2016: Projekt: EcmComFrdm
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+// #define Ad0IsRdyDown() (LPC_GPIO0->FIOCLR & 0x000800000)
+// #define Ad1IsRdyDown() (LPC_GPIO0->FIOCLR & 0x001000000)
+
+//const char* MyIp = "192.168.2.99";
+//const char* HostIp = "192.168.2.8";
+//const char* MySub = "255.255.255.0";
+//const char* MyGw = "0.0.0.0";
+
+
+
+/*-------------------------------------------------------------------------------
+Main Funktion.
+-------------------------------------------------------------------------------*/
+int main()
+{
+
+ InitMain();
+ ConnectIrq();
+ g_fDisableDataRead = false;
+// Ad7739Start(0, 0,1);
+// MVars.m_fMessDlgOpened = true;
+ MVars.nAktMittelAfter = 500;
+ while (true)
+ {
+ CheckAnalogIn();
+
+ if(nMyTimer > 0) // Scanner Verarbeitung
+ {
+ CheckTimerHandlingAndScanner();
+ }
+/*
+ if(g_nChn1Counter > 1000)
+ {
+ printf("%c#DG#Channel 1 Counter: %ld %c\n", STX, g_nChn1Counter, ETX);
+ g_nChn1Counter = 0;
+ }
+ else if(g_nChn2Counter > 1000)
+ {
+ printf("%c#DG#Channel 2 Counter: %ld %c\n", STX, g_nChn2Counter, ETX);
+ g_nChn2Counter = 0;
+ }
+*/
+ if(HostIf.nInTel > 0)
+ CheckCommInterface();
+
+ CheckEcmWinConnect();
+
+#ifdef TOUCH_DISPLAY
+ CheckEvent(); // TFT Event
+#endif
+#ifdef DO_AUTO_START
+ if(g_fDoAutostart == true)
+ g_fDoAutostart = CheckAutoStart(); // kommt false zurueck, dann wird der Aufruf beendet
+#endif
+ CheckZustand(); // Zustand der Messung
+ }
+
+}
+/*-------------------------------------------------------------------------------
+ Funktion CheckCommInterface prüft ob ueber die Kommunikationsschnittstelle
+ eine Anforderung kommt.
+-------------------------------------------------------------------------------*/
+int CheckCommInterface()
+{
+ if(TransferSioTel() == true)
+ {
+// ChangeLedColor();
+// printf("%c#DG#HostIf.strTelAwBuf: %s%c\r\n",STX, HostIf.strTelAwBuf, ETX);
+ CheckTel();
+ }
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+ Funktion CheckEcmWinConnect: Bearbeitet alle Methoden die mit der Messung ueber
+ EcmWin zu tun haben.
+-------------------------------------------------------------------------------*/
+int CheckEcmWinConnect()
+{
+ if(!MVars.m_fMessDlgOpened)
+ {
+ g_nChn2Counter++;
+ if(g_nChn2Counter > 50000)
+ {
+// printf("%c#DG#Channel 2 Counter: %ld %c\n", STX, g_nChn2Counter, ETX);
+ ChangeLedColor();
+ g_nChn2Counter = 0;
+ }
+ }
+
+ if(MVars.m_fMessDlgOpened)
+ {
+// ReadAllAdChannels();
+ if(MVars.nMittelTimer >= MVars.nAktMittelAfter)
+ {
+ CheckDaAd();
+ MVars.nMittelTimer -= MVars.nAktMittelAfter;
+ ChangeLedColor();
+ }
+ CheckZustand();
+ }
+#ifdef DO_AUTO_START
+ else if(m_fAutoStart == true) // ist in der Autostart Funktion
+ {
+ if(MVars.nMittelTimer >= MVars.nAktMittelAfter) // nAktMittelAfter muss ueber die Sequenz neu gestzt werden
+ {
+ if(CheckDaAd() == false)
+ {
+ DisableAutoMode();
+ }
+ MVars.nMittelTimer -= MVars.nAktMittelAfter;
+ ChangeLedColor();
+ }
+ if (g_nTftTimer >= 1000)
+ {
+ RequestDateTime();
+ g_nTftTimer = 0;
+ if(m_fAutoStart == true)
+ DoStatusLed = !DoStatusLed;
+ }
+ }
+#endif
+ else
+ {
+ if (g_nTftTimer >= 1000)
+ {
+// RequestDateTime();
+ g_nTftTimer = 0;
+ }
+ }
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+ DoReInit: Initialisieren des AD Wandlers
+-------------------------------------------------------------------------------*/
+int DoReInit()
+{
+ uint8_t Status0, Status1;
+// DigitalOut Test(PTC16);
+#ifdef TFT_DEBUG
+ printf("DOR_C: %08X DIR_C: %08X DDR_C:%08X \r\n", GPIOC->PDOR, GPIOC->PDIR, GPIOC->PDDR); // PTC 16 auf Output schalten
+#endif
+
+// GPIOC->PDDR |= 0x00010000; // PTC 16 auf Output schalten
+
+ MVars.fAdReInit = false;
+ MVars.m_nSendValues = 1; // fängt an, in Grundstellung zu senden
+ g_fRdy0 = false; g_fRdy1 = false;
+
+// ConnectIrq();
+ g_fDisableDataRead = false;
+ Ad7739Start(0, 0,1); // 0=Kanal mit dem begonnen wird, Wandler 0, Mode
+// Ad7739CommonStart(0, 1);
+
+ nMyTimer = 0;
+ g_nAdSetPos = 0; g_nAdGetPos = 0;
+ g_nAdCount = 0;
+ MVars.m_nSendValues = 1; // fängt an, in Grundstellung zu senden
+ ZustandsTimer = 0;
+
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+ Funktion CheckZustand prüft alle eingehenden Telegramme auf Inhalt und Befehl
+-------------------------------------------------------------------------------*/
+int CheckZustand()
+{
+
+ if(MVars.fAdReInit == true)
+ {
+ MVars.fAdReInit = false;
+ DoReInit();
+ }
+
+ if(MVars.m_nSendValues == 0) // nichts senden
+ {
+ nMyTimer = 0;
+ ZustandsTimer = 0;
+ return(0);
+ }
+
+// MVars.dbAdSum[0] += (long double)AdcHs1.read_u16();
+// MVars.dbAdSum[1] += (long double)AdcHs2.read_u16();
+// MVars.nMwMittelCount++;
+#ifdef TFT_DEBUG
+// printf("AdResult_0: %f \n",MVars.dbAdSum[0]);
+#endif
+// g_nAdGetPos++; g_nAdGetPos &= 0x3FF;
+
+
+// AdVal->AdRingBuf[0][g_nAdSetPos] = AdcHs1.read_u16();
+// AdVal->AdRingBuf[1][g_nAdSetPos] = AdcHs2.read_u16();
+// g_nAdSetPos++; g_nAdSetPos &= 0x03FF;
+// g_nAdCount++;
+
+
+// CheckDaAd();
+
+ if(ZustandsTimer >= 100) // die Zustände werden dadurch alle 100ms überprüft
+ {
+ MVars.nSecCounter[0] += 100;
+ IrComp.n100msCounter++;
+ ZustandsTimer -= 100;
+
+ if(MVars.m_nSendValues == 1) // senden in Grundstellung
+ {
+ CheckGrundZustand();
+ }
+ else if(MVars.m_nSendValues == 2) // senden während Messung
+ {
+ CheckRunZustand();
+ }
+ }
+
+ return(0);
+}
+
+/*-------------------------------------------------------------------------------
+ CheckGrundZustand:
+-------------------------------------------------------------------------------*/
+int CheckGrundZustand()
+{
+ MVars.m_fDisableStopTel = false;
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+ CheckRunZustand:
+-------------------------------------------------------------------------------*/
+int CheckRunZustand()
+{
+
+ switch(MVars.nMessZustand[0])
+ {
+ case -1:
+ break;
+ case 0:
+ break;
+ case 1:
+ break;
+ case 2:
+ MVars.nSecCounter[0] = 0;
+ break;
+ case 3:
+ break;
+ case 4:
+ break;
+ case 5:
+ if(MPara.RpDauerNach[0] > 0)
+ {
+ if(MVars.nSecCounter[0] >= 1000)
+ {
+ MVars.nSecCounter[0] -= 1000;
+ MPara.RpDauerNach[0]--;
+ }
+ }
+ else
+ {
+ MVars.m_fDoFinishMeasurement = true;
+ MVars.m_fDisableStopTel = true;
+ }
+ break;
+ case 6: // schickt nur kontinuierlich die Werte
+ break;
+ default:
+ break;
+
+ }
+ if(MVars.m_fDoFinishMeasurement == true) // wird von Stopkommando aus EcmTel gesetzt
+ {
+ MVars.m_fDoFinishMeasurement = false;
+ MVars.m_fFinishMeasurement = true;
+ MVars.m_fScan = false;
+#ifdef SIO_DEBUG
+ printf("MessZustand: %d \n",MVars.nMessZustand[0]);
+ printf("SwOCP:%d\n",MVars.SwitchChn[0]);
+#endif
+
+ }
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+ChangeConversionTime: Im Fall dass die Wandlungszeit geändert werden muss
+-------------------------------------------------------------------------------*/
+void ChangeConversionTime()
+{
+ MVars.fChangeCt = false;
+ SetAdConversionTime();
+// wait(0.2);
+// led1 = !led1;
+}
+/*-------------------------------------------------------------------------------
+SendMessungStart: Startet die Messung
+-------------------------------------------------------------------------------*/
+int SendMessungStart()
+{
+ sprintf(HostIf.strTempBuf,"%c#MG#%c", STX, ETX);
+ SendTelToHost(false, false, false);
+ return(0);
+}
+/*-------------------------------------------------------------------------------
+SendMessungStop: Stoppt die Messung
+-------------------------------------------------------------------------------*/
+int SendMessungStop()
+{
+ sprintf(HostIf.strTempBuf,"%c#MS#%c", STX, ETX);
+ SendTelToHost(false, false, false);
+ return(0);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/AdCalculations.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,75 @@
+/*-------------------------------------------------------------------------------
+Programm Name: AdCalculations.C
+Version: 1.0
+Sprache: C++
+Compiler: mbed Studio
+Autor: PS/UF
+Copyright: IPS
+
+
+Funktion: Basiskalkulationen für die Umrechnung der Werte von A/D Wandler
+
+16.06.2017
+Neu angelegt um die Funktionen in Main zu entzerren
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+/*-------------------------------------------------------------------------------
+File interne Membervariablen
+-------------------------------------------------------------------------------*/
+
+
+/*-------------------------------------------------------------------------------
+CalculateAdBaseValues: macht die Basisumrechnungen der vom A/D Wandler gelieferten
+Werte. Erst mitteln, dann um den Nullpunkt verschieben, dann Skalieren
+-------------------------------------------------------------------------------*/
+int CalculateAdBaseValues()
+{
+ int i;
+
+ for(i=0;i<8;i++)
+ {
+ if(MVars.m_fChnValid[i] == true)
+ {
+ if(MVars.nChnAverage[i] > 0)
+ {
+ if( MVars.dbAdSum[i] == 0.0)
+ {
+ InitBaseInputArray();
+ printf("No Values, dbAdSum = 0.0\r\n");
+ return(false);
+ }
+ MVars.dbAdResult[i] = MVars.dbAdSum[i] / (double)MVars.nChnAverage[i];
+ MVars.dbAdResult[i] -= 8388607.;
+ MVars.dbAdResult[i] *= EcmIni.dbUScale[i]; // Potential
+ MVars.dbAdResult[i] += EcmIni.dbUOffset[i]; // Offsetkorrektur für das Potential
+ MVars.dbAdResult[i] += 8388607.;
+ }
+ else
+ {
+ InitBaseInputArray();
+ printf("No Values, ChnAverage = 0\r\n");
+ return(false);
+ }
+ }
+ MVars.dbAdSum[i] = 0.0;
+ MVars.nChnAverage[i] = 0;
+ }
+ InitBaseInputArray();
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+InitBaseInputArray: setzt die Variablen für die Messdaten, welche im Interrupt gelesen
+werden, auf Null
+-------------------------------------------------------------------------------*/
+void InitBaseInputArray()
+{
+ int j;
+
+ for(j=0;j<8;j++)
+ {
+ MVars.dbAdSum[j] = 0.0;
+ MVars.nChnAverage[j] = 0;
+ }
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/AdGlobals.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,158 @@
+/*-------------------------------------------------------------------------------
+Programm Name: AdGlobals.cpp
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Globale Variablen für den A/D Wandlerzugriff
+
+30.06.2017:
+
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+// I/O's für den A/D Wandler
+DigitalOut AdcSck(PTC10);
+DigitalIn AdcMiso(PTC11);
+DigitalOut AdcMosi(PTB11);
+
+InterruptIn AdcRdy0(PTB10);
+InterruptIn AdcRdy1(PTC9);
+
+DigitalOut Adc0Cs(PTB3);
+DigitalOut Adc1Cs(PTC8);
+
+DigitalIn AdcReset(PTB2);
+
+
+// Globale Variablen
+//-------------------------------------
+uint8_t g_TempDelay;
+uint8_t g_AReadTemp;
+uint8_t g_nAdResultCount;
+
+
+bool g_fAdConversion;
+bool g_fRdy0, g_fRdy1;
+
+
+AD_VAL *AdVal;
+
+UINT8 g_fARead[8];
+uint8_t g_nAdSetPos, g_nAdGetPos;
+int g_nAdCount;
+UINT32 m_AdTemp[8];
+
+
+/*-------------------------------------------------------------------------------
+Schreibt die Inits auf beide AD Wandler
+-------------------------------------------------------------------------------*/
+void Ad7739CommonWrite(uint8_t b)
+{
+ uint8_t mask = 0x80;
+ AdSckUp();
+ Ad0CsDown();
+ Ad1CsDown();
+ short_delay(2);
+ do
+ {
+ AdSckDown();
+ short_delay(2); // min. 50ns SCK low
+ (b & mask) ? (AdMosiUp()) : (AdMosiDown());
+ short_delay(2); // min. 30ns bevor die Flanke hochgeht
+ AdSckUp();
+ short_delay(2); // min. 50ns SCK high
+ }
+ while(mask >>= 1);
+// AdMosiUp();
+ Ad0CsUp();
+ Ad1CsUp();
+}
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+void Ad7739OutWrite(uint8_t b, int Wandler)
+{
+ uint8_t mask = 0x80;
+ AdSckUp();
+ if(Wandler == 0)
+ Ad0CsDown();
+ else
+ Ad1CsDown();
+ short_delay(2); // min. 50ns SCK low
+ do
+ {
+ AdSckDown();
+ short_delay(2); // min. 50ns SCK low
+ (b & mask) ? (AdMosiUp()) : (AdMosiDown());
+ short_delay(2); // min. 30ns bevor die Flanke hochgeht
+ AdSckUp();
+ short_delay(2); // min. 50ns SCK high
+ }
+ while(mask >>= 1);
+ Ad0CsUp();
+ Ad1CsUp();
+ AdMosiDown();
+}
+/*-------------------------------------------------------------------------------
+Startet einen einzelnen A/D Wandler. Wenn Mode = 0, dann single Mode, wenn Mode
+= 1, dann continous Mode.
+-------------------------------------------------------------------------------*/
+void Ad7739Start(uint8_t Chn, uint8_t Wandler, uint8_t Mode)
+{
+
+ if(Mode == 0) // Single Mode
+ {
+ Ad7739OutWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_MODE, Chn)), Wandler);
+ Ad7739OutWrite(0x42, Wandler); // 0x26 ist continous mode
+ }
+ else // continuous
+ {
+ Ad7739OutWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_MODE, Chn)), Wandler);
+ Ad7739OutWrite(0x2E, Wandler); // 0x26 ist continous mode0x08=Dump Mode, 0x04: Continous Read
+ Ad7739OutWrite(0x48, Wandler); // the first write of 48 start the continous read mode
+// g_nIRead = 0;
+ AdMosiDown(); // muss unten sein, da sonst der Continous Mode gestoppt werden kann
+
+ }
+ __enable_irq(); // 2017-05-31
+
+}
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+void Ad7739CommonStart(uint8_t Chn, uint8_t Mode)
+{
+ if(Mode == 0) // Single Mode
+ {
+ Ad7739CommonWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_MODE,Chn)));
+ Ad7739CommonWrite(0x42); // 0x26 ist continous mode
+ }
+ else // continuous
+ {
+ Ad7739CommonWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_MODE, Chn)));
+ Ad7739CommonWrite(0x2E); // 0x26 ist continous mode
+ Ad7739CommonWrite(0x48); // 0x26 ist continous mode
+ }
+
+ g_fAdConversion = true; // 2017-05-31
+ __enable_irq(); // 2017-05-31
+
+}
+
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+void Ad7739Stop(void)
+{
+ // single
+ /* return; */
+
+ // continous
+ Ad7739CommonWrite(AD7739_WRITE_OP(AD7739_ADDR_MODE));
+ Ad7739CommonWrite(0x02);
+
+ g_fAdConversion = false; // 2017-05-31
+ __enable_irq(); // 2017-05-31
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/AdGlobals.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,142 @@ +/*------------------------------------------------------------------------------- +Programm Name: AdGlobals.h +Version: 1.0 +Sprache: C++ +Compiler: mbed +Autor: PS +Copyright: PS + + +Funktion: Globale Variablen für den A/D Wandlerzugriff + +30.06.2017: + +-------------------------------------------------------------------------------*/ + +/* +#define _nop_() +( + asm nop +) +*/ + +// Makros zum lesen des A/D Wandlers +//----------------------------------- +#define Ad0CsUp() (GPIOB->PSOR |= 0x00000008) // PTB3 +#define Ad0CsDown() (GPIOB->PCOR |= 0x00000008) +#define Ad1CsUp() (GPIOC->PSOR |= 0x00000100) // PTC8 +#define Ad1CsDown() (GPIOC->PCOR |= 0x00000100) + + + +#define AdSckUp() (GPIOC->PSOR |= 0x00000400) // PTC10 +#define AdSckDown() (GPIOC->PCOR |= 0x00000400) +#define AdMosiUp() (GPIOB->PSOR |= 0x00000800) // PTB11 +#define AdMosiDown() (GPIOB->PCOR |= 0x00000800) + +#define AdIsMisoUp() (GPIOC->PDIR & 0x000000800) // PTC11 + +// Rdy ist der Interrupt von AD7739 +#define Ad0IsRdyUp() (GPIOB->PDIR & 0x000000400) // PTB10 + +#define Ad1IsRdyUp() (GPIOC->PDIR & 0x000000200) // PTC9 + + + + +// I/O's für den A/D Wandler +//------------------------------------- +extern DigitalOut AdcSck; +extern DigitalIn AdcMiso; +extern DigitalOut AdcMosi; +extern InterruptIn AdcRdy0; +extern InterruptIn AdcRdy1; + +extern DigitalIn AdcReset; + +extern DigitalOut Adc0Cs; +extern DigitalOut Adc1Cs; + + + +// Globale Variablen +//------------------------------------- +extern uint8_t g_TempDelay; +extern uint8_t g_AReadTemp; +extern uint8_t g_nAdResultCount; + + +extern AD_VAL *AdVal; +extern UINT8 g_fARead[8]; +extern uint8_t g_nAdSetPos, g_nAdGetPos; +extern int g_nAdCount; +extern UINT32 m_AdTemp[8]; + + +extern bool g_fAdConversion; +extern bool g_fRdy0, g_fRdy1; + +// extern uint8_t m_AiMask, m_Rdy0Mask, m_Rdy1Mask, m_Rdy0Status, m_Rdy1Status; + + +// Funktionen aus AdCalculations.c +//------------------------------------- +extern int CalculateAdBaseValues(); +extern int CheckLimitValues(); +extern void InitBaseInputArray(); + + + +// Funktionen aus AdInit.c +//------------------------------------- +extern int InitSpiAd(void); +extern int AdIsRdyUp(int Chn); +extern void Ad7739Init(int EcmWinCall); // EcmWinCall == 1, wenn Aufruf durch EcmWin +extern void SetAdConversionTime(); +extern void InitAdValues(); +extern int ConnectIrq(void); +extern void AdReset(); +extern void DoAdReset(); + + +// Funktionen aus AdRead.cpp +//------------------------------------ +extern void Rdy0Fall(); +extern void Rdy1Fall(); +extern int AdReadChannels(uint8_t Chn, uint8_t Wandler, uint8_t MitStatus); +extern void AdInRead(int Chn); + + +// Funktionen aus AdGlobals.cpp +//------------------------------------ +extern void Ad7739CommonWrite(uint8_t b); +extern void Ad7739OutWrite(uint8_t b, int Wandler); +extern void Ad7739Start(uint8_t Chn, uint8_t Wandler, uint8_t Mode); +extern void Ad7739CommonStart(uint8_t No, uint8_t Mode); +extern void Ad7739Stop(void); + + +// Funktionen aus AdMember.c +//------------------------------------ +extern uint8_t ReadAdIoPortRegister(uint8_t Wandler); +extern uint8_t ReadAdRevisionRegister(uint8_t Wandler); +extern uint8_t ReadAdTestRegister(uint8_t Wandler); +extern uint8_t ReadAdStatusRegister(uint8_t Wandler); +extern uint8_t ReadAdCheckSumRegister(uint8_t Wandler); +extern uint8_t ReadAdZeroScaleRegister(uint8_t Wandler); +extern uint8_t ReadAdFullScaleRegister(uint8_t Wandler); +extern uint8_t ReadAdChnZeroScaleRegister(uint8_t Wandler); +extern uint8_t ReadAdChnFullScaleRegister(uint8_t Wandler); +extern uint8_t ReadAdChnStatusRegister(uint8_t Chn, uint8_t Wandler); +extern uint8_t ReadAdChnSetupRegister(uint8_t Wandler); +extern uint8_t ReadAdConvTimeRegister(uint8_t Wandler); +extern uint8_t ReadAdChnModeRegister(uint8_t Wandler); +extern uint8_t ReadAd0Ad1In(int n); + + + + + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/AdInit.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,314 @@
+/*-------------------------------------------------------------------------------
+Programm Name: AdInit.cpp
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Init-Funktion für den A/D Wandlerzugriff
+
+30.06.2017:
+
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+bool fChnValid[8];
+
+
+/*-------------------------------------------------------------------------------
+Analog-Digital Konverter initialisieren
+-------------------------------------------------------------------------------*/
+void InitAdValues()
+{
+ int i,j;
+
+ AdVal = new (AD_VAL);
+ for(i=0;i<ANZ_POT*4;i++)
+ {
+ g_fARead[i] = false;
+ MVars.dbAdSum[i] = 0.;
+ for(j=0;j<16;j++)
+ {
+ AdVal->AdResult[i][j] = 0.0;
+ }
+ }
+ for(i=0;i<ANZ_POT*4;i++)
+ {
+ for(j=0;j<64;j++)
+ AdVal->AdRingBuf[i][j] = 0L;
+ }
+ g_nAdSetPos = 0;
+ g_nAdGetPos = 0;
+ g_nAdCount = 0;
+
+ g_nAdResultCount = 0;
+
+ AdVal->FKoeff[0] = -0.7128E-3;
+ AdVal->FKoeff[1] = 0.01879;
+ AdVal->FKoeff[2] = 0.06321;
+ AdVal->FKoeff[3] = 0.125;
+ AdVal->FKoeff[4] = 0.1806;
+ AdVal->FKoeff[5] = 0.20305;
+ AdVal->FKoeff[6] = 0.1806;
+ AdVal->FKoeff[7] = 0.125;
+ AdVal->FKoeff[8] = 0.06321;
+ AdVal->FKoeff[9] = 0.01879;
+ AdVal->FKoeff[10] = -0.7128E-3;
+
+ AdVal->nStartFk = 11;
+ AdVal->nEndeFk = 5;
+
+ AdVal->dbUNoiseGainFaktor = 0.1;
+ AdVal->dbINoiseGainFaktor = 1.0;
+
+ MVars.AdConvTime = 0x7F; // Startwert, längste Wandlungszeit ohne Chop Mode 0x80 ist Chopper
+}
+
+
+/*-------------------------------------------------------------------------------
+Interrupt für den A/D Wandler einrichten. InterruptIn AdcRdy(PTB10) liegt hier
+auf PTB10, muss je nach Hardware angepasst werden
+-------------------------------------------------------------------------------*/
+int InitSpiAd(void)
+{
+ Adc0Cs = true;
+ Adc1Cs = true;
+
+ AdcRdy0.mode(PullUp);
+ AdcRdy1.mode(PullUp);
+
+ Ad0CsUp();
+ AdSckUp();
+ printf("Nach Set Irq's\n");
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+Interrupt für den A/D Wandler einrichten. InterruptIn AdcRdy(PTB10) liegt hier
+auf PTB10, muss je nach Hardware angepasst werden
+-------------------------------------------------------------------------------*/
+int ConnectIrq(void)
+{
+ AdcRdy0.fall(&Rdy0Fall);
+ AdcRdy1.fall(&Rdy1Fall);
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+void AdReset()
+{
+// macht einen kompletten Reset auf den Wandler
+ DoAdReset();
+ printf("Nach AdReset CommonWrite Hex 00\n");
+
+ wait(2.0);
+
+}
+/*-------------------------------------------------------------------------------
+Macht einen Reset des A/D Wandlers
+-------------------------------------------------------------------------------*/
+void DoAdReset()
+{
+ int i;
+
+ AdSckUp();
+ AdMosiDown();
+ Ad0CsDown();
+ Ad1CsDown();
+ short_delay(2);
+
+ for(i=0;i<8;i++)
+ {
+ AdSckDown();
+ short_delay(2); // min. 50ns SCK low
+ AdSckUp();
+ short_delay(2); // min. 50ns SCK high
+ }
+ AdMosiUp();
+ for(i=0;i<32;i++)
+ {
+ AdSckDown();
+ short_delay(2); // min. 50ns SCK low
+ AdSckUp();
+ short_delay(2); // min. 50ns SCK high
+ }
+ Ad0CsUp();
+ Ad1CsUp();
+}
+
+/*-------------------------------------------------------------------------------
+// Rdy ist der Interrupt von AD7734
+#define Ad0IsRdyUp() (GPIOB_PDIR & 0x000000400)
+-------------------------------------------------------------------------------*/
+int AdIsRdyUp(int Chn)
+{
+ if(Chn == 0)
+ return(Ad0IsRdyUp());
+ else
+ return(Ad1IsRdyUp());
+}
+
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+void Ad7739Init(int EcmWinCall)
+{
+ // Power on Reset
+ uint8_t i, j;
+
+ for(i=0;i<8;i++)
+ fChnValid[i] = false;
+
+
+
+
+// Conversiontime zuerst setzen, da dies auf die Kalibrierzeiten wirkt
+ SetAdConversionTime();
+
+// die ersten vier Kanäle sind aktiv
+ for(i=0;i<3;i++)
+ {
+ fChnValid[i] = true;
+ MVars.m_fChnValid[i] = true;
+ }
+
+#ifdef SIO_DEBUG
+ STemp[0] = 0x00;
+ for(i=0;i<8;i++)
+ {
+ sprintf(SDebug, "Chn%d: %d", i, fChnValid[i]);
+ strcat(STemp, SDebug);
+ }
+ printf("%s \r\n",STemp);
+#endif
+
+ ReadAdRevisionRegister(0);
+ ReadAdRevisionRegister(1);
+
+// Self Calibration
+ for(i=0;i<2;i++)
+ {
+ Ad7739OutWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_MODE, 0)),i); //Mode Register 0x38
+ Ad7739OutWrite(0x82,i); // ADC Zero-Scale schreibt nur in das erste, das genuegt
+ nMyTimer = 0;
+ while( (AdIsRdyUp(i) && (nMyTimer < 2000))); // && Ad1IsRdyUp());
+ if(nMyTimer >=2000)
+ printf("Self Calibration finish on Timer \r\n");
+
+ }
+/*
+#ifdef SIO_DEBUG
+ printf("Nach SelfCalibration %d\r\n", nMyTimer);
+#endif
+ Status0 = ReadAdStatusRegister(0);
+ Status1 = ReadAdStatusRegister(1);
+#ifdef TFT_DEBUG
+ printf("St0: %d St1: %d \n", Status0, Status1);
+#endif
+*/
+
+// Fullscale Calibration
+ for(i = 0; i < 2; i++) // muss nur für die erste Adresse geschrieben werden gilt für acht Kanäle
+ {
+ Ad7739OutWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_MODE, 0)),i);
+ Ad7739OutWrite(0xA2,i); // ADC Full-Scale und 24 Bit
+ nMyTimer = 0;
+ while( (AdIsRdyUp(i) && (nMyTimer < 2000))); // && Ad1IsRdyUp());
+ if(nMyTimer >=2000)
+ printf("FullScale Calibration finish on Timer \r\n");
+ }
+/*
+#ifdef SIO_DEBUG
+ printf("Nach FullScaleCalibration %d\r\n", nMyTimer);
+#endif
+ Status0 = ReadAdStatusRegister(0);
+ Status1 = ReadAdStatusRegister(1);
+#ifdef TFT_DEBUG
+ printf("St0: %d St1: %d \n", Status0, Status1);
+#endif
+*/
+
+//
+// Channel Setup Register 0x28 bis 0x2F
+
+// Schreiben des Channel Setup Registers 0x28 bis 0x2F
+// Bit 2 setzt den +-2,5V Bereich, Bit 3 enabled den Kanal, Bit 5 und Bit 6 setzen den Differential Mode
+// beide auf 0 heißt single ended
+
+
+
+ for(i=0;i<4;i++) // Wandler 0
+ {
+ Ad7739OutWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_C_SET, i)),0); // Geht an Wandler Diff Mode AI0
+ Ad7739OutWrite(0x08,0); // 08 = +- 10V, 0A = +- 5V
+ nMyTimer = 0;
+ while( (AdIsRdyUp(0) && (nMyTimer < 2000))); // && Ad1IsRdyUp());
+ if(nMyTimer >=2000)
+ printf("ADC0 active and Range on Timer \r\n");
+ short_delay(10);
+ }
+ for(i=0;i<4;i++) // Wandler 1
+ {
+ Ad7739OutWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_C_SET, i)),1); // Geht an Wandler Diff Mode AI0
+ Ad7739OutWrite(0x00,1); // 08 = +- 10V, 0A = +- 5V, zweiter Wandler wird nicht gebraucht
+ nMyTimer = 0;
+ while( (AdIsRdyUp(1) && (nMyTimer < 2000))); // && Ad1IsRdyUp());
+ short_delay(10);
+ if(nMyTimer >=2000)
+ printf("ADC1 active and Range on Timer \r\n");
+ }
+
+ printf("Nach Setup AD 1 %d\r\n", nMyTimer);
+
+
+
+// IO Register
+ for(j=0;j<2;j++)
+ {
+ Ad7739OutWrite(AD7739_WRITE_OP(AD7739_ADDR_IO),j);
+ Ad7739OutWrite(0x30,j); // 0x08 sagt, daß der Ready Pin low geht, wenn alle Kanäle konvertiert sind
+ }
+ printf("Nach IO Register \r\n");
+
+ AdSckUp();
+ AdMosiDown();
+
+ ReadAdIoPortRegister(0);
+ ReadAdIoPortRegister(1);
+ ReadAdRevisionRegister(0);
+ ReadAdRevisionRegister(1);
+
+ ReadAdTestRegister(0);
+
+ ReadAdChnZeroScaleRegister(0);
+ ReadAdChnZeroScaleRegister(1);
+
+
+/* while(true)
+ {
+ AdReadChannels(0,0,0); // Kanal, Wandler, ohne/mit Status
+ AdReadChannels(0,1,0); // Kanal, Wandler, ohne/mit Status
+ }
+*/
+}
+/*-------------------------------------------------------------------------------
+Setzt die Wandlungszeit für die A/D Wandler
+-------------------------------------------------------------------------------*/
+void SetAdConversionTime()
+{
+ int i;
+ uint8_t AdConversionTime;
+
+
+// Wandlungszeit FF bedeutet Chopper ist an und 7F ist dei max. Wandlungszeit
+// Die minimale Wandlungszeit ist 0x02, d.h. mit Chopper ist es 0x82, ohne 0x02
+// AdConversionTime = MVars.AdConvTime;
+ AdConversionTime = 0x7F;
+ for(i = 0; i < 4; i++)
+ {
+ Ad7739CommonWrite(AD7739_WRITE_OP(AD7739_CHANNEL(AD7739_ADDR_C_CT, i))); //0x30 conversion time
+ Ad7739CommonWrite(AdConversionTime);
+// ReadAdConvTimeRegister();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/AdMember.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,179 @@
+/*-------------------------------------------------------------------------------
+Programm Name: AdMember.C
+Version: 1.0
+Sprache: C
+Compiler: CrossStudio Ver. 2.0
+Autor: PS
+Copyright: PS
+
+
+Funktion: Member-Funktion für den A/D Wandlerzugriff
+
+28.10.2012:
+
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+// uint8_t Ch1[8], Ch2[8];
+
+extern uint8_t ReadAd0In(int n);
+extern uint8_t ReadAd1In(int n);
+
+
+/*-------------------------------------------------------------------------------
+Liest das IO Register beider AD's
+-------------------------------------------------------------------------------*/
+uint8_t ReadAdIoPortRegister(uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_IO), Wandler); // 0x41 lesen des I/O Portregisters
+ {
+ AdInRead(Wandler);
+ return(g_AReadTemp);
+ }
+}
+uint8_t ReadAdRevisionRegister(uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_REV), Wandler); // 0x42
+ {
+ AdInRead(Wandler);
+ return(g_AReadTemp);
+ }
+}
+uint8_t ReadAdTestRegister(uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_TEST), Wandler); // 0x43
+ ReadAd0Ad1In(3);
+ return(true);
+}
+uint8_t ReadAdStatusRegister(uint8_t Wandler) // wird von Main aufgerufen
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_STATUS), Wandler); // 0x44
+ {
+ AdInRead(Wandler);
+ return(g_AReadTemp);
+ }
+}
+uint8_t ReadAdCheckSumRegister(uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_CHKSUM), Wandler); // 0x45
+ ReadAd0Ad1In(2);
+ return(true);
+}
+uint8_t ReadAdZeroScaleRegister(uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_ZS_CAL), Wandler); // 0x46
+ ReadAd0Ad1In(3);
+ return(true);
+}
+uint8_t ReadAdFullScaleRegister(uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_FS_CAL), Wandler); // 0x47
+ ReadAd0Ad1In(3);
+ return(true);
+}
+uint8_t ReadAdChnZeroScaleRegister(uint8_t Wandler)
+{
+ int i;
+
+ for(i = 0; i < 4; i++)
+ {
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_C_ZS | i), 0); // 0x50-57
+ ReadAd0In(3);
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_C_ZS | i), 1); // 0x50-57
+ ReadAd1In(3);
+#ifdef SINGLE_DEBUG
+ printf("Wandler 1: %02X %02X %02X\n",g_ReadReg[0], g_ReadReg[1], g_ReadReg[2]); // Parameter ist egal, liest sowieso beide
+ printf("Wandler 2: %02X %02X %02X\n",g_ReadReg[4], g_ReadReg[5], g_ReadReg[6]); // Parameter ist egal, liest sowieso beide
+#endif
+ }
+ return(true);
+}
+uint8_t ReadAdChnFullScaleRegister(uint8_t Wandler)
+{
+ int i;
+
+ for(i = 0; i < 8; i++)
+ {
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_C_FS | i), Wandler); // 0x58 - 5F
+ ReadAd0Ad1In(3);
+ }
+ return(true);
+}
+
+uint8_t ReadAdChnStatusRegister(uint8_t Chn, uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_CHANNEL(AD7739_ADDR_C_STAT, Chn)), Wandler); // 0x60 - 67
+ {
+ AdInRead(Wandler);
+ return(g_AReadTemp);
+ }
+}
+uint8_t ReadAdChnSetupRegister(uint8_t Wandler)
+{
+ int i;
+
+ for(i = 0; i < 8; i++)
+ {
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_C_SET | i), Wandler); // 0x68 - 6F
+ ReadAd0Ad1In(1);
+ }
+ return(true);
+}
+uint8_t ReadAdConvTimeRegister(uint8_t Wandler)
+{
+ int i;
+
+ for(i = 0; i < 8; i++)
+ {
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_C_CT | i), Wandler); // 0x70 - 77
+ ReadAd0Ad1In(1);
+ }
+ return(true);
+}
+uint8_t ReadAdChnModeRegister(uint8_t Wandler)
+{
+ Ad7739OutWrite(AD7739_READ_OP(AD7739_ADDR_MODE), Wandler); // 0x70 - 77
+ ReadAd0Ad1In(1);
+ return(true);
+}
+
+uint8_t ReadAd0In(int n)
+{
+ int i;
+
+ for(i=0;i<n;i++)
+ {
+ AdInRead(0); //
+ g_ReadReg[i] = g_AReadTemp;
+ }
+ return(true);
+}
+uint8_t ReadAd1In(int n)
+{
+ int i;
+
+ for(i=0;i<n;i++)
+ {
+ AdInRead(1); //
+ g_ReadReg[i+4] = g_AReadTemp;
+ }
+ return(true);
+}
+
+
+uint8_t ReadAd0Ad1In(int n)
+{
+ int i;
+
+ for(i=0;i<n;i++)
+ {
+ AdInRead(0); //
+ g_ReadReg[i] = g_AReadTemp;
+ }
+ for(i=0;i<n;i++)
+ {
+ AdInRead(1); //
+ g_ReadReg[i+4] = g_AReadTemp;
+ }
+ return(true);
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/AdRead.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,246 @@
+/*-------------------------------------------------------------------------------
+Programm Name: AdRead.cpp
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Lese-Funktion für den A/D Wandlerzugriff
+
+30.06.2017:
+
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+// Membervariablen, die nur in dieser Datei verwendet werden
+uint8_t m_AiMask, m_Rdy0Mask, m_Rdy1Mask, m_RdyStatus[8];
+
+int g_nDelCount;
+uint8_t AdcA0V1, AdcA0V2, AdcA0V3;
+
+long g_nChn1Counter = 0;
+long g_nChn2Counter = 0;
+long g_nFinishCounter = 0;
+
+uint16_t nTempCounter = 0;
+
+int g_Temp1, g_Temp2, g_Temp3, g_Temp4, g_Temp5, g_Temp6;
+
+Converter0 Conv0[2];
+
+uint8_t g_nIRead;
+
+int nStatusCounter = 0;
+
+bool g_fDisableDataRead;
+
+/*----------------- INTERRUPT SERVICE ROUTINES --------------------------*/
+
+void Rdy0Fall()
+{
+ __disable_irq();
+ g_fRdy0 = true;
+ Adc0ReadChn();
+ __enable_irq();
+}
+
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+void Rdy1Fall()
+{
+ __disable_irq();
+ g_fRdy1 = true;
+ Adc1ReadChn();
+ __enable_irq();
+}
+/*-------------------------------------------------------------------------------
+ReadConverter0: Lesen des ersten A/D Wandlers
+-------------------------------------------------------------------------------*/
+void ReadConverter0()
+{
+ unsigned char ChnStatus;
+
+ g_fRdy0 = false;
+ if(g_fDisableDataRead == true)
+ return;
+// m_Rdy0Status = ReadAdStatusRegister(0); // liest Statusregister von Wandler 0
+// m_Rdy0Mask = 0x01;
+ ChnStatus = Conv0[0].AdPart[3] >> 5;
+ if(ChnStatus >= 4) ChnStatus = 3;
+
+ Conv0[0].AdPart[3] = 0x00;
+ MVars.dbAdSum[ChnStatus] += Conv0[0].AdComplete;
+ MVars.nChnAverage[(int)ChnStatus]++;
+
+}
+/*-------------------------------------------------------------------------------
+ReadConverter0: Lesen des ersten A/D Wandlers
+Der zweite Wandler wird mit den Idexen 4-7 verarbeitet
+-------------------------------------------------------------------------------*/
+void ReadConverter1()
+{
+ unsigned char ChnStatus;
+
+ g_fRdy1 = false;
+ if(g_fDisableDataRead == true)
+ return;
+// m_Rdy0Status = ReadAdStatusRegister(0); // liest Statusregister von Wandler 0
+// m_Rdy0Mask = 0x01;
+ ChnStatus = Conv0[1].AdPart[3] >> 5;
+ if(ChnStatus >= 4) ChnStatus = 3;
+
+ Conv0[1].AdPart[3] = 0x00;
+ MVars.dbAdSum[ChnStatus *2 + 1] += Conv0[1].AdComplete;
+ MVars.nChnAverage[((int)ChnStatus + 4) + 1]++;
+
+}
+/*-------------------------------------------------------------------------------
+ CheckAnalogIn: Liest die Daten von den Wandlern
+-------------------------------------------------------------------------------*/
+int CheckAnalogIn()
+{
+ if(g_fRdy0 == true)
+ ReadConverter0();
+ if(g_fRdy1 == true)
+ ReadConverter1();
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+ CheckDaAd: Schreibt zum AD und liest den AD
+-------------------------------------------------------------------------------*/
+int CheckDaAd()
+{
+ int i,Ret;
+
+// ReadAllChannels(); wird schon im Main aufgerufen
+// In Grundstellung ist nAktMittelAfter=500, d.h. es wird über eine halbe Sekunde gemittelt
+// Im Messmode ist nAktMittelAfter auf einen Wert von z.B. 10 bei 100 Werten pro Sekunde
+ Ret = CalculateAdBaseValues();
+ if(Ret == false) // nicht alle Felder waren mit Werten gefüllt
+ {
+ g_nChn1Counter++;
+ g_nChn2Counter++;
+ if(g_nChn1Counter > 10)
+ {
+ Ad7739Stop(); // Erst mal stoppen, damit noch ein weiterer Zugriff passiert
+ Ad7739Start(0, 0,1); // neu starten
+ g_nChn1Counter = 0;
+ if(g_nChn2Counter >= 100 ) // hat 10 Mal versucht neu anzustossen
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#A/D-Converter did not answer. 10 times restart without access %c\r\n", STX, ETX); //
+ HostIf.fSendError = true;
+ }
+
+ }
+ return(false);
+ }
+ else
+ {
+ g_nChn1Counter = 0;
+ g_nChn2Counter = 0;
+ }
+
+ g_nChn1Counter = 0;
+// MVars.dbAdResult[g_nUChn[0]] = MVars.dbAdResult[g_nUChn[0]]; // - IrComp.dbKorrVoltage;
+// CheckLimitValues();
+
+ SendAnalogValues();
+
+ MVars.nMwMittelCount = 0;
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+int AdReadChannels(uint8_t Chn, uint8_t Wandler, uint8_t MitStatus)
+{
+// ab hier ist der gewandelte Wert einzulesen
+// #define AD7739_READ_OP(addr) (0x40 | addr) #define AD7739_CHANNEL(0x08, 0...3) (addr | ch) #define AD7739_ADDR_C_DATA 0x08
+// Ad7739OutWrite(AD7739_READ_OP(AD7739_CHANNEL(AD7739_ADDR_C_DATA, Chn)),Wandler); //0x48, die 0 legt die CS0 auf low
+
+// for(g_TempDelay = 0;g_TempDelay < 2; g_TempDelay++);
+ AdInRead(Wandler);
+ m_RdyStatus[Chn] = g_AReadTemp;
+ AdInRead(Wandler);
+ AdcA0V1 = g_AReadTemp;
+ AdInRead(Wandler);
+ AdcA0V2 = g_AReadTemp;
+ AdInRead(Wandler);
+ AdcA0V3 = g_AReadTemp;
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+Liest zuerst das Statusbyte und dann die Daten, welche in die Union Struktur gelesen werden
+-------------------------------------------------------------------------------*/
+int Adc0ReadChn()
+{
+ AdInRead(0);
+ Conv0[0].AdPart[3] = g_AReadTemp;
+ AdInRead(0);
+ Conv0[0].AdPart[2] = g_AReadTemp;
+ AdInRead(0);
+ Conv0[0].AdPart[1] = g_AReadTemp;
+ AdInRead(0);
+ Conv0[0].AdPart[0] = g_AReadTemp;
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+Liest zuerst das Statusbyte und dann die Daten, welche in die Union Struktur gelesen werden
+-------------------------------------------------------------------------------*/
+int Adc1ReadChn()
+{
+ AdInRead(1);
+ Conv0[1].AdPart[3] = g_AReadTemp;
+ AdInRead(1);
+ Conv0[1].AdPart[2] = g_AReadTemp;
+ AdInRead(1);
+ Conv0[1].AdPart[1] = g_AReadTemp;
+ AdInRead(1);
+ Conv0[1].AdPart[0] = g_AReadTemp;
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+//Liest das vorher selektierte Register des ersten A/D Wandler
+-------------------------------------------------------------------------------*/
+void AdInRead(int Wandler)
+{
+// core_util_critical_section_enter();
+ int i;
+
+ m_AiMask = 0x80;
+ g_AReadTemp = 0x00;
+
+ AdMosiDown(); // muss unten sein, da sonst der Continous Mode gestoppt werden kann
+ AdSckUp();
+
+ if(Wandler == 0)
+ {
+ Ad1CsUp();
+ Ad0CsDown();
+ }
+ else
+ {
+ Ad0CsUp();
+ Ad1CsDown();
+ }
+ for(g_TempDelay = 0;g_TempDelay < 2; g_TempDelay++);
+ for(i=0;i<8;i++)
+ {
+ AdSckDown();
+ for(g_TempDelay = 0;g_TempDelay < 2; g_TempDelay++);
+ if(AdIsMisoUp())
+ g_AReadTemp |= m_AiMask;
+ AdSckUp();
+ for(g_TempDelay = 0;g_TempDelay < 2; g_TempDelay++);
+ m_AiMask = (m_AiMask>>1);
+ }
+
+ Ad0CsUp();
+ Ad1CsUp();
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/AdRead.h Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------------
+Programm Name: AdRead.h
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+Funktion: Lese-Funktion für den A/D Wandlerzugriff
+
+-------------------------------------------------------------------------------*/
+union Converter0
+{
+ unsigned long AdComplete;
+ unsigned char AdPart[4];
+};
+
+extern bool g_fDisableDataRead;
+
+
+extern long g_nChn1Counter;
+extern long g_nChn2Counter;
+extern long g_nFinishCounter;
+
+
+extern void AdReset();
+
+
+extern int Adc0ReadChn();
+extern int Adc1ReadChn();
+
+extern void ReadConverter0();
+extern void ReadConverter1();
+
+extern int CheckAnalogIn();
+
+// Methoden aus AdCalculations
+//------------------------------------------
+extern void InitBaseInputArray();
+extern int CheckLimitValues();
+extern int CalculateAdBaseValues();
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/CalcScan.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,97 @@
+/*
+-------------------------------------------------------------------------------
+Programm Name: CalcScan.c
+Version: 1.0
+Sprache: C
+Compiler: MBED
+Autor: PS
+Copyright: PS
+
+Funktion: Steuerfunktionen für den Scanner (LPC1768)
+
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+/*-------------------------------------------------------------------------------
+Startwerte, die bei allen Startbefehlen gleich sind, auf Default setzten
+-------------------------------------------------------------------------------*/
+int SetStartBasics(int Nr)
+{
+ int i;
+
+ MVars.m_fDisableStopTel = false;
+ MVars.m_fFinishMeasurement = false;
+ MVars.m_fDoFinishMeasurement = false;
+ for(i=0;i<4;i++)
+ MVars.dbAdSum[i] = 0L;
+ MVars.nMwMittelCount = 0;
+ MVars.m_nSendValues = 2; // Messdaten kontinuierlich schicken
+ MVars.ZInfo[0] = 1;
+ MVars.ZInfo[1] = 1;
+ MVars.nAktMittelAfter = MVars.nMittelAfter; // nimmt jetzt das voreingstellte Intervall
+#ifdef SIO_DEBUG
+ printf("in SetStartBasics nAktMittelAfter: %d \n",MVars.nAktMittelAfter);
+#endif
+ if(MVars.nAktMittelAfter < 6) // bei 1000/500 und 200 Werten
+ MVars.nSendAfter = 5;
+ else
+ MVars.nSendAfter = 50;
+
+ if(MVars.nMittelAfter > 50) // wenn nur wenige Werte gesendet werden, genügt es alle 500ms
+ MVars.nSendAfter = 500;
+ MVars.m_nAnzValue = MVars.SendAnzWerte/2;
+
+
+ MVars.nTelLen = 0;
+
+ MVars.fTelStart = true;
+ MVars.nSecCounter[Nr] = 1000;
+ MVars.m_fSendStatus = true;
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+Diverse Startwerte auf Default setzten
+-------------------------------------------------------------------------------*/
+int SetStartDefault(int Nr)
+{
+ SetStartBasics(Nr);
+
+
+// gilt für Scan und Pulsmessung gleichermaßen
+ MVars.m_fScan = true;
+
+// MVars.nSecCounter[Nr] = 0;
+
+
+// printf("MVars.nAktMittelAfter:%d MVars.nSendAfter: %d \n",MVars.nAktMittelAfter,MVars.nSendAfter);
+ return true;
+}
+/*-------------------------------------------------------------------------------
+Messung beenden. Wird von irgend einem globalen Ereignis wie Watchdog oder
+Pufferüberlauf aufgerufen. Alles wird zurückgesetzt
+-------------------------------------------------------------------------------*/
+int SetMessungEnde()
+{
+
+ MVars.m_fDisableStopTel = false;
+ MVars.nMessZustand[0] = 0;
+ MVars.m_fSendStatus = true;
+ MVars.m_fMeasurementFinished = false;
+// MVars.m_fMeasurementFinished
+ MVars.nMittelTimer = 0;
+ MVars.m_nSendAnz = 0;
+ MVars.m_nSendValues = 1; // sendet Einzelwerte
+ MVars.m_fStartTel = 0x01;
+ IrComp.fSendInfo = false;
+ MVars.m_nAnzValue = 1;
+ MVars.nAktMittelAfter = 500;
+ MVars.nSendAfter = 500;
+ Mv[0].Circuit = 0;
+ Mv[1].Circuit = 0;
+ IrComp.dbIrAddVoltage = 0.;
+ IrComp.dbKorrVoltage = 0.;
+ IrComp.fIrInProcess = false;
+
+// printf("SetMessungEnde\r\n");
+ return(true);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/Chip1768.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,48 @@ +/* +------------------------------------------------------------------------------- +Programm Name: Chip1768.H +Version: 1.0 +Sprache: C +Compiler: MBED +Autor: PS +Copyright: PS + + +Funktion: Protoypen und Externdefinitionen fuers Projekt + +28.10.2012: + +-------------------------------------------------------------------------------*/ +// Defines fuer AD7739 +#define AD7739_ADDR_COM 0x00 +#define AD7739_ADDR_IO 0x01 +#define AD7739_ADDR_REV 0x02 +#define AD7739_ADDR_TEST 0x03 +#define AD7739_ADDR_STATUS 0x04 +#define AD7739_ADDR_CHKSUM 0x05 +#define AD7739_ADDR_ZS_CAL 0x06 +#define AD7739_ADDR_FS_CAL 0x07 +#define AD7739_ADDR_C_DATA 0x08 +#define AD7739_ADDR_C_ZS 0x10 +#define AD7739_ADDR_C_FS 0x18 +#define AD7739_ADDR_C_STAT 0x20 +#define AD7739_ADDR_C_SET 0x28 +#define AD7739_ADDR_C_CT 0x30 +#define AD7739_ADDR_MODE 0x38 + +#define AD7739_READ_OP(addr) (0x40 | addr) +#define AD7739_WRITE_OP(addr) (addr) +#define AD7739_CHANNEL(addr, ch) (addr | ch) + + + + + + + + + + +// Funktionen aus NetIo.c +extern int InitEthernet(); +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/Dio.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,493 @@
+/*
+-------------------------------------------------------------------------------
+Programm Name: Dio.CPP
+Version: 1.0
+Sprache: C
+Compiler: MBED
+Autor: PS
+Copyright: PS
+
+
+Funktion: Digital In/Out auf LPC1768
+
+Modified:
+
+2016-06 UFa: Aenderungen aufgrund HW-Revision:
+ a) Anpassungen in Fkt "SetIRange"
+ b) Neue Funktionen (ersetzen z.T. entsp. Macros)
+ - SetWe()
+ - GeIstGe()
+ - ClearWeSchirm()
+ - SquareOffsetDown()
+
+-------------------------------------------------------------------------------
+*/
+#include "Headers.h"
+
+//#define Spi0IsMisoUp() (LPC_GPIOA->FIOPIN & 0x00020000)
+//#define Spi0IsMisoDown() (LPC_GPIOA->FIOPIN & ~0x00020000)
+
+BYTE Port;
+#ifdef PGU_EDUCATION
+DigitalOut SwPot(PTB20);
+DigitalOut SwGal(PTC10);
+DigitalOut SwGe(PTC11);
+#endif
+DigitalOut DoStatusLed(PTA1);
+
+
+/*-------------------------------------------------------------------------------
+Initialisieren der Schaltkontakte
+-------------------------------------------------------------------------------*/
+int InitDio(void)
+{
+
+
+#ifdef TOUCH_DISPLAY
+ TftDisp.nTagVWriteCounter = 0;
+ TftDisp.nTagVReadCounter = 0;
+ g_fInCalibrationMode = false;
+#endif
+
+#ifndef PGU_RPA
+ g_fCheckSpecial = false;
+ g_fSpzFktSwitchIRange = false;
+ g_fSpzFktSwitchNoiseGain = false;
+
+ Setk(4,0);
+ Setk(5,0);
+
+ printf("Now SwitchRanges.\n");
+
+ SwitchRangesOnStart();
+ printf("Now SetIRange.\n");
+ SetIRange(0,0);
+#endif
+#ifdef PGU_TOUCH
+ SetWe(0x00); //PS 10.12.16 ClearWe entfällt, es wird einfach der Bereich 0 für die WE gesetzt, damit ist die WE1 aktiv
+ SetGe(0);
+ SetWeSchirm(1); // auf 1 damit die Leitung offen ist und keinen Fehler verursacht
+
+ SetSinGainDefault(); // setzt die Verstärker auf Defaultwerte
+ SetNoiseGainDefault(); // damit werden auch die Cs Signale auf Default gesetzt
+
+ SetSquareOffset(0); // Setzt den Offset für Sinuns und Dreieck
+
+ SinGenOff(); // Setzt den AD9833 auf Reset und den Cs auf high
+#endif
+
+ printf("Now Return.\n");
+ return(true);
+}
+/****************************************************************
+ * SetNoiseGainDefault:
+ *
+ * Setzt die Rauschverstärker Defaultwert. Default ist hier der
+ größte Wert, damit wird das Signal am Ausgang minimal. Je größer der
+ Wert vom X9C103, desto kleiner die Amplitude vom Sinus.
+ Die Position vom X9C103 ist 100, der Index von den Verstärkungsfaktoren
+ ist 0
+ ****************************************************************/
+int SetNoiseGainDefault()
+{
+ int i;
+
+#ifdef ECN
+ SwHpZero = true; // erst mal kurzschließen, damit der nicht so ausschlägt
+ CsUNoiseGain = false;
+ CsINoiseGain = false;
+ DpUpDown = true;
+ short_delay(50); // !!! die short_delay auf keinem Fall entfernen. Es hat sich bei einer
+
+ for(i=0;i<=100;i++)
+ {
+ DpIncrement = false;
+ short_delay(20); // !!! die short_delay auf keinem Fall entfernen. Es hat sich bei einer
+ DpIncrement = true;
+ short_delay(20); // !!! die short_delay auf keinem Fall entfernen. Es hat sich bei einer
+ }
+ GCount.nUNoisePos = 100;
+ GCount.nINoisePos = 100;
+ GCount.nUnGainItem = 0;
+ GCount.nInGainItem = 0;
+
+ CsUNoiseGain = true;
+ CsINoiseGain = true;
+#endif
+ return(true);
+}
+/****************************************************************
+ * SetSinGainDefault:
+ *
+ * Setzt den Signalverstärker für Sinus auf Default. Default ist hier der
+ kleinste Wert, damit wird das Signal am Ausgang minimal. Je kleiner der
+ Wert vom X9C103, desto kleiner die Amplitude vom Sinus.
+ Die Position vom X9C103 ist 1, der Index von den Verstärkungsfaktoren
+ ist 4
+ ****************************************************************/
+int SetSinGainDefault()
+{
+ int i;
+
+#ifdef SINE_GEN
+ CsSinGain = false;
+ DpUpDown = false;
+ short_delay(50); // !!! die short_delay auf keinem Fall entfernen. Es hat sich bei einer
+
+ for(i=0;i<=100;i++)
+ {
+ DpIncrement = false;
+ short_delay(20); // !!! die short_delay auf keinem Fall entfernen. Es hat sich bei einer
+ DpIncrement = true;
+ short_delay(20); // !!! die short_delay auf keinem Fall entfernen. Es hat sich bei einer
+ }
+ GCount.nSinGainPos = 1;
+ GCount.nSinGainItem = 4;
+
+ CsSinGain = true;
+#endif
+ return(true);
+}
+
+/****************************************************************
+ * ReadInput
+ *
+ * Liest das Inputbit des Tasters
+ ****************************************************************/
+int ReadInput()
+{
+/* if(Spi0IsMisoUp())
+ if(ExtStart)
+ return true; //
+ else */
+ return false;
+}
+/****************************************************************
+ * SetBaVariablen:
+ * Wird von SetK aufgerufen und setzt die Variablen Mv[i].Circuit und Mv[i].BetriebsArt
+ * damit andeer Programmstellen wissen in welchem Mode die Kiste ist.
+ ****************************************************************/
+int SetBaVariablen(int Nr, bool Level)
+{
+
+ if(Nr == MVars.SwitchChn[0]) // 0=1. IZelle, 1= 1. PotGal, 2=2. IZelle, 3=2. PotGal
+ {
+ if(Level == HIGH)
+ Mv[0].Circuit = 1;
+ else
+ Mv[0].Circuit = 0;
+ }
+ if(Nr == MVars.SwitchChn[1]) // 0=1. IZelle, 1= 1. PotGal, 2=2. IZelle, 3=2. PotGal
+ {
+ if(Level == HIGH)
+ Mv[0].BetriebsArt = 1;
+ else
+ Mv[0].BetriebsArt = 0;
+ }
+ return(true);
+}
+
+
+/****************************************************************
+ * Setk
+ *
+ * Setzten eines Kontaktes. Die Betriebsart und Circuit wird hier auch gesetzt
+ ****************************************************************/
+int Setk(int Nr, bool Level)
+{
+// uint8_t mask = 0x80;
+
+#ifdef PGU_EDUCATION
+// uint8_t mask = 0x80;
+ SetBaVariablen(Nr, Level);
+ if(Nr == 4) // I-Zelle
+ SwGe = Level;
+ else if(Nr == 5)
+ {
+ if(Level == false)
+ {
+ SwPot = true;
+ SwGal = false;
+ }
+ else // if(Level == false)
+ {
+ SwPot = false;
+ SwGal = true;
+ }
+ }
+#endif
+#ifdef PGU_POTI // wenn ein Potentiostat angeschlossen ist
+ if(Nr == MVars.SwitchChn[0]) // 0=1. IZelle, 1= 1. PotGal, 2=2. IZelle, 3=2. PotGal
+ {
+ if(Level == HIGH)
+ {
+ g_nSendDisableTimer = 1000;
+ SetSwitchHpZero(0);
+ Mv[0].Circuit = 1;
+ SkIzUp();
+ if(IRange.AutoRange[0] < 2)
+ {
+ IRange.m_fCheckRange = true;
+ }
+ nSwitchDownCount[0] = EcmIni.DelayAfterSwitchUp; // beim Rauschen deutlich laenger
+ }
+ else
+ {
+ IRange.m_fCheckRange = false;
+ Mv[0].Circuit = 0;
+ SkIzDown();
+ }
+ }
+ if(Nr == MVars.SwitchChn[1]) // 0=1. IZelle, 1= 1. PotGal, 2=2. IZelle, 3=2. PotGal
+ {
+
+ if(Level == HIGH)
+ {
+ Mv[0].BetriebsArt = 1;
+ PotGalUp();
+ }
+ else
+ {
+ Mv[0].BetriebsArt = 0;
+ PotGalDown();
+ }
+ }
+#endif
+ return(true);
+
+}
+/****************************************************************
+SetSwHpZero
+
+Schaltet die Eingänge der Rauschverstärker auf Null, damit eine
+Impuls durch das Umschalten eines Bereiches nicht den Hochpass
+ausstuert
+****************************************************************/
+void SetSwitchHpZero(int nType)
+{
+#ifdef ECN
+ g_fCheckSpecial = true;
+ if(nType == 0) // IRange Umschaltung
+ {
+ SwHpZero = true;
+ g_nSpzFktSwitchIRange = 2; // 2 steht für 500ms
+ g_fSpzFktSwitchIRange = true;
+ g_nSpzFktSwitchNoiseGain = 10; // 1/2Sekunde
+ g_fSpzFktSwitchNoiseGain = true;
+ }
+ else if(nType == 1) // Noise Gain Umschaltung
+ {
+// g_nSpzFktSwitchNoiseGain = 50; // 1.5 Sekunde
+// g_fSpzFktSwitchNoiseGain = true;
+ }
+#endif
+}
+
+/****************************************************************
+ * WriteToRefPort
+ *
+ Schreibt SPI Daten an das Schieberegister über CsRef
+****************************************************************/
+void WriteToSpiPort(unsigned char Pt)
+{
+ uint8_t mask = 0x80;
+ uint8_t i;
+ Port = Pt;
+
+ for(i=0;i<8;i++)
+ {
+ DaSckDown();
+ g_nDelayCounter = 1;
+ g_nDelayCounter = 2;
+ g_nDelayCounter = 3;
+ g_nDelayCounter = 4;
+ if((Port & mask) == mask)
+ DaMosiUp();
+ else
+ DaMosiDown();
+ g_nDelayCounter = 1;
+ g_nDelayCounter = 2;
+ g_nDelayCounter = 3;
+ g_nDelayCounter = 4;
+ DaSckUp();
+ g_nDelayCounter = 1;
+ g_nDelayCounter = 2;
+ g_nDelayCounter = 5;
+ g_nDelayCounter = 6;
+ mask = (mask >> 1);
+ }
+}
+
+/*-------------------------------------------------------------------------------
+ChangeMittelValue: Ändert den Mittelwert und alles drumherum
+-------------------------------------------------------------------------------*/
+int ChangeMittelValue()
+{
+ m_fChangeMittelValue = false;
+ MVars.nMwMittelVal = MVars.m_nStoreMwIntervall; // nimmt jetzt das voreingstellte Intervall
+ MVars.nMwPerBlock = NsRate.nNewSendeRate / 2;
+// printf("Neuer Mittelwert: %d Neuer Blockwert: %d\n",MVars.nMwMittelVal,MVars.nMwPerBlock);
+ m_fFallBack = NsRate.fFallBack;
+ nFallBackCounter = 0;
+#ifdef PGU_POTI
+ if(NsRate.nNewAutoRange < 3)
+ {
+ if(NsRate.nNewAutoRange != IRange.AutoRange[0])
+ {
+ NsRate.nOldAutoRange = IRange.AutoRange[0];
+ IRange.AutoRange[0] = NsRate.nNewAutoRange;
+ }
+ }
+ if(NsRate.nNewRange != -1)
+ {
+ IRange.AktRange[0] = NsRate.nNewRange;
+ SetIRange(0,IRange.AktRange[0]);
+ }
+#endif
+ return(true);
+}
+/****************************************************************
+ * SetWe
+ *
+ * Setzen verschied. WorkingElektroden
+ *
+ * WeSelect wäre & 0xE7 löscht die beiden Eingänge des Multiplexers und
+ setzt damit die WE 1 und | 0x18 setzt beide Eingänge auf high, das wäre die WE 4
+***************************************************************/
+
+void SetWe(UINT8 WeRange)
+{
+#ifdef PGU_TOUCH
+ UINT8 Range;
+ Range = WeRange;
+
+ ReInitPtc16_17();
+ CsCurrentDown(); // low aktiv
+#if defined REV_1B || defined REV_1D
+ MVars.nCurrentPort &= 0xE7;
+#else
+ MVars.nCurrentPort &= 0xCF; // ist jetzt auf Bit 4 und Bit 5
+#endif
+ MVars.nCurrentPort |= Range;
+ WriteToSpiPort(MVars.nCurrentPort);
+ CsCurrentUp(); // low aktiv
+#endif
+}
+
+
+
+/****************************************************************
+ * GeIstGe
+ *
+ *
+***************************************************************/
+
+void SetGe(UINT8 State)
+{
+ UINT8 Value;
+/* Schaltet den Ausgang GE auf den Schirm der WE. Das Signal WeSchirm hat nun den
+ Ausgang Gegenelektrode. Solange wie SwWeSchirm auf Low, hat das keinen Effekt
+ ist WeSchirm auf High, dann wird die Klemme, welche den WeSchirm nach aussen bringt,
+ auf die Ge geschaltet.
+ D.h. LPR mit CoulCount Sensor bedeutet:
+ SetGe(1); (SwGeWeSchirm auf high)
+ SwWeSchirm(1) (SwWeSchirm auf high)
+ Für CoulCount muss SwWeSchirm(0) gesetzt werden, sonst liegt der Schirm nicht auf GND
+
+ */
+#ifdef PGU_TOUCH
+
+ ReInitPtc16_17();
+ CsCurrentDown(); // low aktiv
+ #if defined REV_1B || defined REV_1D
+ MVars.nCurrentPort &= 0xBF;
+ #else
+ MVars.nCurrentPort &= 0x7F;
+ #endif
+ if(State == 1)
+ {
+ #if defined REV_1B || defined REV_1D
+ Value = 0x40;
+ #else
+ Value = 0x80;
+ #endif
+ MVars.nCurrentPort |= Value;
+ }
+ WriteToSpiPort(MVars.nCurrentPort);
+ CsCurrentUp(); // low aktiv
+#endif
+}
+
+/****************************************************************
+ * ClearWeSchirm
+ * Um den Ausgang des Summierverstärkers über IZelle auf die Gegenelektrode zu schalten,
+ muss SwGeWeSchirm auf Low sein.
+ Der Anschluss WeSchirm (Klemme K4 nach aussen) liegt auf GND, wenn SwWeSchirm auf Low ist. Damit
+ wirkt der Anschluss entweder als zusätzlicher Schirm oder er kann für die zweite Elektrode zur Strommessung verwendet
+ werden. Soll eine außenstromlose Messung mit zwei WE durchgeführt werden, dann ist SwWeSchirm vor der Messung auf high zu halten.
+ Entsprechend ist SwGeWeSchirm auf low zu halten, da sonst der Anschluss auf die Gegenelektrode gehen könnte (aber nur, wenn
+ SwIZelle = high, sonst hängt der Eingang in der Luft (soll er auch damit kein Strom fließt).
+
+ Ist SwWeSchirm auf High, dann ist der Eingang der WE-S zunächt offen, es sei denn, SwGeWeSchirm ist auch high. Dann ist die zweite
+ WE als GE geschaltet.
+ 1. Die Gegenelektrode ist ganz normal an dem Ausgang des Summierverstärkers: SwGeWeSchirm ist auf low, SwWeSchirm auch low.
+ WeSchirm liegt auf GND. Ist eine Elektrode angeschlossen und eingetaucht, dann fließt sofort ein Kurzschlussstrom.
+2. Die zweite WE ist offen (SwWeSchirm = high). Dann kann sie als Gegenelektrode genutzt werden, wenn SwGeWeSchirm auch auf high ist,
+ muss aber nicht.
+Einstellungen für CoulCount:
+- Vor Beginn der Messung muss SwWeSchirm auf high sein, damit der Anschluss offen ist. SwGeWeSchirm ist low, damit die Gegenelektrode da nicht
+ dran kann.
+ Wird die Messung gestartet, dann wird SwWeSchirm auf Low geschaltet. Damit wird der Strommesskreis kurzgeschlossen.
+Einstellungen für LPR:
+- Wird der gleiche Sensor wie für CoulCount auch für LPR genommen, dann ist SwWeSchirm und SwGeWeSchirm auf high zu schalten.
+ Mit Beginn des Polarisierens wird IZelle auf high gesetzt, damit wird die zweite WE des Sensors als GE geschaltet.
+
+ *
+***************************************************************/
+void SetWeSchirm(UINT8 State)
+{
+#ifdef PGU_TOUCH
+ UINT8 Value;
+// if State == low ZRA Messung, SwWeSchirm auf low
+
+ ReInitPtc16_17();
+ CsCurrentDown(); // low aktiv
+ #if defined REV_1B || defined REV_1D
+ MVars.nCurrentPort &= 0xDF;
+ #else
+ MVars.nCurrentPort &= 0xBF;
+ #endif
+ if(State == 1) // wird auf GE geschaltet, WE ist GE /
+ {
+ #if defined REV_1B || defined REV_1D
+ Value = 0x20;
+ #else
+ Value = 0x40;
+ #endif
+ MVars.nCurrentPort |= Value;
+ }
+
+ WriteToSpiPort(MVars.nCurrentPort);
+ CsCurrentUp(); // low aktiv
+#endif
+}
+
+/****************************************************************
+ * SquareOffsetDown
+ * 0 setzt den Offset des Sinusgenerators auf Sinus und Dreieck.
+ um den Generator auf Recheck zusetzen, ist SwitchWaveForm auf true
+ zu setzen. Damit wird der Offset verschoben und an das Rechtecksignal
+ angepasst.
+ *
+***************************************************************/
+void SetSquareOffset(int State)
+{
+#ifdef PGU_TOUCH
+ SwitchWaveForm = State;
+#endif
+}
+
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/Dio.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,123 @@ +/*------------------------------------------------------------------------------- +Programm Name: Dio.h +Version: 1.0 +Sprache: C +Compiler: mbed +Autor: PS +Copyright: PS + +Funktion: I/O Signale für Messbereichszugriffe, U-Ruhe/IZelle, Pot/Gal usw. +-------------------------------------------------------------------------------*/ + +// D-I/O's +//----------------------------------------------------------------------------- +extern DigitalOut led1; // (LED1); +extern DigitalOut led2; // (LED2); +extern DigitalOut led3; //(LED3); +extern DigitalOut led4; //(LED4); + + +#ifdef CURRENT_5A_PIO +extern DigitalOut CsCurrent; // Enable +extern DigitalOut CsTemp1; // A0 +extern DigitalOut CsTemp2; // A1 +extern DigitalOut CsIrComp; // A2 +#else + +extern DigitalOut EnableOffset; //Offset freigeben + +#endif + + +// Macros +/*----------------------------------------------------------------------------- +#define Spi0IsMisoUp() (LPC_GPIO0->FIOPIN & 0x00020000) +#define Spi0IsMisoDown() (LPC_GPIO0->FIOPIN & ~0x00020000) + +#ifdef EXT_AB + + #define SkIzUp() (LPC_GPIO2->FIOSET |= 0x00000001) // CsIrKomp + #define SkIzDown() (LPC_GPIO2->FIOCLR |= 0x00000001) // + + #define PotGalUp() (LPC_GPIO2->FIOSET |= 0x00000002) // CsCurrent + #define PotGalDown() (LPC_GPIO2->FIOCLR |= 0x00000002) +#else + #ifdef PGU_MOD_OLD + + #define SkIzUp() (LPC_GPIO0->FIOSET |= 0x00040000) + #define SkIzDown() (LPC_GPIO0->FIOCLR |= 0x00040000) + + #define PotGalUp() (LPC_GPIO0->FIOSET |= 0x00008000) + #define PotGalDown() (LPC_GPIO0->FIOCLR |= 0x00008000) + + #else + + #define SkIzUp() (LPC_GPIO2->FIOSET |= 0x00000001) // CsIrKomp + #define SkIzDown() (LPC_GPIO2->FIOCLR |= 0x00000001) + + #define PotGalUp() (LPC_GPIO2->FIOSET |= 0x00000002) // CsCurrent + #define PotGalDown() (LPC_GPIO2->FIOCLR |= 0x00000002) + + #endif +#endif + +#ifdef IMP_INTERFACE + +#define SkIzUp() (LPC_GPIO2->FIOSET |= 0x00000001) // CsIrKomp +#define SkIzDown() (LPC_GPIO2->FIOCLR |= 0x00000001) // + +#define PotGalUp() (LPC_GPIO2->FIOSET |= 0x00000002) // CsCurrent +#define PotGalDown() (LPC_GPIO2->FIOCLR |= 0x00000002) + +#define IRangeEnable() (LPC_GPIO2->FIOSET |= 0x00000004) // CsSinGen +#define IRangeDisable() (LPC_GPIO2->FIOCLR |= 0x00000004) // CsSinGen + +#endif + +// Für die wenigen externen Geräte die noch über eine Box angesteuert werden +#define K0_Up() (LPC_GPIO2->FIOSET |= 0x00000001) +#define K0_Down() (LPC_GPIO2->FIOCLR |= 0x00000001) +#define K1_Up() (LPC_GPIO2->FIOSET |= 0x00000002) +#define K1_Down() (LPC_GPIO2->FIOCLR |= 0x00000002) +#define K2_Up() (LPC_GPIO2->FIOSET |= 0x00000004) +#define K2_Down() (LPC_GPIO2->FIOCLR |= 0x00000004) +#define K3_Up() (LPC_GPIO2->FIOSET |= 0x00000008) +#define K3_Down() (LPC_GPIO2->FIOCLR |= 0x00000008) + +#define K4_Up() (LPC_GPIO2->FIOSET |= 0x00000020) +#define K4_Down() (LPC_GPIO2->FIOCLR |= 0x00000020) +#define K5_Up() (LPC_GPIO2->FIOSET |= 0x00000010) +#define K5_Down() (LPC_GPIO2->FIOCLR |= 0x00000010) +#define K6_Up() (LPC_GPIO1->FIOSET |= 0x40000000) +#define K6_Down() (LPC_GPIO1->FIOCLR |= 0x40000000) +#define K7_Up() (LPC_GPIO1->FIOSET |= 0x80000000) +#define K7_Down() (LPC_GPIO1->FIOCLR |= 0x80000000) + +*/ + +// Funktionen aus Dio.cpp +//------------------------------------ +extern int SetBaVariablen(int Nr, bool Level); +extern int Setk(int Nr, bool Level); +extern int SetkPio(int Nr, bool Level); +extern int SetkPguMod(int Nr, bool Level); +extern int SetkPguStack(int Nr, bool Level); +extern void SetRefFilter(unsigned char Rng); +extern void SetUGainMux(unsigned char Range); +extern void SetIGainMux(unsigned char Range); +extern void SetUOffset(unsigned char Range); +extern void SetFrqGain(BYTE V1, BYTE V2, BYTE Mux); +extern void SinOnOff(int State); +extern int InitDio(void); +extern void SetRefSpiRange(); +extern void SetCurSpiRange(); +// extern void WriteToSpiPort(unsigned char Port); +extern void SetExtBnc(int State, int Nr); +extern int ChangeMittelValue(); +extern int SwitchRangesOnStart(); +extern void SetCurBiRange(); +extern int SetIZelleBasis(int Nr, bool Level); +extern void WriteToStackPort(unsigned int Port); +extern void SetRefStackRange(); + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/EcmTel.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,485 @@
+/*
+-------------------------------------------------------------------------------
+Programm Name: EcmTel.CPP
+Version: 1.0
+Sprache: C
+Compiler: MBED
+Autor: PS
+Copyright: PS
+
+Funktion: Telegrammauswertung fuer EcmCom Programm auf LPC1768
+
+Letzte Änderung für neue EcmWin Version 2.1 war
+Ver.: 2.0.1.0
+
+
+-------------------------------------------------------------------------------
+*/
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+
+
+/*-------------------------------------------------------------------------------
+Interne Prototypen
+-------------------------------------------------------------------------------*/
+extern int ScanNext(char *Line, int &Start, int Len);
+
+
+/*-------------------------------------------------------------------------------
+Variablen, die nur in EcmTel verwendet werden
+-------------------------------------------------------------------------------*/
+char TelCode[8];
+
+int TelLen;
+
+char *TelPos;
+
+
+const char *CodeTab[11] = {"CN", "SK", "FR", "SW", "SC", "IC", "SI", "DI", "GD", "DY", "PA"
+};
+
+/* Die Codefunktionen sind:
+CN: Kanalnummern setzen DecodeChannel()
+SK: Kontakt Setzen DecodeContact()
+FR: Freigabe, keine Komm. DecodeFreigabe()
+SW: Set Watchdog DecodeSetWd()
+SC: Set Analogausgang DecodeAnalogValue()
+IC: Setzt den Ini Code DecodeIniCode(char *Line);
+SI: Sendet den Ini Code SendIniCode(char *Line);
+
+DI: Sendet die DevID Datei, damit EcmWin das angeschlossene Gerät erkennen kann
+GD: Empfängt die DevID Datei,
+DY: Dummy Telegramm damit die Leitung in beide Richtungen angesprochen wird
+PA: Schaltet die Pumpe ein. SwitchPumpeOn
+
+*/
+
+
+
+int (*FktPtr[])(char *) = {DecodeChannel, DecodeContact, DecodeFreigabe, DecodeSetWd,DecodeAnalogValue, DecodeIniCode, \
+ SendIniCode, SendDevFile, GetDevFile, RequestDummy, SwitchPumpeOn
+};
+
+/*-------------------------------------------------------------------------------
+ Funktion CheckSioTel prueft den gesamten String und fieselt die einzelenen
+ Telegramme auseinander. Für jedes Telegramm wird separat DecodeTel aufgerufen,
+ welches den Inhalt des Telegramms auswertet
+ Der Telegrammanfang ist mit ! , das Ende mit $ gekennzeichnet
+-------------------------------------------------------------------------------*/
+int CheckTel()
+{
+ int i, Len;
+ char OldSign;
+
+ i=0;
+
+ Len = HostIf.nAwTelLen;
+#ifdef SIO_DEBUG
+// printf("HostIf.strTelAwBuf: %s\r\n",HostIf.strTelAwBuf);
+#endif
+// printf("%c#DG#HostIf.strTelAwBuf: %s%c\r\n",STX, HostIf.strTelAwBuf, ETX);
+
+ while(i < Len)
+ {
+ if(HostIf.strTelAwBuf[i] == STX) // hat Startzeichen erkannt. sollten Zeichen vor dem STX sein, dann werden diese verworfen
+ {
+ HostIf.ptrTelPos = &HostIf.strTelAwBuf[i+1];
+ HostIf.nTelLen = Len - i -1; // das Existieren von ETX wurde verher schon geprueft
+
+ OldSign = HostIf.strTelAwBuf[Len-1];
+ HostIf.strTelAwBuf[Len-1] = 0x00;
+ DecodeTel();
+ HostIf.strTelAwBuf[Len-1] = OldSign;
+ i = Len;
+ }
+ i++;
+ }
+ ChangeLedColor();
+ HostIf.fIsConnected = true;
+ return(0);
+}
+/*-------------------------------------------------------------------------------
+ CompareTelCode: vergleicht den Inhalt des Telegramms mit der Tabelle
+-------------------------------------------------------------------------------*/
+int CompareTelCode()
+{
+ int i;
+
+ for(i=0;i<ANZ_TEL_CODE;i++)
+ {
+ if( (HostIf.TelCode[0] == CodeTab[i][0]) && (HostIf.TelCode[1] == CodeTab[i][1]) )
+ {
+// printf("%s\n", HostIf.strTelAwBuf);
+ return(i);
+ }
+ }
+ return(-1);
+}
+
+
+/*-------------------------------------------------------------------------------
+ Funktion DecodeTel prueft Telegramme auf Inhalt und Befehl. Wird nur aufgerufen,
+ wenn Telegramm vollständig.
+ TelPos zeigt auf Anfang de Telegramms, TelLen ist die Länge bis zum TelEnde
+------------------------------------------------------------------------------- */
+int DecodeTel()
+{
+ int i, Ret;
+
+ i =0;
+ while( (*(HostIf.ptrTelPos+i) == '#') && (i < HostIf.nAwTelLen) )
+ i++;
+
+ if( (*(HostIf.ptrTelPos+i) > 0x40) && (*(HostIf.ptrTelPos+i) < 0x5B)) // ist ein Zeichen aus den Grossbuchstaben
+ {
+ if( (*(HostIf.ptrTelPos+i+1) > 0x40) && (*(HostIf.ptrTelPos+i+1) < 0x5B)) // auch das zweite Zeichen ist ein Grossbuchstabe
+ {
+ if(*(HostIf.ptrTelPos+i+2) == '#') // erst kommen zwei Großbuchstaben und dann ein #
+ { // ist ein richtige Telegramm
+ HostIf.TelCode[0] = *(HostIf.ptrTelPos+i);
+ HostIf.TelCode[1] = *(HostIf.ptrTelPos+i+1);
+ HostIf.TelCode[2] = 0x00;
+ Ret = CompareTelCode();
+ if(Ret >= 0) // gütiger Wert
+ {
+ (*FktPtr[Ret])((char *)(HostIf.ptrTelPos+i+3));
+ }
+ else // findet keinen passenden Code
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#Unbekanntes Telegramm", STX);
+ HostIf.fSendError = true;
+// printf("%s",IdSendBuf);
+
+ }
+ }
+ }
+ }
+ return(0);
+}
+/*-------------------------------------------------------------------------------
+RequestDummy: Nichts tun
+-------------------------------------------------------------------------------*/
+int RequestDummy(char *Line)
+{
+// MVars.m_fSendStatus = true;
+ return(1);
+}
+
+
+//--------------------------------------------------------------------------
+// Telegramm #IC#: Decode Ini File EcmWin sendet einen neuen IniFile
+//--------------------------------------------------------------------------
+int DecodeIniCode(char *Line)
+{
+ strcat(Line, "\r\n");
+ clSdCard.WriteFile(FileNames.IniFileName, Line);
+ OpenIni();
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Telegramm #SI#: Send Ini File. EcmWin ruft den Inifile ab
+//--------------------------------------------------------------------------
+int SendIniCode(char *Line)
+{
+ int Ret, fEnde;
+
+ Ret = clSdCard.OpenFile( (char *)FileNames.IniFileName, FileNames.FileReadMode);
+
+ if(Ret == false)
+ {
+ sprintf(HostIf.strTempBuf, "%c#DG#Fehler beim Oeffnen der IniDatei %s %s",STX, FileNames.IniFileName, FileNames.FileReadMode);
+ SendTelToHost(false, false, 0); // weitere Telegramme und kein EOF
+ return(false); // Fehler beim Öffnen der Datei
+ }
+ SetTimerInterrupt(0);
+ fEnde = false;
+ sprintf(HostIf.strTempBuf, "%c#SI#",STX);
+ SendTelToHost(true, false, 0); // weitere Telegramme und kein EOF
+ do
+ {
+ Ret = clSdCard.ReadLine(HostIf.strTempBuf, 512); // HostIf.strCommonTmpBuf hat 512 Zeichen, mehr sind in einer Zeile nicht drin
+ if(Ret > 0)
+ {
+ SendTelToHost(true, false, 0); // weitere Telegramme, kein EOF, LF durch # ersetzen
+ }
+ else // wenn er mit Ret = 0 zurückkommt, dann sind die Fehler gecleart, Datei noch offen
+ {
+ HostIf.strTempBuf[0] = 0x00; // ETX wird spaeter drangehaengt
+ SendTelToHost(false, false, 0); // Gesamtdatei kleiner 16384 Bytes, daher ohne EOF
+ fEnde = true;
+ }
+ }
+ while(fEnde == false);
+ clSdCard.CloseFile();
+ if(MVars.m_fMessDlgOpened == true)
+ SetTimerInterrupt(1);
+ return(true);
+}
+//--------------------------------------------------------------------------
+// ScanNext: Such die nächste Stelle im Telegramm hinter dem #
+//--------------------------------------------------------------------------
+int ScanNext(char *Line, int &Start, int Len)
+{
+ while(*(Line+Start) != '#')
+ {
+ Start++;
+ if(Start >= Len)
+ return(false);
+ }
+ Start++;
+ if(Start >= Len)
+ return(false);
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Telegramm #CN#: Kanalnummern, Anz. Messwerte und Gültige Kanäle werde uebertragen
+// Kanalnummern, die uebertragen werden sollen
+// Tel hat die Form: !#CN#0,1,2,3,4,5,6,7,4,5,6,7, 4,5,6,7,0,0|<CR><LF>
+// Die ersten 8 Zahlen sind die Kanalnumern der Messkanaele, die naechste vier sind die Schaltkanaele
+// die naechsten beiden sind Autorange
+//--------------------------------------------------------------------------
+int DecodeChannel(char *Line)
+{
+ int Start, Len,i;
+
+// printf("%c#DG#Decode Channel Line %s %c\n", STX, Line, ETX);
+ MVars.m_fMessDlgOpened = true;
+ MVars.fAdReInit = false;
+ MVars.fEnableAuto = true; // damit EnableAutoRange gesetzt wird
+ MVars.nAktMittelAfter = 500; // in Grundstellung alle 500ms
+
+ Start = 0;
+ Len = strlen(Line);
+// printf("%c#DG#LineLen Decode Channel %d %c\n", STX,Len, ETX);
+ for(i=0;i<8;i++)
+ {
+ MVars.dbAdSum[i] = 0.;
+ MVars.MwChn[i] = atoi(Line+Start);
+ if(ScanNext(Line,Start, Len) == false) return(false);
+ }
+// printf("%c#DG#Decode Channel nach for i<8 %c\n", STX, ETX);
+
+ MVars.m_nAnzChnSend = 3;
+
+ for(i=0;i<3;i++)
+ MVars.m_fChnValid[i] = true;
+
+// printf("%c#DG#Decode Channel nach fValid%c\n", STX, ETX);
+
+ MVars.SendAnzWerte = 2;
+ CalcSendAnzWerte();
+ if(MVars.SendAnzWerte == 1000)
+ {
+ MVars.AdConvTime = 0x18; // Startwert, längste Wandlungszeit
+ }
+ else if(MVars.SendAnzWerte == 500)
+ {
+ MVars.AdConvTime = 0x28; // Startwert, längste Wandlungszeit
+ }
+ else if(MVars.SendAnzWerte == 200)
+ {
+ MVars.AdConvTime = 0x58; // Startwert, längste Wandlungszeit
+ }
+ else
+ {
+ MVars.AdConvTime = 0x7F; // Startwert, längste Wandlungszeit
+ }
+// printf("%c#DG#Decode Channel nach CalcSendAnz%c\n", STX, ETX);
+
+// SetAdConversionTime();
+// wait(2.0);
+ SetTimerInterrupt(1); // wenn er schon laeuft, dann passiert nichts
+
+ MVars.nAktMittelAfter = 500; // in Grundstellung alle 500ms
+
+ MVars.nSendAfter = 500;
+ MVars.m_nAnzValue = 1;
+
+ MVars.nDestCount = 0;
+ MVars.nMittelTimer =0;
+ MVars.nMessTimer = 0;
+ MVars.m_fStartTel = 0x01;
+ MVars.m_nSendValues = 1;
+ STemp[0] = 0x00;
+
+// Ad7739Init();
+ Ad7739Start(0, 0,1);
+// MVars.fAdReInit = true;
+// printf("%c#DG#Ende Decode Channel%c\n", STX, ETX);
+
+ return(true);
+}
+//--------------------------------------------------------------------------
+void CalcSendAnzWerte()
+{
+ if(MVars.SendAnzWerte >= 1000) // 1000 Werte Pro Sekunden
+ MVars.nMittelAfter = 1;
+ else if(MVars.SendAnzWerte == 500) // 500 Werte Pro Sekunden
+ MVars.nMittelAfter = 2;
+ else if(MVars.SendAnzWerte == 200) // 200 Werte Pro Sekunden
+ MVars.nMittelAfter = 5;
+ else if(MVars.SendAnzWerte == 100) // 100 Werte Pro Sekunden
+ MVars.nMittelAfter = 10;
+ else if(MVars.SendAnzWerte == 50) // 50 Werte Pro Sekunden
+ MVars.nMittelAfter = 20;
+ else if(MVars.SendAnzWerte == 20) // 20 Werte Pro Sekunden
+ MVars.nMittelAfter = 50;
+ else if(MVars.SendAnzWerte == 10) // 10 Werte Pro Sekunden
+ MVars.nMittelAfter = 100;
+ else if(MVars.SendAnzWerte == 4) // 4 Werte Pro Sekunden
+ MVars.nMittelAfter = 250;
+ else // if(MVars.SendAnzWerte == 2) // 2 Werte Pro Sekunden
+ MVars.nMittelAfter = 500;
+}
+//--------------------------------------------------------------------------
+// #SK# // beliebigen Kanal schalten
+//--------------------------------------------------------------------------
+int DecodeContact(char *Line)
+{
+ int Start,Len, SkChn;
+ bool SkLevel;
+
+ Start = 0;
+
+ Len = strlen(Line);
+ SkChn = atoi(Line);
+ while( (*(Line+Start) != '#') && (Start < Len) )
+ Start++;
+ Start += 1;
+ SkLevel = (bool)atoi(Line+Start);
+
+ if(SkChn == 0) // Start Kommando, Motor laeuft los
+ {
+ if(SkLevel == 0)
+ SwR0 = false;
+ else
+ {
+ SwR0 = true;
+ MVars.m_fSendStatus = true;
+ }
+ }
+ else if(SkChn == 1) // Direktion, wenn low, dann Gegenuhrzeigersinn
+ {
+ if(SkLevel == 0) SwR1 = false;
+ else SwR1 = true;
+ }
+
+
+ return(true);
+}
+//--------------------------------------------------------------------------
+// #FR# Pot. freigeben
+//--------------------------------------------------------------------------
+int DecodeFreigabe(char *Line)
+{
+ int i;
+
+ MVars.nMessArt = 0;
+ MVars.fSequenzMessung = false;
+ IrComp.fMitIrValue = false;
+ MVars.m_fMessDlgOpened = false;
+ FrqValues.fImpedance = false; // falls er auf Impedanzmessung war
+
+ Ad7739Stop();
+ for(i=0;i<ANZ_POT;i++)
+ MVars.nMessZustand[i] = 0;
+ IrComp.dbAOut[0] = 0.;
+ CalcDa(IrComp.dbAOut[0], 0);
+ MVars.m_nSendValues = 0;
+
+ LedsOff();
+ MVars.fEnableAuto = false; // damit EnableAutoRange gesetzt wird
+ nMyTimer = 0;
+ return(true);
+}
+//--------------------------------------------------------------------------
+// #SW# Set Watchdog
+//--------------------------------------------------------------------------
+int DecodeSetWd(char *Line)
+{
+ int Start,Len,i;
+
+ Start = 0;
+ Len = strlen(Line);
+ WDog.fEnabled = (bool)atoi(Line);
+
+ while( (*(Line+Start) != '#') && (Start < Len) )
+ Start++;
+ Start++;
+ WDog.nTimeOut = atoi(Line+Start);
+ WDog.nMsTimeOut = WDog.nTimeOut * 200;
+
+ while( (*(Line+Start) != '#') && (Start < Len) )
+ Start++;
+ Start++;
+ i=0;
+ while( (*(Line+Start) != '#') && (Start < Len) )
+ {
+ WDog.cSign[i] = *(Line+Start);
+ Start++; i++;
+ if(i > 7) break;
+ }
+ Start++;
+ WDog.fLogFile = (bool)atoi(Line+Start);
+// printf("WatchDog: %d, %d, %s, %d",WDog.fEnabled, WDog.nTimeOut, WDog.cSign, WDog.fLogFile);
+ return(true);
+}
+//--------------------------------------------------------------------------
+ // #SC# Analogausgang setzen
+//--------------------------------------------------------------------------
+int DecodeAnalogValue(char *Line)
+{
+ int Start,Chn;
+
+ Start = 0;
+
+// return(true);
+// printf("Puffer:%s",Line);
+#ifdef SIO_DEBUG
+ printf("MessZustand: %d Flag Sequenzmessung %d\n",MVars.nMessZustand[0], MVars.fSequenzMessung);
+#endif
+ if(MVars.fSequenzMessung) // nur wenn innerhalb der Sequenzmessung
+ MVars.m_fScan = false;
+ Chn = atoi(Line);
+ if(Chn > 0) Chn--; // bekommt 1 und 2, muss aber mit 0 und 1 arbeiten
+ Start += 2;
+// printf("Ch:%d Val:%f\n",Channel,AOut);
+ IrComp.dbAOut[Chn] = atof(Line+Start);
+#ifdef SIO_DEBUG
+ printf("DaValue: %f \n",IrComp.dbAOut[Chn]);
+#endif
+ CalcDa(IrComp.dbAOut[Chn], Chn);
+
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+// SendIdTel: Sendet das ID-Telegramm
+-------------------------------------------------------------------------------*/
+int SendIdTel()
+{
+// TcpClient.send( TcpSendBuf, strlen(TcpSendBuf));
+ return(1);
+}
+//--------------------------------------------------------------------------
+// Telegramm #CN#: Kanalnummern, Anz. Messwerte und Gültige Kanäle werde uebertragen
+// Kanalnummern, die uebertragen werden sollen
+// Tel hat die Form: !#CN#0,1,2,3,4,5,6,7,4,5,6,7, 4,5,6,7,0,0|<CR><LF>
+// Die ersten 8 Zahlen sind die Kanalnumern der Messkanaele, die naechste vier sind die Schaltkanaele
+// die naechsten beiden sind Autorange
+//--------------------------------------------------------------------------
+int SwitchPumpeOn(char *Line)
+{
+ int Start, Len,i;
+
+ Start = 0;
+ Len = strlen(Line);
+
+ IrComp.dbAOut[0] = atof(Line+Start);
+ CalcDa(IrComp.dbAOut[0], 0);
+ SwR0 = true;
+ MVars.m_fSendStatus = true;
+ return(true);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/EcmTel.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,36 @@ +/* +------------------------------------------------------------------------------- +Programm Name: EcmTel.h +Version: 1.0 +Sprache: C +Compiler: MBED +Autor: PS +Copyright: PS + + +Funktion: Externdeklarationen f�r die EcmTel +Aenderungen: +2016-06-29 +------------------------------------------------------------------------------- +*/ + +#define ANZ_TEL_CODE 11 // 2019-08-23: PS: auf 77, alle zusammengefasst + + +extern void CalcSendAnzWerte(); +extern int CompareTelCode(char *Line); + + +extern int DecodeChannel(char *Line); +extern int DecodeContact(char *Line); +extern int DecodeFreigabe(char *Line); +extern int DecodeSetWd(char *Line); +extern int DecodeAnalogValue(char *Line); +extern int DecodeIniCode(char *Line); +extern int SendIniCode(char *Line); +extern int SendDevFile(char *Line); +extern int GetDevFile(char *Line); +extern int RequestDummy(char *Line); +extern int SwitchPumpeOn(char *Line); + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/FT_DataTypes.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,71 @@ +/* mbed Library for FTDI FT800 Enbedded Video Engine "EVE" + * based on Original Code Sample from FTDI + * ported to mbed by Peter Drescher, DC2PD 2014 + * Released under the MIT License: http://mbed.org/license/mit */ + +#ifndef _FT_DATATYPES_H_ +#define _FT_DATATYPES_H_ + + +#define FT_FALSE (0) +#define FT_TRUE (1) + +typedef char ft_char8_t; +typedef signed char ft_schar8_t; +typedef unsigned char ft_uchar8_t; +typedef ft_uchar8_t ft_uint8_t; +typedef short ft_int16_t; +typedef unsigned short ft_uint16_t; +typedef unsigned int ft_uint32_t; +typedef int ft_int32_t; +typedef void ft_void_t; +typedef long long ft_int64_t; +typedef unsigned long long ft_uint64_t; +typedef float ft_float_t; +typedef double ft_double_t; +typedef char ft_bool_t; + +#define FT_BYTE_SIZE (1) +#define FT_SHORT_SIZE (2) +#define FT_WORD_SIZE (4) +#define FT_DWORD_SIZE (8) + +#define FT_NUMBITS_IN_BYTE (1*8) +#define FT_NUMBITS_IN_SHORT (2*8) +#define FT_NUMBITS_IN_WORD (4*8) +#define FT_NUMBITS_IN_DWORD (8*8) + +#define ft_prog_uchar8_t ft_uchar8_t +#define ft_prog_char8_t ft_char8_t +#define ft_prog_uint16_t ft_uint16_t + +#define ft_random(x) (rand() % (x)) + +#define ft_pgm_read_byte_near(x) (*(x)) +#define ft_pgm_read_byte(x) (*(x)) + +#define ft_strcpy_P strcpy +#define ft_strlen_P strlen + +#define FT_DBGPRINT(x) printf(x) +#define FT_PROGMEM const + +#define ft_pgm_read_byte_near(x) (*(x)) +#define ft_pgm_read_byte(x) (*(x)) + +#define ft_pgm_read_word(addr) (*(ft_int16_t*)(addr)) + +#endif /*_FT_DATATYPES_H_*/ + + +/* Nothing beyond this*/ + + + + + + + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/Globals.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,298 @@
+/*-------------------------------------------------------------------------------
+Programm Name: Globals.C
+Version: 1.0
+Sprache: C
+Compiler: CrossStudio Ver. 2.0
+Autor: PS
+Copyright: PS
+
+Funktion: Globale Variablen
+
+28.10.2012:
+
+Memo der Registerzuordnung am Beispiel des PTD
+----------------------------------------------
+#define GPIOD_PDOR GPIO_PDOR_REG(PTD)
+#define GPIOD_PSOR GPIO_PSOR_REG(PTD)
+#define GPIOD_PCOR GPIO_PCOR_REG(PTD)
+#define GPIOD_PTOR GPIO_PTOR_REG(PTD)
+#define GPIOD_PDIR GPIO_PDIR_REG(PTD)
+#define GPIOD_PDDR GPIO_PDDR_REG(PTD)
+
+** GPIO - Register Layout Typedef
+typedef struct {
+ __IO uint32_t PDOR; **< Port Data Output Register, offset: 0x0
+ __O uint32_t PSOR; **< Port Set Output Register, offset: 0x4
+ __O uint32_t PCOR; **< Port Clear Output Register, offset: 0x8
+ __O uint32_t PTOR; **< Port Toggle Output Register, offset: 0xC
+ __I uint32_t PDIR; **< Port Data Input Register, offset: 0x10
+ __IO uint32_t PDDR; **< Port Data Direction Register, offset: 0x14
+} GPIO_Type, *GPIO_MemMapPtr;
+
+*/
+
+/*-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+// LED's
+DigitalOut LedRed(LED_RED); // PTB22
+DigitalOut LedGreen(LED_GREEN); // PTE26
+DigitalOut LedBlue(LED_BLUE); // PTB21
+
+// I/O's für die Messbereichsumschaltung
+
+
+
+// I/O's für den D/A Wandler
+// Aenderungen fuer REV-D, PTC16 und PTC17 werden nicht mehr benutzt
+// Aenderungen treffen auf den D/A Wandler zu
+// I/O's fuer D/A Wandler
+DigitalOut DacSck(PTB19);
+DigitalOut DacMosi(PTB18);
+DigitalOut DacCs(PTC1);
+
+// DIO Globals
+
+DigitalOut SwR1(PTD2);
+DigitalOut SwR2(PTD3);
+DigitalOut SwR3(PTE25);
+DigitalOut SwR0(PTE24);
+
+
+
+// Variablen, die in Interruptroutinen verwendet werden
+int g_fDoDioReInit;
+
+//------------------------------------------------------
+
+
+
+
+double m_dbKehrWert;
+
+
+uint8_t g_u8AdcStatus[2];
+uint8_t g_u8ChnStatus[2][8];
+
+int nCounter[2];
+int m_nId, m_nCounter;
+UINT8 fARead[8], fSendData;
+unsigned long AdTemp[8];
+long m_lMittelCount;
+int m_fIdSend;
+int MessTimer;
+int nSumCount;
+
+UINT8 g_ReadReg[8];
+
+bool m_fChangeMittelValue;
+bool m_fFallBack;
+int nFallBackCounter;
+
+bool g_fSequenzMessung;
+
+
+/*-------------------------------------------------------------------------------
+Variablen für zeitverzögerte Funktionen
+-------------------------------------------------------------------------------*/
+int g_nDelayCounter;
+int g_nCntSpzFktSwitchIRange;
+int g_nCntSpzFktSwitchNoiseGain;
+int g_nCntSpzClearDDS;
+int g_nCntSpzSwitchMosFet;
+
+
+bool g_fSpzFktSwitchNoiseGain;
+bool g_fSpzFktSetMosFet;
+bool g_fSpzFktClearDDS;
+
+bool g_fCheckSpecial;
+int g_nEntPrellCounter;
+
+
+
+/*-------------------------------------------------------------------------------
+Variablen für die IR-Kompensation
+-------------------------------------------------------------------------------*/
+IR_COMP IrComp;
+
+
+
+/*-------------------------------------------------------------------------------
+Variablen für die SPI Ausgabemasken
+-------------------------------------------------------------------------------*/
+
+
+
+
+
+/*-------------------------------------------------------------------------------
+Variablen für das Netzwerkhandling
+-------------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------------
+Variable für das Auslesen der SD Card und Versenden via TCP
+-------------------------------------------------------------------------------*/
+
+char FName[128];
+char DName[128];
+
+char IoLine[256];
+
+DIR *dir;
+FILE *ifs;
+
+char g_sTelEndeContinue[8];
+char g_sTelEndeFinish[8];
+bool g_fMwTransferOpen;
+char g_cFileEndCharacter[2];
+
+/*-------------------------------------------------------------------------------
+Strukturen und Pointer
+-------------------------------------------------------------------------------*/
+START_UP StartUp;
+WATCH_DOG WDog;
+MESS_VARIABLES Mv[ANZ_POT]; // Alles für 2 mal
+MESS_VARS MVars;
+FRQ_VALUES FrqValues;
+NEW_SCAN_RATE NsRate;
+ECM_INI EcmIni;
+
+MESS_PARAMETER MPara;
+// I_RANGE IRange;
+
+//UINT32 nAnzPulsesUp[2];
+//UINT32 nAnzPulsesDown[2];
+
+//float flUpperPot;
+//float flLowerPot;
+
+
+UINT32 nScanCount[2];
+UINT16 nDispCount;
+UINT8 fSetHold;
+double LastVal[2];
+
+
+int nGenFktNr[2]; // ist local und wird nur für die Funktionsnummer verwendet
+
+uint8_t g_RCodeStartUp; // RCode der einzelne RCodes beim Start beinhaltet
+bool g_fTimerIsRunning;
+
+
+/*-------------------------------------------------------------------------------
+LED1 umschalten
+-------------------------------------------------------------------------------*/
+void SLed1()
+{
+ LedRed = !LedRed;
+}
+/*-------------------------------------------------------------------------------
+Alle vier LEDs ausschalten
+-------------------------------------------------------------------------------*/
+void LedsOff()
+{
+ LedRed = 0;
+ LedGreen = 0;
+ LedBlue = 0;
+}
+/*-------------------------------------------------------------------------------
+Globale Initialisierung
+-------------------------------------------------------------------------------*/
+
+int InitGlobals()
+{
+
+// InitCnf();
+ InitAll(); // ruft die MVars Inits auf
+ InitAdValues();
+
+ g_cFileEndCharacter[0] = 0x7D;
+ g_cFileEndCharacter[1] = 0x00;
+ sprintf(g_sTelEndeContinue,"%c\r\n", ETX);
+ sprintf(g_sTelEndeFinish,"}%c\r\n", ETX);
+ g_fMwTransferOpen = false;
+
+
+ g_nEntPrellCounter = 1000;
+
+ MVars.fSequenzMessung = false;
+
+ MVars.nIpsDebug = false;
+
+ MVars.nCurrentPort = 0x00;
+ MVars.m_fScan = false;
+ HostIf.fStartTel = true;
+
+ MVars.m_nSendValues = false;
+ MVars.nDestCount = 0;
+ MVars.nSendTimer = 0;
+ MVars.nDaTimer = 0;
+ MVars.nMittelTimer = 0;
+ MVars.m_fMeasurementFinished = false;
+ MVars.m_fFinishMeasurement = false;
+ MVars.m_fDoFinishMeasurement = false;
+ MVars.FrkValue[0] = 0.;
+ MVars.FrkValue[1] = 0.;
+
+ g_fCheckSpecial = false;
+ g_nCntSpzSwitchMosFet = 0;
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+Kurzer Delay
+-------------------------------------------------------------------------------*/
+void short_delay(int n)
+{
+ volatile int d;
+ for (d=0; d<n*10; d++){}
+}
+/*-------------------------------------------------------------------------------
+Funktion InitAll: Führt alle Initialisierungen durch
+-------------------------------------------------------------------------------*/
+int InitAll()
+{
+ InitMVars();
+// InitSioVars();
+
+ return(0);
+}
+/*-------------------------------------------------------------------------------
+Funktion InitMVars: Initialisiert alle Variablen aus der MVars Strúktur
+-------------------------------------------------------------------------------*/
+int InitMVars()
+{
+ int i;
+
+ for(i=0;i<ANZ_POT;i++)
+ MVars.nMessZustand[i] = 0;
+
+ MVars.fAdReInit = false;
+ MVars.m_nSendValues = 0;
+ MVars.m_nAnzChnSend = 0;
+// MVars.m_nStoreMwIntervall = 1;
+ MVars.SendAnzWerte = 200;
+ MVars.m_fCellSwitchOff = true;
+
+ // 1 = Messung laeuft, -1 = Messung wurde beendet,
+
+ for(i=0;i<16;i++)
+ {
+ MVars.MwChn[i] = i;
+ MVars.m_fChnValid[i] = false;
+ }
+
+ for(i=0;i<2;i++)
+ MVars.SwitchChn[i] = i+4;
+ for(i=2;i<4;i++)
+ MVars.SwitchChn[i] = i+10;
+
+ for(i=0;i<2;i++)
+ {
+ MVars.ZInfo[i] = 0; // ist in Grundstellung
+ Mv[i].IAktInVolt = 0.;
+ }
+ return(0);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/Globals.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,295 @@ +/*------------------------------------------------------------------------------- +Programm Name: Globals.H +Version: 1.0 +Sprache: C +Compiler: CrossStudio Ver. 2.0 +Autor: PS +Copyright: PS +Funktion: Globale Variablen und externe Methoden + +28.10.2012: + +-------------------------------------------------------------------------------*/ +/* +Memo: Bei den ersten FRDM Modulen, die bei der Sika stehen, ist die Verdrahtung der Messkanäle so, daß die ersten vier auf dem ersten +Wandler sind: U=A0:0, I=A0:1, IF=A0:2, IA=A0:3, UR=A1:0 (4), IR=A1:1 (5) + +bei der Rev-B ist es wie bei dem LPC, d.h. die Verdrahtung ist alternieren +U=A0:0, I=A1:0, IF=A0:1, IA=A1:1, UR=A0:2 , IR=A1:2 + +jetzt ist das Programm auf Rev. B eingestellt, bei Updates bei der Sika ist aufzupassen +09.04.16 +*/ + + + +// Defines +//------------------------------------ +// #define DEBUG 1 +// #define IR_DEBUG 1 // speziell für die IR-Kompensation +// #define SIO_DEBUG 1 +// #define SINGLE_DEBUG 1 + +// #define TFT_DEBUG 1 + +#define ANZ_KEY 34 // Schlüssel für die Inidatei + +// #define PGU_TOUCH 1 +// #define PGU_OEM_SPI 1 + +// die beiden folgenden sind z.B. für die Hiltigeräte aber auch grundsätzlich für FRDM RevB und PguMod zusetzten +#define FRDM_REV_D 1 + + +#define DEFAULT_STACK_SIZE 2048 + + +#define HIGH 1 +#define LOW 0 + +#define READ_CHN 0 +#define WANDLER 0 + + + +// Variable in TCPSocket.cpp im Ordner mbed-dev/features/netsocket +// wird incrementiert, wenn ein Telegramm kommt + +extern double m_dbKehrWert; + + +// Digital In-/ Outs +//----------------------------------- +// LED's +extern DigitalOut LedRed; // PTB22 +extern DigitalOut LedGreen; // PTE26 +extern DigitalOut LedBlue; // PTB21 + +// I/O's für die Messbereichsumschaltung + + + +// I/O's für den D/A Wandler +extern DigitalOut DacSck; +extern DigitalOut DacMosi; +extern DigitalOut DacCs; + +// DIO Globals +extern DigitalOut SwR1; +extern DigitalOut SwR2; +extern DigitalOut SwR3; +extern DigitalOut SwR0; + + + +// Makros zum Schreiben des D/A Wandlers +//----------------------------------- +#define DaCsUp() (GPIOC->PSOR |= 0x00000002) +#define DaCsDown() (GPIOC->PCOR |= 0x00000002) + + +#define DaSckUp() (GPIOB->PSOR |= 0x00080000) +#define DaSckDown() (GPIOB->PCOR |= 0x00080000) +#define DaMosiUp() (GPIOB->PSOR |= 0x00040000) +#define DaMosiDown() (GPIOB->PCOR |= 0x00040000) + + + +#define SW_REV "1.0.02" + +extern int g_fDoDioReInit; + + + +//------------------------------------------------------ + + + + + +/*------------------------------------------------------------------------------- +Variablen für zeitverzögerte Funktionen +-------------------------------------------------------------------------------*/ +extern int g_nDelayCounter; +extern int g_nCntSpzFktSwitchIRange; +extern int g_nCntSpzFktSwitchNoiseGain; +extern int g_nCntSpzClearDDS; +extern int g_nCntSpzSwitchMosFet; + + +extern bool g_fSpzFktSwitchNoiseGain; +extern bool g_fSpzFktSetMosFet; +extern bool g_fSpzFktClearDDS; + +extern bool g_fCheckSpecial; +extern int g_nEntPrellCounter; + + +/*------------------------------------------------------------------------------- +Variablen für die Ini-Datei +-------------------------------------------------------------------------------*/ +extern string cfgArray[ANZ_KEY][2]; + + + +/*------------------------------------------------------------------------------- +Variablen für die IR-Kompensation +-------------------------------------------------------------------------------*/ +extern IR_COMP IrComp; + + +/*------------------------------------------------------------------------------- +Variablen für Statustelegramm +-------------------------------------------------------------------------------*/ +extern bool fSendStatus; + + + +/*------------------------------------------------------------------------------- +Variablen für das Netzwerkhandling +-------------------------------------------------------------------------------*/ + + +/*------------------------------------------------------------------------------- +Variable für das Auslesen der SD Card und Versenden via TCP +-------------------------------------------------------------------------------*/ + +extern char FName[128]; +extern char DName[128]; + +extern char IoLine[256]; + +extern DIR *dir; +extern FILE *ifs; + +extern char g_sTelEndeContinue[8]; +extern char g_sTelEndeFinish[8]; +extern bool g_fMwTransferOpen; +extern char g_cFileEndCharacter[2]; + +/*------------------------------------------------------------------------------- +Strukturen und Pointer +-------------------------------------------------------------------------------*/ +extern AD_VAL *AdVal; + +// Globale Strukturen +extern WATCH_DOG WDog; +extern MESS_VARIABLES Mv[ANZ_POT]; // Alles für 2 mal +extern MESS_VARS MVars; +extern START_UP StartUp; +extern FRQ_VALUES FrqValues; +extern NEW_SCAN_RATE NsRate; +extern ECM_INI EcmIni; + +extern MESS_PARAMETER MPara; + +// extern I_RANGE IRange; + + + +extern UINT32 nScanCount[2]; +extern UINT16 nDispCount; +extern UINT8 fSetHold; +extern double LastVal[2]; + + +extern bool m_fChangeMittelValue; +extern bool m_fFallBack; +extern int nFallBackCounter; + + +// Globale Variablen +extern uint8_t AdcA0V1, AdcA0V2, AdcA0V3; +extern uint8_t AdcA1V1, AdcA1V2, AdcA1V3; +extern uint8_t g_u8AdcStatus[2]; +extern uint8_t g_u8ChnStatus[2][8]; + + + +extern int nCounter[2]; +extern int m_nId, m_nCounter; +extern UINT8 fARead[8], fSendData; +extern unsigned long AdTemp[8]; +extern long m_lMittelCount; +extern int m_fIdSend; +extern int MessTimer; +extern int nSumCount; + +extern UINT8 g_ReadReg[8]; + +extern int nGenFktNr[2]; // ist local und wird nur für die Funktionsnummer verwendet + +extern uint8_t g_RCodeStartUp; // RCode der einzelne RCodes beim Start beinhaltet +extern bool g_fTimerIsRunning; + + +// Prototypen +// Globale Funktionen + +// Funktionen aus Main.c +//------------------------------------ +extern int CheckDaAd(); +extern int CheckEthInput(); +extern int DoReInit(); + +extern int CheckZustand(); +extern int SendIdTel(); +extern void LedsOff(); +extern int SendAnalogValues(); +extern int ReadAllAdChannels(); +extern void ChangeConversionTime(); +extern int CheckGrundZustand(); +extern int CheckRunZustand(); +extern void SendStatus(void); + +extern int SendMessungStart(); +extern int SendMessungStop(); +extern void SendInfo(void); +extern void ReadAllChannels(); + + + + +// Funktionen aus Globals.c +//------------------------------------ +extern int InitGlobals(); +extern void InitAdValues(); +extern void short_delay(int n); + +extern void SendDataDa(); +extern int InitAll(); +extern int InitMVars(); + +// Funktionen aus EthInOut.c +//------------------------------------ +extern int CheckForFirstConnection(); +extern int WaitForEcmWinRequest(); +extern int ReadEthTel(); +extern int CheckWait(); +extern int DisconnectClient(); + + +// Funktionen aus EcmTel.cpp +//------------------------------------ +extern int CheckTel(); +extern int DecodeTel(); +extern int CloseUdFile(); +extern void CalcSendAnzWerte(); + +// Funktionen aus Dio.cpp +//------------------------------------ +extern int ChangeMittelValue(); + + + +// Funktionen aus DaMethoden.cpp +//------------------------------------ +extern void CalcDa(double SrcVal, UINT8 Chn); + + +// Funktionen aus CalcScan.cpp +//------------------------------------ +extern int SetStartDefault(int Nr); +extern int SetMessungEnde(); +extern int SetStartBasics(int Nr); +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/InitMain.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,163 @@
+/*-------------------------------------------------------------------------------
+Programm Name: InitMain.C
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Macht alle notwendigen Initialisierungen
+04.08.2016: Projekt: EcmComFrdm
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+// Globale Variablen fuer Main
+
+// int g_nMainCounter;
+bool m_fAutoStart;
+
+// bool m_fDoCheckIRange;
+
+// PwmOut PwmTest(PTA0);
+bool m_fTimeAlternate; // wird fuer die Anfrage der Zeit in Sekunden genommen
+bool g_fEnableTftIrq; // wird zur Bearbeitung de TFT Irq's genommen
+bool g_fOnDuringInit;
+
+/*-------------------------------------------------------------------------------
+Main Init.
+-------------------------------------------------------------------------------*/
+int InitMain()
+{
+
+ m_fAutoStart = false;
+ g_fDoDioReInit = false;
+ m_fTimeAlternate = false;
+ g_fOnDuringInit = true;
+
+#ifdef TOUCH_DISPLAY
+// g_fEnableTftIrq = false;
+ g_iMethCCActive = false;
+ g_fTimerIsRunning = false;
+#endif
+ EcmIni.nAnzChannel = 8;
+ MVars.nAnzPot = 1; // nur 1 Pot.
+
+ InitInterface();
+ printf("Init Interface done.\n");
+
+ SetTimerInterrupt(1);
+ printf("Timer started.\n");
+ if (InitGlobals() == true) // noch kein Zugriff auf die A/D Wandler
+ {
+ printf("Global Values initialized.\n");
+ g_RCodeStartUp |= 0x01;
+ }
+ else
+ printf("Error on init Global Values. \n");
+
+ if (InitSdFileSystem() == true)
+ {
+ printf("SD-Filesystem initialized.\n");
+ g_RCodeStartUp |= 0x02;
+ }
+ else
+ printf("Error on init SD-Filesystem. \n");
+
+ if (OpenIni() == true)
+ {
+ printf("IniFile read sucessful.\n");
+ g_RCodeStartUp |= 0x04;
+ }
+ else
+ printf("Error on open Ini-File. \n");
+
+ OpenDevIni();
+ printf("DevIniFile read sucessful.\n");
+
+ if (InitDio() == true)
+ {
+ printf("Digital I/O initialized.\n");
+ g_RCodeStartUp |= 0x08;
+ }
+ else
+ printf("Error on init Digital I/O. \n");
+
+#ifndef PGU_RPA
+ if (InitMethGlobals() == true) //
+ {
+ printf("Global Method values initialized.\n");
+ g_RCodeStartUp |= 0x10;
+ }
+ else
+ printf("Error on init Global Method values. \n");
+
+ InitAutoStart(); // Autostartdatei lesen
+ printf("Auto-Start initialized.\n");
+#endif
+#ifdef TOUCH_DISPLAY
+ if (InitTftGlobals() == true) // 2016-03-31 UFa; Initialisierung der TftGlobals Variablen
+ g_RCodeStartUp |= 0x18;
+#endif
+#ifndef PGU_RPA
+ if (InitFkt() == true)
+ {
+ printf("Scanner initialized.\n");
+ g_RCodeStartUp |= 0x20;
+ }
+ else
+ printf("Error on init Scanner. \n");
+#endif
+ if (InitDac() == true)
+ {
+ printf("DAC initialized.\n");
+ g_RCodeStartUp |= 0x40;
+ }
+ else
+ printf("Error on init DAC. \n");
+
+#ifdef ADC_24BIT
+ if (InitSpiAd() == true) // Setzt den Mode vom ADC Irq
+ {
+ printf("24 Bit ADC initialized.\n");
+ g_RCodeStartUp |= 0x80;
+ }
+ else
+ printf("Error on init 24 Bit ADC. \n");
+
+#endif
+// SwitchRangesOnStart(); //UFa 2017-05-23 -- > IRange.RangeValue[0] wird uad 0 gesetzt;
+
+#ifdef TOUCH_DISPLAY
+ DefineTouchInt(); // 2016-03-07 UFa: Touch Interrupts Definition
+
+ DispInit2Screen();
+
+
+ TftDecodeChannel(1); // Initialer Aufruf, da Para = 1
+
+ TftDisp.fMeasureRunning = false; // initial, es l�uft keine aktive Messung
+ TftDisp.fPguTouchActive = true; // initial, PguTouch ist via TFT bedienbar
+
+ g_ToCallScreen = 0;
+ DispMainScreenStatic();
+ DispMainScreenDynamic();
+#endif
+
+#ifdef ADC_24BIT
+ AdReset();
+ InitSpiAd(); // definiert die Irq's, der CallBack ist aber noch nicht scharf
+ Ad7739Init(0); // macht den kompletten Registerinit der ADC's
+ printf("Nach Ad7739 Init\n");
+
+ #ifdef PGU_STAND_ALONE
+ SetAdIrq(); // macht den Interrupt scharf
+ DoAdStart();
+ #endif
+#endif
+
+ g_fOnDuringInit = false;
+ return(true);
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/InitMain.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,31 @@ +/*------------------------------------------------------------------------------- +Programm Name: InitMain.h +Version: 1.0 +Sprache: C++ +Compiler: mbed +Autor: PS +Copyright: PS + + +Funktion: Macht alle notwendigen Initialisierungen +04.08.2016: Projekt: EcmComFrdm +-------------------------------------------------------------------------------*/ + +// Globale Variablen fuer Main + +// extern int g_nMainCounter; +extern bool m_fAutoStart; +extern bool g_fEnableTftIrq; // wird zur Bearbeitung de TFT Irq's genommen +extern bool m_fTimeAlternate; // wird fuer die Anfrage der Zeit in Sekunden genommen +extern bool g_fOnDuringInit; + + +// Methoden fuer Main +extern int InitMain(); +extern int CheckCommInterface(); +extern int CheckEcmWinConnect(); +extern int CheckAutoStart(); + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/LoopTimer.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,128 @@
+/*-------------------------------------------------------------------------------
+Programm Name: LoopTimer.cpp
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Main Funktionen
+04.08.2016: Projekt: RpaAnalyse
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+
+Ticker flipper; // Timerinterrupt
+// Variablen, die in Interruptroutinen verwendet werden
+volatile int nMyTimer;
+int ZustandsTimer;
+int g_nSendDisableTimer;
+int g_nTftTimer; // wird vor allem fuer das Abfragen der Uhr genommen
+
+
+/*-------------------------------------------------------------------------------
+Interrupt Funktion. Wird auf 1ms gesetzt
+-------------------------------------------------------------------------------*/
+void flip()
+{
+ nMyTimer++;
+}
+/*-------------------------------------------------------------------------------
+
+-------------------------------------------------------------------------------*/
+void DetachMyTicker()
+{
+ flipper.detach();
+ g_fTimerIsRunning = false;
+}
+/*-------------------------------------------------------------------------------
+
+-------------------------------------------------------------------------------*/
+void AttachMyTicker()
+{
+#ifdef SEND_DEBUG_TO_HOST
+ sprintf(HostIf.strTempBuf, "%c#DG#Attach Ticker%c",STX, ETX);
+ SendTelToHost(false, false, false);
+#endif
+
+ flipper.attach_us(&flip, 1000); // setup flipper to call flip after 1000 us
+ nMyTimer = 0;
+ MVars.nMittelTimer = 0;
+ MVars.nSendTimer = 0;
+ g_fTimerIsRunning = true;
+ g_nSendDisableTimer = 0;
+}
+/*-------------------------------------------------------------------------------
+SetTimerInterrupt:
+-------------------------------------------------------------------------------*/
+void SetTimerInterrupt(int Flag)
+{
+ if(Flag == 0) // ausschalten
+ {
+ if(g_fTimerIsRunning == true)
+ {
+ DetachMyTicker();
+ }
+ }
+ else
+ {
+ if(g_fTimerIsRunning == false)
+ {
+ AttachMyTicker();
+ }
+ }
+}
+/*-------------------------------------------------------------------------------
+ Funktion CheckTimerHandlingAndScanner: prüft ob Messdaten reinkommen
+-------------------------------------------------------------------------------*/
+int CheckTimerHandlingAndScanner()
+{
+ MVars.nMittelTimer++;
+ MVars.nSendTimer++;
+// nScreenSaverTimer++; // 2017-02-02 UFa: Timer ScreenSaver
+ ZustandsTimer++;
+ nMyTimer--;
+ g_nTftTimer++;
+ if(g_nSendDisableTimer > 0) g_nSendDisableTimer--;
+
+ if(MVars.nSendTimer >=500)
+ {
+// g_fDoCheckIRange = true;
+ MVars.nSendTimer = 0;
+ }
+
+// Der SAetGenValues wäre für RPA nicht notwendig, wenn m_fScan aber auf false
+// bleibt, dann sollte das kein Problem sein
+#ifndef PGU_RPA
+ if(MVars.m_fScan == true) // wenn true, dann wird gescannt
+ SetGenValues();
+#endif
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+ Funktion RequestDateTime
+-------------------------------------------------------------------------------*/
+int RequestDateTime()
+{
+#ifdef USE_RTC
+// Uhrzeit //UFa Timer
+ if(m_fTimeAlternate == true)
+ {
+ if(g_fDisableTimeRead == false)
+ {
+ seconds = time(NULL);
+ MyTm = localtime(&seconds); // seconds = time(NULL); vorher
+ sprintf(DtTime.cTimeBuffer,"%02d:%02d:%02d", MyTm->tm_hour, MyTm->tm_min,MyTm->tm_sec);
+ sprintf(DtTime.cDateBuffer,"%04d:%02d:%02d", MyTm->tm_year + 1900, MyTm->tm_mon +1 , MyTm->tm_mday);
+ m_fTimeAlternate = false;
+ }
+ }
+ else
+ m_fTimeAlternate = true;
+#endif
+ return(true);
+}
+
+
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MySources/LoopTimer.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,24 @@ +/*------------------------------------------------------------------------------- +Programm Name: LoopTimer.h +Version: 1.0 +Sprache: C++ +Compiler: mbed +Autor: PS +Copyright: PS + + +Funktion: Main Funktionen +04.08.2016: Projekt: RpaAnalyse +-------------------------------------------------------------------------------*/ +// Variablen, die in Interruptroutinen verwendet werden +extern volatile int nMyTimer; +extern int ZustandsTimer; +extern int g_nSendDisableTimer; +extern int g_nTftTimer; + +extern void DetachMyTicker(); +extern void AttachMyTicker(); +extern void SetTimerInterrupt(int Flag); + +extern int CheckTimerHandlingAndScanner(); +extern int RequestDateTime();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/OpenDevId.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,519 @@
+/*
+-------------------------------------------------------------------------------
+Programm Name: OpenDevId.CPP
+Version: 1.0
+Sprache: C
+Compiler: MBED
+Autor: PS
+Copyright: PS
+
+
+Funktion: Liest die ID-Datei und überträft diese an EcmWin. Damit kann
+ EcmWin den Gerätetyp eintragen. Wenn nicht vorhanden, dann kommt
+ ein NAK
+-------------------------------------------------------------------------------
+*/
+/*
+-------------------------------------------------------------------------------
+
+-------------------------------------------------------------------------------
+*/
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+const char *DevIdKey[] = {"DEV_INDEX", "POT_REV", "POT_VAR", "SCAN_VAR", "POT_CHN", "CURR_CHN", "AMP_CHN", "AMP_ACTIVE", "SW_IZ", "SW_PG", \
+ "POT_INVERTED", "O_POT_INV", "O_GAL_INV", "GAL_VAR_VAL", "U_N_CHN", "I_N_CHN", "I_N_ACTIVE", "LPC_CAL_C0", "LPC_CAL_C1", "LPC_CAL_C2",\
+ "LPC_CAL_C3", "LPC_CAL_C4", "LPC_CAL_C5", "LPC_CAL_C6", "LPC_CAL_C7", "INST_BOARD", "S_RATE_ID", "AV_VALUE" };
+
+
+DEV_INI DevIni;
+
+int (*DevKeyPtr[])(char *) = {DecDevIndex, DecPotRev, DecPotVar, DecScanVar,DecPotChn, DecCurrChn, DecAmpChn, DecAmpActive, DecSwIz, DecSwPg, \
+ DecPotInverted, DecOPotInv, DecOGalInv,DecGalVarVal, DecUnChn, DecInChn, DecInActive, DecLpcCalC0, DecLpcCalC1, \
+ DecLpcCalC2, DecLpcCalC3, DecLpcCalC4,DecLpcCalC5, DecLpcCalC6, DecLpcCalC7, DecInstBoard, DecSRateId, DecAvValue };
+
+
+
+/*-------------------------------------------------------------------------------
+SetIniKey: Beschreiben der Felder mit den INiKeys
+-------------------------------------------------------------------------------*/
+void SetDevIdKey()
+{
+ int i;
+
+ i = 0;
+
+}
+
+/*-------------------------------------------------------------------------------
+Datei öffnen
+-------------------------------------------------------------------------------*/
+int OpenDevIni()
+{
+ int i,j, Ret;
+ char strKeyCode[64];
+ char strValue[64];
+
+ InitDevIni();
+
+// return;
+
+ if(g_SdInitSuccess == false) // wenn SD Karte nicht vorhanden, retour
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#SD-Card is not acessable. %c\r\n", STX, ETX); //
+ HostIf.fSendError = true;
+ if(g_fOnDuringInit)
+ printf("%s",HostIf.strErrorBuf);
+
+ return(false);
+ }
+
+ Ret = clSdCard.OpenFile(FileNames.DevIdFileName, FileNames.FileReadMode);
+
+ if(Ret == false)
+ {
+ WriteDevFile(); // Defaultdatei erzeugen
+ sprintf(HostIf.strErrorBuf,"%c#ER#Error on open IniFile. Default created. %c\r\n", STX, ETX); //
+ HostIf.fSendError = true;
+ if(g_fOnDuringInit)
+ printf("%s",HostIf.strErrorBuf);
+ return(false); // öffnen der Inidatei hat nicht geklappt
+ }
+
+ do
+ {
+ Ret = clSdCard.ReadLine(strFileRwBuf, FILE_RW_BUF_LEN);
+ if(Ret > 0) // es sind Zeichen im Puffer
+ {
+ for(i=0;i<Ret;i++)
+ {
+ if( (strFileRwBuf[i] == 0x0A) || (strFileRwBuf[i] == 0x0D))
+ {
+ strFileRwBuf[i] = 0x00;
+ i = Ret;
+ }
+ else if(strFileRwBuf[i] == 0x2C) // Komma
+ strFileRwBuf[i] = 0x2E; // in Punkt
+ }
+ i = 0;
+ while( (i < 64) && (strFileRwBuf[i] != '=') )
+ {
+ strKeyCode[i] = strFileRwBuf[i];
+ i++;
+ }
+ strKeyCode[i] = 0x00;
+ i++;
+ while( (strFileRwBuf[i] == ' ') && (i < 100) )
+ i++;
+ strcpy(strValue,&strFileRwBuf[i]);
+
+ //printf("KeyCode: %s Value: %s\n", strKeyCode, strValue);
+ for(j = 0;j< ANZ_DEV_KEY;j++)
+ {
+ if(strcmp(strKeyCode, DevIdKey[j]) == 0) // die Strings stimmen überein
+ {
+ (*DevKeyPtr[j])((char *)(strValue));
+ j = ANZ_DEV_KEY;
+ }
+ }
+ }
+ }
+ while(Ret > 0);
+ clSdCard.CloseFile();
+ EcmIni.fCfgExists = true;
+// EcmIni.fCalRange = true;
+
+ return(true);
+}
+
+//--------------------------------------------------------------------------
+// DecDevIndex: Decodieren
+//--------------------------------------------------------------------------
+int DecDevIndex(char *Line)
+{ DevIni.nDevIndex = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecPotRev: Decodieren
+//--------------------------------------------------------------------------
+int DecPotRev(char *Line)
+{ DevIni.nPotRev = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecPotVar: Decodieren
+//--------------------------------------------------------------------------
+int DecPotVar(char *Line)
+{ DevIni.dbPotVar = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecScanVar: Decodieren
+//--------------------------------------------------------------------------
+int DecScanVar(char *Line)
+{ DevIni.dbScanVar = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecPotChn: Decodieren
+//--------------------------------------------------------------------------
+int DecPotChn(char *Line)
+{ DevIni.nPotChn = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecCurrChn: Decodieren
+//--------------------------------------------------------------------------
+int DecCurrChn(char *Line)
+{ DevIni.nCurrChn = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecAmpChn: Decodieren
+//--------------------------------------------------------------------------
+int DecAmpChn(char *Line)
+{ DevIni.nAmpChn = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecAmpActive: Decodieren
+//--------------------------------------------------------------------------
+int DecAmpActive(char *Line)
+{ DevIni.nAmpActive = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecSwIz: Decodieren
+//--------------------------------------------------------------------------
+int DecSwIz(char *Line)
+{ DevIni.nSwIz = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// DecSwPg: Decodieren
+//--------------------------------------------------------------------------
+int DecSwPg(char *Line)
+{ DevIni.nSwPotGal = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecPotInverted: Decodieren
+//--------------------------------------------------------------------------
+int DecPotInverted(char *Line)
+{ DevIni.nPotInverted = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecOPotInv: Decodieren
+//--------------------------------------------------------------------------
+int DecOPotInv(char *Line)
+{ DevIni.nOPotInv = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecOGalInv: Decodieren
+//--------------------------------------------------------------------------
+int DecOGalInv(char *Line)
+{ DevIni.nOGalInv = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecGalVarVal: Decodieren
+//--------------------------------------------------------------------------
+int DecGalVarVal(char *Line)
+{ DevIni.dbGalVar = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecUnChn: Decodieren
+//--------------------------------------------------------------------------
+int DecUnChn(char *Line)
+{ DevIni.nUnChn = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecInChn: Decodieren
+//--------------------------------------------------------------------------
+int DecInChn(char *Line)
+{ DevIni.nInChn = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecInActive: Decodieren
+//--------------------------------------------------------------------------
+int DecInActive(char *Line)
+{ DevIni.nNoiseActive = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC0: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC0(char *Line)
+{ DevIni.dbLpcCal0 = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC1: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC1(char *Line)
+{ DevIni.dbLpcCal1 = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC2: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC2(char *Line)
+{ DevIni.dbLpcCal2 = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC3: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC3(char *Line)
+{ DevIni.dbLpcCal3 = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC4: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC4(char *Line)
+{ DevIni.dbLpcCal4 = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC5: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC5(char *Line)
+{ DevIni.dbLpcCal5 = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC6: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC6(char *Line)
+{ DevIni.dbLpcCal6 = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecLpcCalC7: Decodieren
+//--------------------------------------------------------------------------
+int DecLpcCalC7(char *Line)
+{ DevIni.dbLpcCal7 = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecInstBoard: Decodieren
+//--------------------------------------------------------------------------
+int DecInstBoard(char *Line)
+{ DevIni.nInstBoard = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecSRateId: Decodieren
+//--------------------------------------------------------------------------
+int DecSRateId(char *Line)
+{ DevIni.nSRateIndex = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// DecAvValue: Decodieren
+//--------------------------------------------------------------------------
+int DecAvValue(char *Line)
+{ DevIni.nAvValue = atoi(Line); return(true); }
+
+/*-------------------------------------------------------------------------------
+Struktur Initialisieren
+-------------------------------------------------------------------------------*/
+void InitDevIni()
+{
+
+ DevIni.nDevIndex = 50; // Geräteindex
+ DevIni.nPotRev = 1; // Hardware Rev
+ DevIni.dbPotVar = 1.0; // Variabler Faktor für das Anzeigepotential
+ DevIni.dbScanVar = 1.0; // Variabler Faktor für das Scannerpotential
+ DevIni.nPotChn = 0; // Messkanal Potential
+ DevIni.nCurrChn = 1; // Messkanal Strom
+ DevIni.nAmpChn = 3; // Messkanal Verstärker
+ DevIni.nAmpActive = 0; // Stromverstärker aktiv
+ DevIni.nSwIz = 4; // Schalter OCP/Izelle
+ DevIni.nSwPotGal = 5; // Schalter Pot/Gal
+ DevIni.nPotInverted = 1; // Potentialanzeige invertiert
+ DevIni.nOPotInv = 1; // Scanner Potential invertiert
+ DevIni.nOGalInv = 1; // Scanner Galvanostat invertiert
+ DevIni.dbGalVar = 1.0; // Variabler Faktor für Galvanostat
+ DevIni.nUnChn = 4; // Messkanal UNoise
+ DevIni.nInChn = 5; // Messkanal INoise
+ DevIni.nNoiseActive = 0; // Noisemessung aktiv
+ DevIni.dbLpcCal0 = 1.0; // 1. Faktor für LpcKalibrierung
+ DevIni.dbLpcCal1 = 1.0; // 2. Faktor für LpcKalibrierung
+ DevIni.dbLpcCal2 = 1.0; // 3. Faktor für LpcKalibrierung
+ DevIni.dbLpcCal3 = 1.0; // 4. Faktor für LpcKalibrierung
+ DevIni.dbLpcCal4 = 1.0; // 5. Faktor für LpcKalibrierung
+ DevIni.dbLpcCal5 = 1.0; // 6. Faktor für LpcKalibrierung
+ DevIni.dbLpcCal6 = 1.0; // 7. Faktor für LpcKalibrierung
+ DevIni.dbLpcCal7 = 1.0; // 8. Faktor für LpcKalibrierung
+ DevIni.nInstBoard = 4; // Installierte Messkarte
+ DevIni.nSRateIndex = 3; // Index Samplerate
+ DevIni.nAvValue = 5; // Average Value
+
+}
+
+//--------------------------------------------------------------------------
+// #DI# DevID-Request, Host fragt die Geräteeinstellungen ab
+//--------------------------------------------------------------------------
+int SendDevFile(char *Line)
+{
+
+ OpenDevIni();
+
+
+ sprintf(HostIf.strTempBuf, "%c#DI#%s=%d#",STX, DevIdKey[0],DevIni.nDevIndex);
+ sprintf(STemp, "%s=%d#", DevIdKey[1],DevIni.nPotRev);
+ strcat(HostIf.strTempBuf, STemp);
+
+ sprintf(STemp, "%s=%f#", DevIdKey[2],DevIni.dbPotVar);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[3],DevIni.dbScanVar);
+ strcat(HostIf.strTempBuf, STemp);
+
+ sprintf(STemp, "%s=%d#", DevIdKey[4],DevIni.nPotChn);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[5],DevIni.nCurrChn);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[6],DevIni.nAmpChn);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[7],DevIni.nAmpActive);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[8],DevIni.nSwIz);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[9],DevIni.nSwPotGal);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[10],DevIni.nPotInverted);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[11],DevIni.nOPotInv);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[12],DevIni.nOGalInv);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[13],DevIni.dbGalVar);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[14],DevIni.nUnChn);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[15],DevIni.nInChn);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[16],DevIni.nNoiseActive);
+ strcat(HostIf.strTempBuf, STemp);
+
+ sprintf(STemp, "%s=%f#", DevIdKey[17],DevIni.dbLpcCal0);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[18],DevIni.dbLpcCal1);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[19],DevIni.dbLpcCal2);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[20],DevIni.dbLpcCal3);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[21],DevIni.dbLpcCal4);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[22],DevIni.dbLpcCal5);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[23],DevIni.dbLpcCal6);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%f#", DevIdKey[24],DevIni.dbLpcCal7);
+ strcat(HostIf.strTempBuf, STemp);
+
+ sprintf(STemp, "%s=%d#", DevIdKey[25],DevIni.nInstBoard);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#", DevIdKey[26],DevIni.nSRateIndex);
+ strcat(HostIf.strTempBuf, STemp);
+ sprintf(STemp, "%s=%d#%c\r\n", DevIdKey[27],DevIni.nAvValue, ETX);
+ strcat(HostIf.strTempBuf, STemp);
+
+ SendIdTel();
+
+ return(true);
+}
+
+//--------------------------------------------------------------------------
+// #GD# DevID-Request, Host sendet die Geräteeinstellungen
+//--------------------------------------------------------------------------
+int GetDevFile(char *Line)
+{
+
+ clSdCard.WriteFile(FileNames.DevIdFileName, Line);
+ OpenDevIni();
+ return(true);
+
+}
+/*-------------------------------------------------------------------------------
+Parameter Schreiben
+-------------------------------------------------------------------------------*/
+int WriteDevFile()
+{
+ int Ret,i;
+
+ if(g_SdInitSuccess == false) // wenn SD Karte nicht vorhanden, retour
+ {
+ return(false);
+ }
+
+ Ret = clSdCard.OpenFile(FileNames.DevIdFileName, FileNames.FileWriteMode);
+
+ if(Ret == false)
+ return(false); // öffnen der Datei hat nicht geklappt
+
+
+ i = 0;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nDevIndex);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nPotRev);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbPotVar);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbScanVar);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nPotChn);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nCurrChn);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nAmpChn);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nAmpActive);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nSwIz);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nSwPotGal);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nPotInverted);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nOPotInv);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nOGalInv);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbGalVar);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nUnChn);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nInChn);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nNoiseActive);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal0);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal1);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal2);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal3);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal4);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal5);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal6);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n",DevIdKey[i],DevIni.dbLpcCal7);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nInstBoard);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nSRateIndex);
+ clSdCard.WriteLine();
+ i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n",DevIdKey[i],DevIni.nAvValue);
+ clSdCard.WriteLine();
+ i++;
+
+ clSdCard.CloseFile();
+ return(true);
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/OpenDevId.h Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,94 @@
+/*-------------------------------------------------------------------------------
+Programm Name: OpenDevId.h
+Version: 1.0
+Sprache: C
+Compiler: MBED
+Autor: PS
+Copyright: PS
+
+
+Funktion: Liest die ID-Datei und überträft diese an EcmWin. Damit kann
+ EcmWin den Gerätetyp eintragen. Wenn nicht vorhanden, dann kommt
+ ein NAK
+-------------------------------------------------------------------------------
+*/
+
+#define ANZ_DEV_KEY 28
+
+
+/*===========================================================================
+Die nachfolgende Struktur dient zur Speicherung der Dev-Daten, die von EcmWin
+gelesen werden
+===========================================================================*/
+struct strDevIni
+{
+ int nDevIndex; // Geräteindex
+ int nPotRev; // Hardware Rev
+ double dbPotVar; // Variabler Faktor für das Anzeigepotential
+ double dbScanVar; // Variabler Faktor für das Scannerpotential
+ int nPotChn; // Messkanal Potential
+ int nCurrChn; // Messkanal Strom
+ int nAmpChn; // Messkanal Verstärker
+ int nAmpActive; // Stromverstärker aktiv
+ int nSwIz; // Schalter OCP/Izelle
+ int nSwPotGal; // Schalter Pot/Gal
+ int nPotInverted; // Potentialanzeige invertiert
+ int nOPotInv; // Scanner Potential invertiert
+ int nOGalInv; // Scanner Galvanostat invertiert
+ double dbGalVar; // Variabler Faktor für Galvanostat
+ int nUnChn; // Messkanal UNoise
+ int nInChn; // Messkanal INoise
+ int nNoiseActive; // Noisemessung aktiv
+ double dbLpcCal0; // 1. Faktor für LpcKalibrierung
+ double dbLpcCal1; // 2. Faktor für LpcKalibrierung
+ double dbLpcCal2; // 3. Faktor für LpcKalibrierung
+ double dbLpcCal3; // 4. Faktor für LpcKalibrierung
+ double dbLpcCal4; // 5. Faktor für LpcKalibrierung
+ double dbLpcCal5; // 6. Faktor für LpcKalibrierung
+ double dbLpcCal6; // 7. Faktor für LpcKalibrierung
+ double dbLpcCal7; // 8. Faktor für LpcKalibrierung
+ int nInstBoard; // Installierte Messkarte
+ int nSRateIndex; // Index Samplerate
+ int nAvValue; // Average Value
+
+};
+typedef struct strDevIni DEV_INI;
+
+
+extern DEV_INI DevIni;
+
+
+// Funktionen aus OpenDevId.cpp
+//------------------------------------
+extern int OpenDevIni();
+extern void InitDevIni();
+extern int WriteDevFile();
+
+extern int DecDevIndex(char *Line);
+extern int DecPotRev(char *Line);
+extern int DecPotVar(char *Line);
+extern int DecScanVar(char *Line);
+extern int DecPotChn(char *Line);
+extern int DecCurrChn(char *Line);
+extern int DecAmpChn(char *Line);
+extern int DecAmpActive(char *Line);
+extern int DecSwIz(char *Line);
+extern int DecSwPg(char *Line);
+extern int DecPotInverted(char *Line);
+extern int DecOPotInv(char *Line);
+extern int DecOGalInv(char *Line);
+extern int DecGalVarVal(char *Line);
+extern int DecUnChn(char *Line);
+extern int DecInChn(char *Line);
+extern int DecInActive(char *Line);
+extern int DecLpcCalC0(char *Line);
+extern int DecLpcCalC1(char *Line);
+extern int DecLpcCalC2(char *Line);
+extern int DecLpcCalC3(char *Line);
+extern int DecLpcCalC4(char *Line);
+extern int DecLpcCalC5(char *Line);
+extern int DecLpcCalC6(char *Line);
+extern int DecLpcCalC7(char *Line);
+extern int DecInstBoard(char *Line);
+extern int DecSRateId(char *Line);
+extern int DecAvValue(char *Line);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/OpenIni.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,493 @@
+/*
+-------------------------------------------------------------------------------
+Programm Name: OpenIni.CPP
+Version: 1.0
+Sprache: C
+Compiler: MBED
+Autor: PS
+Copyright: PS
+
+
+Funktion: Oeffnen die zusätzliche Ini-Datei. Falls nicht vorhanden,
+ Basisinitialisierung.
+-------------------------------------------------------------------------------
+*/
+/*
+-------------------------------------------------------------------------------
+Zuordnung der Konfigurationsvariablen. Folgende Informationen sollten verarbeitet
+werden: 08.01.2008
+Diese Ini-Datei soll so gestaltet sein, daß Zeilen angehängt werden können.
+Zunächst sollen folgende Inhalte aufgenommen werden:
+1. Seriennummer des Potentiostaten
+2. Lizenznummer der Software
+3. Revisionsnummer der Software
+4. Offsetkorrekturwert für die Analogausgabe
+5. Netzwerkadresse z.B. 192.168.2.99
+
+
+-------------------------------------------------------------------------------
+*/
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+/*-------------------------------------------------------------------------------
+Variablen für die Ini-Datei
+-------------------------------------------------------------------------------*/
+
+ // 0 1 2 3 4 5 6 7 8 9 10 11
+/*char *Key[34] = {"DEV_TYP", "POT_CODE", "SER_NR", "LZ_NR", "REV_NR", "IP_ADR", "SUB_NET", "GATEWAY", "HOST_IP", "PORT_NO", \
+"EXT_START", "SEXT_CHN_NR", "RPM_OFFSET", "RPM_SCALE", "AO_SCALE", "AO_OFFSET", "RE_INIT", "NR_OFF",
+"A0_OFFSET", "A1_OFFSET", "A2_OFFSET", "A3_OFFSET", "A4_OFFSET", "A5_OFFSET", "A6_OFFSET", "A7_OFFSET",
+"A0_SCALE", "A1_SCALE", "A2_SCALE", "A3_SCALE", "A4_SCALE", "A5_SCALE", "A6_SCALE", "A7_SCALE"
+}; // bis hier 93
+*/
+// Zeile = 50, Spalte = 16
+char IniKey[50][16];
+
+
+int posKey, posEqual, posValueEnd;
+
+int (*KeyPtr[])(char *) = {DecDevTyp, DecPotCode, DecSerNr, DecLzNr,DecRevNr, DecIpAddr, DecSubNet, DecGateway, DecHostIp, DecPortNo, \
+ DecExtStart, DecSextChnNr, DecRpmOffset, DecRpmScale, DecAoScale, DecAoOffset,DecReInit, DecNrOff,
+ DecU0Offset, DecU1Offset, DecU2Offset, DecU3Offset, DecU4Offset, DecU5Offset, DecU6Offset, DecU7Offset,
+ DecU0Scale, DecU1Scale, DecU2Scale, DecU3Scale, DecU4Scale, DecU5Scale, DecU6Scale, DecU7Scale
+ };
+
+
+/*-------------------------------------------------------------------------------
+SetIniKey: Beschreiben der Felder mit den INiKeys
+-------------------------------------------------------------------------------*/
+void SetIniKey()
+{
+ int i;
+
+ i = 0;
+ strcpy(IniKey[i++], "DEV_TYP");
+ strcpy(IniKey[i++], "POT_CODE");
+ strcpy(IniKey[i++], "SER_NR");
+ strcpy(IniKey[i++], "LZ_NR");
+ strcpy(IniKey[i++], "REV_NR");
+ strcpy(IniKey[i++], "IP_ADR");
+ strcpy(IniKey[i++], "SUB_NET");
+ strcpy(IniKey[i++], "GATEWAY");
+ strcpy(IniKey[i++], "HOST_IP");
+ strcpy(IniKey[i++], "PORT_NO");
+
+ strcpy(IniKey[i++], "EXT_START");
+ strcpy(IniKey[i++], "SEXT_CHN_NR");
+ strcpy(IniKey[i++], "RPM_OFFSET");
+ strcpy(IniKey[i++], "RPM_SCALE");
+ strcpy(IniKey[i++], "AO_SCALE");
+ strcpy(IniKey[i++], "AO_OFFSET");
+ strcpy(IniKey[i++], "RE_INIT");
+ strcpy(IniKey[i++], "NR_OFF");
+ strcpy(IniKey[i++], "A0_OFFSET");
+ strcpy(IniKey[i++], "A1_OFFSET");
+ strcpy(IniKey[i++], "A2_OFFSET");
+ strcpy(IniKey[i++], "A3_OFFSET");
+ strcpy(IniKey[i++], "A4_OFFSET");
+ strcpy(IniKey[i++], "A5_OFFSET");
+ strcpy(IniKey[i++], "A6_OFFSET");
+ strcpy(IniKey[i++], "A7_OFFSET");
+ strcpy(IniKey[i++], "A0_SCALE");
+ strcpy(IniKey[i++], "A1_SCALE");
+ strcpy(IniKey[i++], "A2_SCALE");
+ strcpy(IniKey[i++], "A3_SCALE");
+ strcpy(IniKey[i++], "A4_SCALE");
+ strcpy(IniKey[i++], "A5_SCALE");
+ strcpy(IniKey[i++], "A6_SCALE");
+ strcpy(IniKey[i++], "A7_SCALE");
+}
+
+/*-------------------------------------------------------------------------------
+Datei öffnen
+-------------------------------------------------------------------------------*/
+int OpenIni()
+{
+ int i,j,Ret;
+ char strKeyCode[64];
+ char strValue[128];
+
+
+ InitDefault(); // vor den Lesen defautl initialisieren
+#ifdef SINGLE_DEBUG
+ printf("Nach InitDfault\n");
+#endif
+
+ if(g_SdInitSuccess == false) // wenn SD Karte nicht vorhanden, retour
+ {
+#ifdef SINGLE_DEBUG
+ printf("SD Card not present\n");
+#endif
+ }
+
+ Ret = clSdCard.OpenFile(FileNames.IniFileName, FileNames.FileReadMode);
+
+ if(Ret == false)
+ {
+ WriteIni(); // Default erzeugen
+ return(false); // öffnen der Inidatei hat nicht geklappt
+ }
+
+ do
+ {
+ Ret = clSdCard.ReadLine(strFileRwBuf, FILE_RW_BUF_LEN);
+ if(Ret > 0) // es sind Zeichen im Puffer
+ {
+#ifdef SINGLE_DEBUG
+// printf("Buf: %s\n",strFileRwBuf);
+#endif
+ for(i=0;i<Ret;i++)
+ {
+ if( (strFileRwBuf[i] == 0x0A) || (strFileRwBuf[i] == 0x0D))
+ {
+ strFileRwBuf[i] = 0x00;
+ i = Ret;
+ }
+ else if(strFileRwBuf[i] == 0x2C) // Komma
+ strFileRwBuf[i] = 0x2E; // in Punkt
+ }
+ i = 0;
+ while( (i < 64) && (strFileRwBuf[i] != '=') )
+ {
+ strKeyCode[i] = strFileRwBuf[i];
+ i++;
+ }
+ strKeyCode[i] = 0x00;
+ i++;
+ while( (strFileRwBuf[i] == ' ') && (i < 100) )
+ i++;
+ strcpy(strValue,&strFileRwBuf[i]);
+
+ //printf("KeyCode: %s Value: %s\n", strKeyCode, strValue);
+ for(j = 0;j< ANZ_KEY;j++)
+ {
+ if(strcmp(strKeyCode, IniKey[j]) == 0) // die Strings stimmen überein
+ {
+ (*KeyPtr[j])((char *)(strValue));
+ j = ANZ_KEY;
+ }
+ }
+ }
+ }
+ while(Ret > 0);
+ clSdCard.CloseFile();
+ EcmIni.fCfgExists = true;
+ if(EcmIni.nReInit == 1)
+ {
+ EcmIni.nReInit = 0;
+ InitDefault();
+ WriteIni(); // Default erzeugen
+ }
+
+
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+Defaultwerte für die Inivariablen setzten
+-------------------------------------------------------------------------------*/
+int InitDefault()
+{
+ int i;
+
+ strcpy(EcmIni.DevTyp,"RPA-Device"); // Gerätetyp des Gerätes
+ strcpy(EcmIni.DevSio,"200_xxx"); // Seriennummer des Gerätes
+ strcpy(EcmIni.SwLizenz,"20000_xxx"); // Lizenznummer der Software
+ strcpy(EcmIni.SwRev,SW_REV); // Revisionsnummer der Software
+ strcpy(EcmIni.IpAddress,"192.168.2.1"); // meine IP-Adresse für Netzwerkbetrieb
+ strcpy(EcmIni.SubNet,"255.255.255.0"); // IP-Adresse für Netzwerkbetrieb
+ strcpy(EcmIni.Gateway,"0.0.0.0"); // IP-Adresse für Netzwerkbetrieb
+ strcpy(EcmIni.HostIp,"192.168.2.8"); // IP-Adresse für Netzwerkbetrieb
+
+ EcmIni.nPotCode = 1; // default PGU, Jaissle ist 0x00, 71 ist PGU-Stack
+ EcmIni.nExtStart = 0; // default kein externen Start
+ EcmIni.nSExtChnNr = 0x00; // default Kanalnummer 0 für externen Start
+ EcmIni.nPortNr = 4000; // Default 4000
+ EcmIni.dbRpmOffset = 0.0; // Offsetkorrektur für die Anzeige Drehzahl
+ EcmIni.dbRpmScale = 1.0; // Skalierungswert fuer die Anzeige Drehzahl
+ EcmIni.dbAoScale = 13.107; // Skalierungswert fuer den Analogausgang
+ EcmIni.dbAoOffset = 0.0; // Offset fuer den Analogausgang
+ EcmIni.nReInit = 0; // Flag für Reinitialisierung
+ EcmIni.nNrOff = 0; // Ausschalten der Drehzahlnachführung
+ for(i=0;i<8;i++)
+ {
+ EcmIni.dbUOffset[i] = 0.0;
+ EcmIni.dbUScale[i] = 1.0;
+ }
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+Datei speichern
+-------------------------------------------------------------------------------*/
+int WriteIni()
+{
+ int Ret,i, j;
+
+
+ if(g_SdInitSuccess == false) // wenn SD Karte nicht vorhanden, retour
+ {
+#ifdef TFT_DEBUG
+// printf("SD Card not present\n");
+#endif
+ return(false);
+ }
+
+ Ret = clSdCard.OpenFile(FileNames.IniFileName, FileNames.FileWriteMode);
+
+ if(Ret == false)
+ return(false); // öffnen der Datei hat nicht geklappt
+
+ i= 0;
+ // Methode CI
+
+
+
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.DevTyp); clSdCard.WriteLine(); i++; // DEV_TYP
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n", IniKey[i],EcmIni.nPotCode); clSdCard.WriteLine(); i++; // POT_CODE
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.DevSio); clSdCard.WriteLine(); i++; // SER_NR
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.SwLizenz); clSdCard.WriteLine(); i++; // LZ_NR
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.SwRev); clSdCard.WriteLine(); i++; // REV_NR
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.IpAddress); clSdCard.WriteLine(); i++; // IP_ADR
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.SubNet); clSdCard.WriteLine(); i++; // SUB_NET
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.Gateway); clSdCard.WriteLine(); i++; // GATEWAY
+ sprintf(clSdCard.cSdLine, "%s=%s\r\n", IniKey[i],EcmIni.HostIp); clSdCard.WriteLine(); i++; // HOST_IP
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n", IniKey[i],EcmIni.nPortNr); clSdCard.WriteLine(); i++; // PORT_NO
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n", IniKey[i],EcmIni.nExtStart); clSdCard.WriteLine(); i++; // "EXT_START
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n", IniKey[i],EcmIni.nSExtChnNr); clSdCard.WriteLine(); i++; // "SEXT_CHN_NR
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n", IniKey[i],EcmIni.dbRpmOffset); clSdCard.WriteLine(); i++; //
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n", IniKey[i],EcmIni.dbRpmScale); clSdCard.WriteLine(); i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n", IniKey[i],EcmIni.dbAoScale); clSdCard.WriteLine(); i++;
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n", IniKey[i],EcmIni.dbAoOffset); clSdCard.WriteLine(); i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n", IniKey[i],EcmIni.nReInit); clSdCard.WriteLine(); i++;
+ sprintf(clSdCard.cSdLine, "%s=%d\r\n", IniKey[i],EcmIni.nNrOff); clSdCard.WriteLine(); i++;
+
+ for(i=0, j=18;i<8;i++, j++)
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n", IniKey[j],EcmIni.dbUOffset[i]); clSdCard.WriteLine(); i++;
+ for(i=0, j=26;i<8;i++, j++)
+ sprintf(clSdCard.cSdLine, "%s=%f\r\n", IniKey[j],EcmIni.dbUScale[i]); clSdCard.WriteLine(); i++;
+
+ clSdCard.CloseFile();
+ return(true);
+
+}
+
+
+//--------------------------------------------------------------------------
+// DecDevTyp: Decodieren des Gerätetyps
+//--------------------------------------------------------------------------
+int DecDevTyp(char *Line)
+{
+ strcpy(EcmIni.DevTyp,Line);
+#ifdef TFT_DEBUG
+ printf("DevTyp: %s\n", EcmIni.DevTyp);
+#endif
+ return(true);
+}
+//--------------------------------------------------------------------------
+// DecPotCode: Decodieren
+//--------------------------------------------------------------------------
+int DecPotCode(char *Line)
+{ EcmIni.nPotCode = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecSerNr(char *Line)
+{ strcpy(EcmIni.DevSio,Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecLzNr(char *Line)
+{ strcpy(EcmIni.SwLizenz,Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecRevNr(char *Line)
+{ strcpy(EcmIni.SwRev,Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecIpAddr(char *Line)
+{ strcpy(EcmIni.IpAddress,Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecSubNet(char *Line)
+{ strcpy(EcmIni.SubNet,Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecGateway(char *Line)
+{ strcpy(EcmIni.Gateway,Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecHostIp(char *Line)
+{ strcpy(EcmIni.HostIp,Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecPortNo(char *Line)
+{ EcmIni.nPortNr = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecExtStart(char *Line)
+{ EcmIni.nExtStart = atoi(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecSextChnNr(char *Line)
+{ EcmIni.nSExtChnNr = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecRpmOffset(char *Line)
+{ EcmIni.dbRpmOffset = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecRpmScale(char *Line)
+{ EcmIni.dbRpmScale = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecAoScale(char *Line)
+{ EcmIni.dbAoScale = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecReInit(char *Line)
+{ EcmIni.nReInit = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecNrOff(char *Line)
+{ EcmIni.nNrOff = atoi(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecAoOffset(char *Line)
+{ EcmIni.dbAoOffset = atof(Line);
+ return(true);
+}
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU0Offset(char *Line)
+{ EcmIni.dbUOffset[0] = atof(Line);
+ EcmIni.dbUOffset[0] *= 838860.;
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU1Offset(char *Line)
+{ EcmIni.dbUOffset[1] = atof(Line);
+ EcmIni.dbUOffset[1] *= 838860.;
+ return(true);
+}
+
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU2Offset(char *Line)
+{ EcmIni.dbUOffset[2] = atof(Line);
+ EcmIni.dbUOffset[2] *= 838860.;
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU3Offset(char *Line)
+{ EcmIni.dbUOffset[3] = atof(Line);
+ EcmIni.dbUOffset[3] *= 838860.;
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU4Offset(char *Line)
+{ EcmIni.dbUOffset[4] = atof(Line);
+ EcmIni.dbUOffset[4] *= 838860.;
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU5Offset(char *Line)
+{ EcmIni.dbUOffset[5] = atof(Line);
+ EcmIni.dbUOffset[5] *= 838860.;
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU6Offset(char *Line)
+{ EcmIni.dbUOffset[6] = atof(Line);
+ EcmIni.dbUOffset[6] *= 838860.;
+ return(true);
+}
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU7Offset(char *Line)
+{ EcmIni.dbUOffset[7] = atof(Line);
+ EcmIni.dbUOffset[7] *= 838860.;
+ return(true);
+}
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU0Scale(char *Line)
+{ EcmIni.dbUScale[0] = atof(Line); return(true); }
+
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU1Scale(char *Line)
+{ EcmIni.dbUScale[1] = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU2Scale(char *Line)
+{ EcmIni.dbUScale[2] = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU3Scale(char *Line)
+{ EcmIni.dbUScale[3] = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU4Scale(char *Line)
+{ EcmIni.dbUScale[4] = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU5Scale(char *Line)
+{ EcmIni.dbUScale[5] = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU6Scale(char *Line)
+{ EcmIni.dbUScale[6] = atof(Line); return(true); }
+//--------------------------------------------------------------------------
+// Dec
+//--------------------------------------------------------------------------
+int DecU7Scale(char *Line)
+{ EcmIni.dbUScale[7] = atof(Line); return(true); }
+
+
+
+
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/OpenIni.h Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,93 @@
+/*
+-------------------------------------------------------------------------------
+Programm Name: OpenIni.h
+Version: 1.0
+Sprache: C
+Compiler: MBED
+Autor: PS
+Copyright: PS
+
+
+Funktion: Externdeklarationen für die IniDatei
+-------------------------------------------------------------------------------
+*/
+
+/*===========================================================================
+Die nachfolgende Struktur dient zur Speicherung der Ini-Daten
+===========================================================================*/
+struct EcmIni
+{
+ char DevTyp[32]; // Gerätetyp
+ int nPotCode; // Codierung, welche Hardware angeschlossen ist
+ char DevSio[16]; // Seriennummer des Gerätes
+ char SwLizenz[16]; // Lizenznummer der Software
+ char SwRev[16]; // Revisionsnummer der Software
+ char IpAddress[32]; // eigene IP-Adresse für Netzwerkbetrieb
+ char SubNet[32]; // Sub-Net Mask für Netzwerkbetrieb
+ char Gateway[32]; // IP-Adresse für Gateway
+ int nOnlyTcp;
+ char HostIp[32]; // IP-Adresse für Host
+ int nPortNr; // Portnummer für Ethernet
+ int nExtStart; // wenn true, dann kann ein externer Start über einen Eingangskontakt erfolgten
+ int nSExtChnNr; // Kanalnummer zum Einlesen für externen Start
+ int nAnzChannel;
+ double dbRpmOffset;
+ double dbRpmScale;
+ bool fCfgExists;
+ double dbAoScale;
+ double dbAoOffset;
+ int nReInit;
+ int nNrOff;
+ double dbUOffset[8];
+ double dbUScale[8];
+};
+typedef struct EcmIni ECM_INI;
+
+
+extern char IniKey[50][16];
+
+extern int OpenIni();
+extern int DecodeIniValues(char *Src);
+
+
+extern int InitDefault();
+extern int WriteIni();
+
+
+extern int DecDevTyp(char *Line);
+extern int DecPotCode(char *Line);
+extern int DecSerNr(char *Line);
+extern int DecLzNr(char *Line);
+extern int DecRevNr(char *Line);
+extern int DecIpAddr(char *Line);
+extern int DecSubNet(char *Line);
+extern int DecGateway(char *Line);
+extern int DecHostIp(char *Line);
+extern int DecPortNo(char *Line);
+extern int DecExtStart(char *Line);
+extern int DecSextChnNr(char *Line);
+extern int DecRpmOffset(char *Line);
+extern int DecRpmScale(char *Line);
+extern int DecAoScale(char *Line);
+extern int DecAoOffset(char *Line);
+extern int DecReInit(char *Line);
+extern int DecNrOff(char *Line);
+
+extern int DecU0Offset(char *Line);
+extern int DecU1Offset(char *Line);
+extern int DecU2Offset(char *Line);
+extern int DecU3Offset(char *Line);
+extern int DecU4Offset(char *Line);
+extern int DecU5Offset(char *Line);
+extern int DecU6Offset(char *Line);
+extern int DecU7Offset(char *Line);
+
+extern int DecU0Scale(char *Line);
+extern int DecU1Scale(char *Line);
+extern int DecU2Scale(char *Line);
+extern int DecU3Scale(char *Line);
+extern int DecU4Scale(char *Line);
+extern int DecU5Scale(char *Line);
+extern int DecU6Scale(char *Line);
+extern int DecU7Scale(char *Line);
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/MySources/Struct.h Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,444 @@
+/*-------------------------------------------------------------------------------
+Programm Name: Struct.H
+Version: 1.0
+Sprache: C
+Compiler: CrossStudio Ver. 2.0
+Autor: PS
+Copyright: PS
+
+
+Funktion: Strukturen fuer EcmCom
+
+28.10.2012:
+
+-------------------------------------------------------------------------------*/
+#define UINT8 unsigned char
+#define uint8_t UINT8
+#define UINT16 unsigned int
+#define uint16_t UINT16
+#define uint UINT16
+#define BYTE unsigned char
+#define UINT32 unsigned long
+#define uint32_t unsigned long
+#define INT16 int
+
+#define FALSE false
+#define TRUE true
+
+#define LOW 0
+#define HIGH 1
+
+#define ANZ_POT 2
+#define ANZ_POLY 101
+
+#define GEN_TYP_QST 1
+#define GEN_TYP_FKT 0
+
+
+/*===========================================================================
+Die nachfolgende Struktur dient zur Speicherung der Startup Konfiguration
+===========================================================================*/
+struct StartUp
+{
+ int HwConfig; // KOnfiguration der Hardware
+ int StpConfig; // ohne oder mit seriell to parallel
+
+ int PotAnz; // 0 = 1 Pot. 1 = 2 Pot.
+ int AoInvert[ANZ_POT];
+ float Offset[ANZ_POT];
+ int PotTyp[ANZ_POT]; // 0=Alter, 1=PGU
+ bool fPotActive[ANZ_POT];
+ bool fStartConnection;
+ bool fNoiseMeasurement;
+
+};
+typedef struct StartUp START_UP;
+
+/*===========================================================================
+Die nachfolgende Struktur dient zur Verwaltung der Watchdogfunktion
+===========================================================================*/
+struct strWatchDog
+{
+ int fEnabled; // 0=kein Watchdog, 1=Watchdog aktiv
+ int nTimeOut; // Timeout-Zeit für Watchdog
+ char cSign[8]; // Watchdog Zeichen was vom Host gesendet wird
+ int nCounter;
+ int nMsTimeOut;
+ int fLogFile;
+ int fHandShake;
+};
+typedef struct strWatchDog WATCH_DOG;
+
+/*===========================================================================
+Die nachfolgende Struktur dient zur Speicherung der Messkanaele
+===========================================================================*/
+struct MChn1
+{
+ float VarGalvFaktor; // Variabler Faktor für die Ansteuerung Galvanostat
+
+};
+typedef struct MChn1 M_KANAL;
+
+/*===========================================================================
+ Die nachfolgende Struktur ist für die Meßparameter
+===========================================================================*/
+struct StrMPara
+{
+ int RpDauer[ANZ_POT]; // Dauer der Ruhepotentialmessung
+ int RpDauerVor[ANZ_POT]; // Dauer der Ruhepotentialmessung
+ int RpDauerNach[ANZ_POT]; // Dauer der Ruhepotentialmessung
+ int IBereichPos[ANZ_POT]; // Position im Array
+ float IKritPos[ANZ_POT]; // Positiver Endwert des Kritischen Stromdichtebereiches
+ float IKritNeg[ANZ_POT]; // Negativer Endwert des Kritischen Stromdichtebereiches
+ int UKritPos[ANZ_POT]; // Positiver Endwert des Potential bei Galvanostat
+ int UKritNeg[ANZ_POT]; // Negativer Endwert des Potential bei Galvanostat
+ int GrenzVerhalten[ANZ_POT]; // Verhalten bei Grenzwertüberschreitung
+ float ProbenGroesse[ANZ_POT]; // Größe der Probe
+ float dUdTRpEnde[ANZ_POT]; // dU/dt für Rp-Ende
+ double SMax[ANZ_POT]; // für Galvanostat
+ int PolarisationsStart[ANZ_POT];// Start der Polarisation absolut oder relativ
+};
+typedef struct StrMPara MESS_PARAMETER;
+
+/*===========================================================================
+Struktur Deklaration für die Quasistationäre Funktion
+===========================================================================*/
+struct strQst1 {
+ int StartPotential;
+ int EndPotential;
+ float StufenHoehe;
+ float StufenDauer;
+ int AufAb;
+ int StartWertRelativ;
+ int AnzZyklen;
+ float flW_StartPotential; // Variable zum arbeiten
+ float flW_EndPotential; // Variable zum arbeiten
+ float flW_StufenHoehe[2]; // Variable zum arbeiten
+ long nW_StufenDauer;
+ int nW_Richtung;
+ int nW_StepCounter;
+ };
+typedef struct strQst1 QST_DATEN;
+
+/*===========================================================================
+ Struktur Definition für die Frequenzwerte and den DDS
+===========================================================================*/
+struct strFrqValues
+{
+ BYTE OutH0, OutH1;
+ BYTE OutL0, OutL1;
+ BYTE Clock;
+ int nFilterAuto;
+ BYTE AdControlLow; // 0x00=Sinus, 0x02 = Dreieck
+ bool fImpedance;
+ BYTE V1, V2, Mux;
+ bool fSendEnable;
+ uint16_t nAktAmplitude;
+ uint16_t nLastAmplitude;
+};
+typedef struct strFrqValues FRQ_VALUES;
+
+/*===========================================================================
+ Struktur zum Speichern der Generatorwerte
+===========================================================================*/
+struct FktStr2
+{
+ int AnzPoly; // Anzahl der Polygone einer Fuktion
+ long nAnzZyklus; // Anzahl der Zyklen
+ long ZyklusStartPunkt; // Einstiegspunkt für den Zyklus
+ int PolyNummer[ANZ_POLY+1]; // Satznummer
+ double ZeitWert[ANZ_POLY+1];// Abs. Zeitwerte der Polygone
+ float SpngWert[ANZ_POLY+1]; // Programmierter Spannungsw. der Polygone
+ double ScanRate[ANZ_POLY+1]; // Scanrate in mV/s
+ int ScanRichtung[ANZ_POLY+1]; // Richtung auf/ab/Sprung/Haltepot.
+ float RealSpngWert[ANZ_POLY+1]; // Tatsächlicher Spannungsw. der Polygone
+
+ double Schritt[ANZ_POLY+2];
+ unsigned long Count[ANZ_POLY+2];
+ int GenActive;
+ long ZCount; // Zähler für Zyklus während der Messung
+ double GenVal;
+ int SetVal; // Der aktuell zu setztende Integer-Wert
+ int LastSetVal; // Der zuletzt gesetzte Integer-Wert
+ float MaxUS, MinUS;
+ float MaxTime;
+ int StartWertRelativ;
+ int FolgeWerteRelativ;
+ float flZyklusOffset;
+ int nZlOffsetMode;
+ float flScanOffset;
+ int VpStatus; // wird vorpolarisiert, dann muá das eingearbeitet werden
+ UINT16 nAktZyklus;
+};
+typedef struct FktStr2 FKT_WERTE;
+
+/*===========================================================================
+Struktur Deklaration für die Scanner Variablen
+===========================================================================*/
+struct strScanVal
+{
+ unsigned long GenCount;
+ int GenPos;
+ int Skiped;
+ int Vz;
+ bool SetStop;
+ bool fNewCycle;
+ float MaxUValue;
+ float MinUValue;
+ int AoMinWert, AoMaxWert;
+};
+typedef struct strScanVal SCAN_VAL;
+/*===========================================================================
+Struktur Deklaration für die Puls Variablen. Übernimmt die Pulswerte aus dem
+Datentelegramm und hält die Werte ohne das sie vom Programm verändert werden
+===========================================================================*/
+struct strPulsValue
+{
+ int nPulsCounter;
+ int nPulsPauseCounter;
+ float flPulsStartPot;
+ float flUpperPulsValue;
+ float flLowerPulsValue;
+ long nAnzPulsUp;
+ long nAnzPulsDown;
+ float flPulsOffset;
+};
+typedef struct strPulsValue PULS_VALUE;
+
+/*===========================================================================
+Struktur Deklaration für Puls Variablen. Diese Strukturvariablen dienen zum
+Arbeiten, können verändert werden und müssen im Bedarfsfalls aus den Basisdaten
+neu geladen werden
+===========================================================================*/
+struct strPulsWorkValue
+{
+ int nPulsCounter;
+ int nPulsPauseCounter;
+ float flUpperPulsValue;
+ float flLowerPulsValue;
+ float flPulsStartPot;
+ long nAnzPulsUp;
+ long nAnzPulsDown;
+ float flPulsOffset;
+ bool nPulsState;
+};
+typedef struct strPulsWorkValue PULS_WORK_VALUES;
+
+
+/*===========================================================================
+ Die nachfolgende Struktur ist für Variablen, die während der Messung
+ von allen Messmodulen benötigt werden. Eine solche Struktur sollte für
+ jeden zu messenden Potentiostaten separat angelegt werden. So läßt sich
+ das Messen besser für Parallel-Messungen erweitern.
+===========================================================================*/
+struct StrMVariables
+{
+ int BetriebsArt; // Potentiostat=0, Galvanostat=1
+ int Circuit; // OLP=0, I-Zelle = 1, Messung Ende = 2
+ float flAktIRange; // Aktueller Max-Strom in mA
+ float RangeFaktor;
+ float IAktInVolt;
+ int GenDateiTyp; // normal oder QST
+ int m_nReversePotential;
+ int m_nLastPotential;
+ int nMessArt;
+ int nReversed;
+
+};
+typedef struct StrMVariables MESS_VARIABLES;
+
+/*===========================================================================
+ Die nachfolgende Struktur ist für Variablen, die der I-Bereichsprüfung und
+ Umschaltung dienen.
+===========================================================================
+struct StrIRange
+{
+ int RangeAnz[ANZ_POT];
+ int AktRange[ANZ_POT];
+ int nIRangeMax[ANZ_POT];
+ int nIRangeMin[ANZ_POT];
+ UINT32 lIMax[ANZ_POT];
+ UINT32 lIMin[ANZ_POT];
+ UINT32 lIMaxCompare[ANZ_POT];
+ UINT32 lIMinCompare[ANZ_POT];
+
+ int TempRange;
+ int AutoRange[ANZ_POT]; // 0=aktiv, 1=nicht aktiv
+ int IDownCount[ANZ_POT];
+ bool m_fIRangeSwitchedUp[ANZ_POT];
+ BYTE RangeValue[ANZ_POT];
+ int Iz1, Iz2;
+ float I1, I2;
+ float IInVolt[ANZ_POT];
+ bool m_fCheckRange;
+ bool m_fAussenStromLos;
+};
+typedef struct StrIRange I_RANGE;
+*/
+/*===========================================================================
+ Struktur Definition der Werte für die Änderung der Senderate während der Messung
+===========================================================================*/
+struct NewScanRate
+{
+ int nNewSendeRate;
+ bool fFallBack; // nach einer bestimmten Anzahl zurücksetzen
+ int nFallBackTime; // zurück zur alten Einstellung nach n Sekunden
+ int nNewAutoRange;
+ int nNewRange; // neuer Bereich, wenn nicht -1 dann setzen
+ int nOldSendAnzWerte;
+ int nOldAutoRange;
+ int nOldIntervall;
+ int nExtSigOnOff;
+ int n2ndExtSigOnOff;
+};
+typedef struct NewScanRate NEW_SCAN_RATE;
+
+
+/*===========================================================================
+ Struktur Definition von MessVariables
+===========================================================================*/
+struct MessVariables
+{
+
+ int MwChn[16];
+ int SwitchChn[4];
+ bool m_fChnValid[16]; // Sagt, welcher Kanal übertragen wird, es werden 16 übertragen
+ int ZInfo[2]; // liefert dem Hauptrechner die Info, wo der Messablauf ist
+
+ int nAnzahlSchritte; // Anzahl der Schritte pro Sekunde
+ float FrkValue[ANZ_POT];
+
+ int SendAnzWerte; // Anzahl Werte, die pro Sekunden gesendet werden
+ int SendAnzSave; // Zwischenspeicher fuer das Sendintervall
+// int m_nStoreMwIntervall; // Zeitabstand, in dem die Messwerte gespeichert werden
+ int m_nAnzChnSend; // Zählt die Kanäle die gesendet werden
+ int m_nSendValues; // das Senden von Single-Messdaten wird mit 1, Cont.Messdaten mit 2 freigegeben
+ int nMessZustand[ANZ_POT];
+ int nOldZustand[ANZ_POT];
+
+//------------------------------------------------------------------------------
+
+ long double dbAdSum[ANZ_POT*4];
+ double dbAdResult[ANZ_POT*4];
+ int nChnAverage[ANZ_POT*4];
+
+ long nMwMittelCount; // wird nach jedem erfolgreichen Lesen des A/D Wandlers incrementiert
+ int nMittelTimer; // zählt die Zeit, über die bisher gemittelt wurde
+ int nMittelAfter; // ist die Zeit in ms, nach der gemäß der Anzahl der Werte eine Mittelung durchgeführt wird
+ int nAktMittelAfter; // ist der aktuelle Wert nach dem gemittelt wird
+ int nSendTimer; // zählt die Zeit zwischen dem senden der Werte
+ int nDaTimer; // zählt die Zeit zwischen der DA Wandlung
+ int nSendAfter; // ist die Zeit in ms, nach der die Daten gesendet werden
+ int nDestCount; // zählt die Werte im Zielpuffer der versendet wird
+ bool m_fStartTel; // sagt, daß ein STX mit MW gesendet werden muss
+ int m_nAnzValue;
+ int nTelLen;
+ bool m_fSendStatus;
+ bool m_fPotGal;
+ bool m_fDoFinishMeasurement;
+ bool m_fFinishMeasurement;
+ bool m_fMeasurementFinished;
+ bool m_fDisableStopTel;
+
+// int nMwMittelVal; // ist der Endwert, nachdem gesendet wird
+ int nSecCounter[2];
+ bool m_fScan; // Flag zum aktivieren des Scanners
+ bool m_fScanPuls;
+ bool m_fPulsMessung;
+ bool m_fQstMessung;
+ bool m_fCellSwitchOff;
+ bool m_fChangeMittelValue;
+ bool fAdReInit;
+ int m_nSendAnz;
+ int nSwapNr; // Nummer des Puffers in den die aktuellen Messdaten geschrieben werden
+
+ int Frk1, Frk2;
+ float Fr1, Fr2;
+ int m_nSendStart;
+ int m_nSendEnd; // beginnt wieder von vorne
+ int nMwPerBlock;
+ int fTelStart;
+ int nBlockCount;
+ int nIpsDebug;
+ uint8_t CsSpiMask;
+// Ports für den I/O Zugriff
+ uint16_t nRefPort;
+ uint8_t nCurrentPort;
+ uint8_t nRingPort;
+ uint8_t nExtPort;
+ uint8_t nGenPort;
+ uint8_t nNoisePort;
+
+ uint8_t nUGain;
+ uint8_t nIGain;
+ uint8_t CsOff;
+ uint8_t IrKompPort;
+ int m_fMessDlgOpened;
+ uint8_t AdConvTime;
+ bool fChangeCt;
+ int nKurveForm;
+
+ int nMwMittelVal;
+ int m_nStoreMwIntervall;
+
+
+ int nMessArt;
+ int nMessTimer;
+ bool fSequenzMessung;
+ uint8_t fEnableAuto; // wenn true, dann wir Enable Autorange gesetzt
+ int nAnzPot;
+
+};
+typedef struct MessVariables MESS_VARS;
+
+/*===========================================================================
+ Struktur Speichern der der A/D Daten
+===========================================================================*/
+struct AnalogDigital
+{
+ double AdResult[8][16]; // wird auch fuer den digitalen Filter verwendet
+ UINT32 AdRingBuf[8][1024];
+ long AdTempU, AdTempU1, AdTempI, AdDiff;
+ double FKoeff[11];
+ uint8_t nStartFk, nEndeFk;
+ double dbUFkResult, dbIFkResult;
+ double dbUNoiseGainFaktor, dbINoiseGainFaktor;
+};
+typedef struct AnalogDigital AD_VAL;
+
+
+/*===========================================================================
+ Struktur für das IR-Handling
+===========================================================================*/
+struct IrCompensation
+{
+ double dbRArray[8];
+ uint8_t nRIndex;
+ bool fMitIrValue;
+ bool fMosFetState;
+ bool fMosFetOpen;
+ bool fWaitForIrVoltage;
+ bool fSendInfo;
+ bool fIrInProcess;
+ bool fCalculate;
+
+ double dbIrValue[16], dbRValue, dbOldRValue;
+ double dbIrAddVoltage, dbKorrVoltage;
+
+ double dbUDiffValue, dbLastIValue, dbUScale;
+ uint8_t nIChn, nUChn;
+ double dbAOut[2];
+ double dbDiv, dbUDisplay; // zum Berechnen der Spannung
+ uint16_t nMosFetCounter;
+ uint8_t n100msCounter; // wird alle 100ms incrementiert, Zeitfenster für die IR-Unterbrechung
+ uint8_t nOffCount;
+ uint8_t nOffSollCount;
+ uint16_t nSollCounter;
+ uint8_t nStartupCounter;
+ uint8_t nDistanceCounter;
+ uint8_t nSkipCounter;
+
+};
+typedef struct IrCompensation IR_COMP;
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/RawSerial/IfGlobals.cpp Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,19 @@ +/*------------------------------------------------------------------------------- +Programm Name: SioGlobals.cpp +Version: 1.0 +Sprache: C++ +Compiler: mbed +Autor: PS +Copyright: PS + + +Funktion: Globale Kommunikations-Variablen und Methoden + +-------------------------------------------------------------------------------*/ +#include "Headers.h" + + +HOST_INTERFACE HostIf; // Struktur mit Variablen zur Kommunikation mit EcmWin + +char STemp[128]; +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RawSerial/IfGlobals.h Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,72 @@
+/*-------------------------------------------------------------------------------
+Programm Name: SioGlobals.h
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Globale Kommunikations-Variablen und Methoden
+
+-------------------------------------------------------------------------------*/
+
+#define STX 0x21
+#define ETX 0x7C
+
+#define MCU_EOF 0x7D // } MyEndOfFile
+#define REPLACE_LF 0x24 // $
+#define REPLACE_LATTEN_ZAUN '#'
+#define SEND_BUF_LEN 4096
+#define TEMP_BUF_LEN 1024
+#define MSG_BUF_LEN 256
+
+/*===========================================================================
+ Struktur f�r das Kommunikationshandling zwischen EcmWin und der Firmware
+ Es kann sich dabei um eine RS232, Ethernet oder in Zukunft ev. auch um ein
+ USB Interface handeln
+===========================================================================*/
+struct HostInterface
+{
+ char strRecBuf[SEND_BUF_LEN]; // Empfangspuffer fuer die eingehenden Zeichen
+ int nRecStartPos;
+ int nRecEndPos;
+ int nEtxPos;
+ int nInTel;
+ char strTelAwBuf[SEND_BUF_LEN]; // Puffer zum Auswerten des gesendeten Telegrammes
+
+ char TelCode[8];
+ int nTelLen;
+ char *ptrTelPos;
+
+ char strTempBuf[TEMP_BUF_LEN];
+ char strFinalSendBuf[SEND_BUF_LEN];
+ char strCommonTmpBuf[SEND_BUF_LEN];
+ char strMessageBuf[MSG_BUF_LEN];
+ char strErrorBuf[MSG_BUF_LEN];
+ int nAwTelLen;
+
+ int nRecInPos;
+ bool fStartTel;
+// bool fConnect, fEthInitDone, fEthConnect,fAfterBind, fAfterCheckWait, fEcmWinIsConnected, fEcmWinStartClose, fEcmWaitForRequest;
+ int fSendStatus;
+ int nDisconnectCounter;
+ bool fIsConnected;
+ bool fAfterCheckWait;
+ bool fEcmWinIsConnected;
+ bool fEcmWinStartClose;
+ bool fAfterBind;
+ bool fAfterOpen;
+ bool fEcmWaitForRequest;
+ bool fSendMessage, fSendError;
+};
+typedef struct HostInterface HOST_INTERFACE;
+
+// ETH_IN_OUT;
+
+
+extern HOST_INTERFACE HostIf;
+
+extern char STemp[128];
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RawSerial/RpaSerial.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,122 @@
+/*-------------------------------------------------------------------------------
+Programm Name: RpaSerial.cpp
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autor: PS
+Copyright: PS
+
+
+Funktion: Serial Funktions fuer Comm
+04.08.2016: Projekt:
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+
+RawSerial RpaDev(USBTX, USBRX);
+int RawChar;
+unsigned char Rc;
+static int m_nLedCount;
+
+/*-------------------------------------------------------------------------------
+Folgendes ist zu beachten:
+Die meisten Telegramme, die von EcmWin kommen, sind kurz, sie passen in einen
+typischen Empfangspuffer mit 2048 Byte.
+Werden jedoch Konfigurationsdaten oder Sequenzdateien uebertragen, dann koennen die
+Telegramme auch laenger sein. Hier muss vorgesorgt werden, sonst kommt es zu einem Chrash.
+Von EcmWin aus muessen die Daten in Bloecken geschickt werden, jeder Block muss eine
+STX und ein ETX haben. Die Firmware wiederum muss wissen, ob es sich um ein laengeres
+Telegramm handelt. Dies kann durch mitsenden eine zweiten Zeichens geschehen,
+trotzdem muss sich die Firmware merken, ob es sich um ein Starttelegramm oder um ein
+Folgetelegramm handelt. Z.B. wird bei der Uebertragun einer Ini-Datei mit dem ersten
+Telegramm die Datei geoeffnet, die Folgetegramme muessen einfach nur geschrieben und
+mit dem letzten Telegramm muss die Ini-Datei geschlossen werden.
+-------------------------------------------------------------------------------*/
+void SioCallback()
+{
+ // Note: you need to actually read from the serial to clear the RX interrupt
+ RawChar = RpaDev.getc();
+ Rc = (unsigned char)RawChar & 0x00FF;
+ HostIf.strRecBuf[HostIf.nRecEndPos] = Rc;
+ if(Rc == ETX) // Telegramm ist vollständig
+ {
+ HostIf.nInTel++; //
+ HostIf.nEtxPos = HostIf.nRecEndPos; // merken, falls waehrend der Verarbeitung ein weiterer IRQ kommt
+ HostIf.nEtxPos &= 0x7FF; // steht jetzt auf der Pos. hinter dem letzten Zeichen
+ }
+ HostIf.nRecEndPos++;
+ HostIf.nRecEndPos &= 0x7FF; // steht jetzt auf der Pos. hinter dem letzten Zeichen
+
+}
+/*-------------------------------------------------------------------------------
+InitInterface: Ist eine zentrale Methode. Fuer RS232 wird die serielle Schnittstelle
+initialisiert, fuer das Ethernet Interface wird Ethernet und Thread initialisiert
+-------------------------------------------------------------------------------*/
+int InitInterface()
+{
+ InitRawSio(); // ganz nach vorne, damit die Debug Ausgabe auch funktioniert
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+int InitRawSio()
+{
+ RpaDev.baud(115200);
+ HostIf.nRecStartPos = 0; // Zeigt auf den Telegrammanfang
+ HostIf.nRecEndPos = 0; // zu Beginn ist der Anfang gleich dem Ende
+ HostIf.nEtxPos = 0;
+ HostIf.fIsConnected = false;
+ HostIf.nInTel = 0;
+ HostIf.fSendMessage = false;
+ HostIf.fSendError = false;
+ RpaDev.attach(&SioCallback);
+ return(true);
+}
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+int TransferSioTel()
+{
+ int i, j;
+
+ for(i=HostIf.nRecStartPos, j=0;i != HostIf.nEtxPos;i++, j++)
+ {
+ i &= 0x7FF;
+ HostIf.strTelAwBuf[j] = HostIf.strRecBuf[i];
+ }
+
+ HostIf.strTelAwBuf[j] = ETX;
+ HostIf.strTelAwBuf[j+1] = 0x00;
+ HostIf.nAwTelLen = j+1;
+ i &= 0x7FF;
+ HostIf.nRecStartPos = i;
+
+ if(HostIf.nInTel > 0)
+ HostIf.nInTel--;
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------*/
+int ChangeLedColor()
+{
+ LedGreen = false;
+ LedBlue = false;
+ LedRed = false; // PTB22
+ if(m_nLedCount == 0)
+ {
+ LedGreen = true;
+ m_nLedCount++;
+ }
+ else if(m_nLedCount == 1)
+ {
+ LedBlue = true;
+ m_nLedCount++;
+ }
+ else // if(LedCount == 2)
+ {
+ LedRed = true;
+ m_nLedCount = 0;
+ }
+ return(true);
+
+}
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/RawSerial/RpaSerial.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,21 @@ +/*------------------------------------------------------------------------------- +Programm Name: RpaSerial.h +Version: 1.0 +Sprache: C++ +Compiler: mbed +Autor: PS +Copyright: PS + + +Funktion: Serial Funktions fuer Comm +04.08.2016: Projekt: +-------------------------------------------------------------------------------*/ + +extern RawSerial RpaDev; + +extern int InitInterface(); + +extern int InitRawSio(); +extern int TransferSioTel(); +extern int ChangeLedColor(); +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RawSerial/SendTelToHost.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,381 @@
+/*-------------------------------------------------------------------------------
+Programm Name: SendTelToHost.cpp
+Version: 1.0
+Sprache: C
+Compiler: mbed Ver. 5.0
+Autor: PS
+Copyright: PS
+
+Funktion: Sendet die Telegramme an den EcmWin Rechner
+28.10.2012:
+-------------------------------------------------------------------------------*/
+#include "Headers.h"
+
+/*-------------------------------------------------------------------------------
+SendAnalogValues: Schickt was fertig ist
+-------------------------------------------------------------------------------*/
+int SendAnalogValues()
+{
+#ifdef PGU_EDUCATION
+ SendAnalogFromEdu();
+#endif
+#ifdef PGU_RPA
+ SendRpaAnalogValues();
+#else
+ SendAnalogFromTouch();
+#endif
+ return(true);
+}
+
+/*-------------------------------------------------------------------------------
+SendAnalogValues: Schickt was fertig ist
+-------------------------------------------------------------------------------*/
+int SendAnalogFromEdu()
+{
+ int j, Ret;
+
+ Ret = false;
+ if(MVars.m_fStartTel == 0x01) // STX schicken
+ {
+ if(MVars.m_fFinishMeasurement == true)
+ {
+ MVars.nMessZustand[0] = 0;
+ MVars.m_fSendStatus = true;
+ MVars.m_fFinishMeasurement = false;
+ MVars.m_fMeasurementFinished = true;
+ }
+
+ if(MVars.m_fSendStatus == true) // Status senden
+ SendStatus();
+ if(HostIf.fSendMessage == true) // Status senden
+ {
+ HostIf.fSendMessage = false;
+ RpaDev.puts(HostIf.strMessageBuf);
+ }
+ if(HostIf.fSendError == true) // Status senden
+ {
+ HostIf.fSendError = false;
+ RpaDev.puts(HostIf.strErrorBuf);
+ }
+
+ MVars.nTelLen = sprintf(STemp,"%c#MW#%d#",STX,MVars.m_nAnzValue);
+ strcpy(HostIf.strTempBuf, STemp);
+ MVars.m_fStartTel = 0x00;
+ }
+
+ for(j=0;j<2;j++)
+ {
+ if(MVars.m_fChnValid[j] == true)
+ {
+ MVars.nTelLen += sprintf(STemp,"%06lu#",(UINT32)MVars.dbAdResult[j]);
+ strcat(HostIf.strTempBuf, STemp);
+ }
+ }
+ MVars.m_nSendAnz++;
+ if(MVars.m_nSendAnz >= MVars.m_nAnzValue)
+ {
+ MVars.nTelLen += sprintf(STemp,"%c",ETX);
+ strcat(HostIf.strTempBuf, STemp);
+ MVars.m_fStartTel = 0x01;
+ MVars.m_nSendAnz = 0;
+ if(MVars.m_fMeasurementFinished == true)
+ {
+ SetMessungEnde();
+ }
+#ifndef PGU_RPA
+ if(g_fDoCheckIRange == true)
+ {
+ CheckIRange();
+ g_fDoCheckIRange = false;
+ }
+#endif
+ Ret = true;
+ }
+ if(MVars.m_nSendValues == 2) // senden während Messung
+ {
+// if(g_fDisableSendMw == false)
+ RpaDev.puts((const char *)HostIf.strTempBuf);
+ MVars.nTelLen = 0;
+ HostIf.strTempBuf[0] = 0x00;
+ }
+ else
+ {
+// if(g_fDisableSendMw == false)
+ RpaDev.puts(HostIf.strTempBuf);
+ MVars.nDestCount = 0;
+ HostIf.strTempBuf[0] = 0x00;
+ }
+
+ return(Ret);
+}
+
+
+/*-------------------------------------------------------------------------------
+SendAnalogValues: Schickt was fertig ist
+-------------------------------------------------------------------------------*/
+int SendAnalogFromTouch()
+{
+ int j, Ret;
+
+#ifndef PGU_RPA
+ if(MVars.m_fMessDlgOpened == false)
+ return(true); // wenn im Config Mode, keine Messtelegramme schicken
+
+ Ret = false;
+ if(MVars.m_fStartTel == 0x01) // STX schicken
+ {
+ if(MVars.m_fFinishMeasurement == true)
+ {
+// MVars.nMessZustand[0] = 0;
+ MVars.m_fSendStatus = true;
+ MVars.m_fFinishMeasurement = false;
+ MVars.m_fMeasurementFinished = true;
+ }
+ if(HostIf.fIsConnected == false) // hat keine Verbindung hergestellt
+ return(true);
+ if(g_nSendDisableTimer > 0)
+ return(true);
+
+// CheckIRange(); // wenn er hier umschaltet, dann ist der SendDisableTimer > 0 und ein Status wird gesendet
+ if(MVars.m_fSendStatus == true) // Status senden
+ {
+ SendStatus();
+ if(g_nSendDisableTimer > 0)
+ return(true);
+ }
+ if(IrComp.fSendInfo == true)
+ {
+ SendInfo();
+ IrComp.fSendInfo = false;
+ }
+ if(HostIf.fSendMessage == true) // Status senden
+ {
+ HostIf.fSendMessage = false;
+ RpaDev.puts(HostIf.strMessageBuf);
+ }
+ if(HostIf.fSendError == true) // Status senden
+ {
+ HostIf.fSendError = false;
+ RpaDev.puts(HostIf.strErrorBuf);
+ }
+
+ MVars.nTelLen = sprintf(STemp,"%c#MW#%d#",STX,MVars.m_nAnzValue);
+ strcpy(HostIf.strTempBuf, STemp);
+ MVars.m_fStartTel = 0x00;
+ }
+
+ for(j=0;j<2;j++)
+ {
+ if(MVars.m_fChnValid[j] == true)
+ {
+ MVars.nTelLen += sprintf(STemp,"%08lu#",(UINT32)AdVal->AdResult[j][g_nAdCount]);
+ strcat(HostIf.strTempBuf, STemp);
+#ifdef TFT_DEBUG
+// printf ("Buf:%s Val:%f j:%d Pos:%d \n",STemp, AdVal->AdResult[j][g_nAdCount], j, g_nAdCount );
+#endif
+ }
+ }
+ if(MVars.m_fChnValid[2] == true)
+ {
+ MVars.nTelLen += sprintf(STemp,"%08lu#",(UINT32)AdVal->dbUFkResult);
+ strcat(HostIf.strTempBuf, STemp);
+ }
+ if(MVars.m_fChnValid[3] == true)
+ {
+ MVars.nTelLen += sprintf(STemp,"%08lu#",(UINT32)AdVal->dbIFkResult);
+ strcat(HostIf.strTempBuf, STemp);
+ }
+
+ MVars.m_nSendAnz++;
+ if(MVars.m_nSendAnz >= MVars.m_nAnzValue)
+ {
+// sprintf(STemp,"%d#%d#%c\r\n",g_fAd0State, g_fAd1State,ETX);
+ MVars.nTelLen += sprintf(STemp,"%c\r\n",ETX);
+ strcat(HostIf.strTempBuf, STemp);
+ MVars.m_fStartTel = 0x01;
+ MVars.m_nSendAnz = 0;
+ if(MVars.m_fMeasurementFinished == true)
+ {
+ SetMessungEnde();
+ }
+ Ret = true;
+ }
+ if(MVars.m_nSendValues == 2) // senden während Messung
+ {
+ if(g_fDisableSendMw == false)
+ RpaDev.puts((const char *)HostIf.strTempBuf);
+ MVars.nTelLen = 0;
+ HostIf.strTempBuf[0] = 0x00;
+ }
+ else
+ {
+ if(g_fDisableSendMw == false)
+ RpaDev.puts(HostIf.strTempBuf);
+ MVars.nDestCount = 0;
+ HostIf.strTempBuf[0] = 0x00;
+ }
+#endif
+ return(Ret);
+}
+
+//-----------------------------------------------------------------------
+// SendStatus: Senden des Status, da sich etwas geändert hat
+//-----------------------------------------------------------------------
+void SendStatus(void)
+{
+#ifdef PGU_RPA
+ SendRpaStatus();
+#else
+ sprintf(HostIf.strTempBuf,"%c#ST#%d#%d#%d#%d#%d#%c\r\n",STX,MVars.nMessZustand[0], IRange.AktRange[0], GenW[0].nAktZyklus,IRange.m_fCheckRange,MVars.m_fPotGal,ETX);
+ MVars.m_fSendStatus = false;
+ RpaDev.puts(HostIf.strTempBuf);
+#endif
+}
+//-----------------------------------------------------------------------
+// SendInfo: Senden des Infotelegramms
+//-----------------------------------------------------------------------
+void SendInfo(void)
+{
+ IrComp.fSendInfo = false;
+ RpaDev.puts(HostIf.strTempBuf);
+}/*-------------------------------------------------------------------------------
+SendAnalogValues: Schickt was fertig ist
+-------------------------------------------------------------------------------*/
+int SendRpaAnalogValues()
+{
+ int j, Ret;
+
+ Ret = false;
+ if(MVars.m_fStartTel == 0x01) // STX schicken
+ {
+ if(MVars.m_fFinishMeasurement == true)
+ {
+ MVars.nMessZustand[0] = 0;
+ MVars.m_fSendStatus = true;
+ MVars.m_fFinishMeasurement = false;
+ MVars.m_fMeasurementFinished = true;
+ }
+
+ if(MVars.m_fSendStatus == true) // Status senden
+ {
+ SendStatus();
+ HostIf.strTempBuf[0] = 0x00;
+ }
+ if(HostIf.fSendMessage == true) // Status senden
+ {
+ HostIf.fSendMessage = false;
+ RpaDev.puts(HostIf.strMessageBuf);
+ }
+ if(HostIf.fSendError == true) // Status senden
+ {
+ HostIf.fSendError = false;
+ RpaDev.puts(HostIf.strErrorBuf);
+ }
+
+ MVars.nTelLen = sprintf(STemp,"%c#MW#%d#",STX,MVars.m_nAnzValue);
+ strcat(HostIf.strTempBuf, STemp);
+ MVars.m_fStartTel = 0x00;
+ }
+
+ for(j=0;j<3;j++)
+ {
+ if(MVars.m_fChnValid[j] == true)
+ {
+ MVars.nTelLen += sprintf(STemp,"%08u#",(UINT32)MVars.dbAdResult[j]);
+#ifdef TFT_DEBUG
+// printf("AdResult_x: %f STemp: %s \n",MVars.dbAdResult[j], STemp);
+#endif
+ strcat(HostIf.strTempBuf, STemp);
+ }
+ }
+ MVars.m_nSendAnz++;
+ if(MVars.m_nSendAnz >= MVars.m_nAnzValue)
+ {
+// sprintf(STemp,"%d#%d#%c\r\n",g_fAd0State, g_fAd1State,ETX);
+ MVars.nTelLen += sprintf(STemp,"%c",ETX);
+ strcat(HostIf.strTempBuf, STemp);
+ MVars.m_fStartTel = 0x01;
+ MVars.m_nSendAnz = 0;
+ if(MVars.m_fMeasurementFinished == true)
+ {
+ SetMessungEnde();
+ }
+ Ret = true;
+ }
+ if(MVars.m_nSendValues == 2) // senden während Messung
+ {
+ RpaDev.puts((const char *)HostIf.strTempBuf);
+ MVars.nTelLen = 0;
+ HostIf.strTempBuf[0] = 0x00;
+ }
+ else
+ {
+ RpaDev.puts(HostIf.strTempBuf);
+ MVars.nDestCount = 0;
+ HostIf.strTempBuf[0] = 0x00;
+ }
+ return(Ret);
+}
+//-----------------------------------------------------------------------
+// SendStatus: Senden des Status, da sich etwas geändert hat
+//-----------------------------------------------------------------------
+void SendRpaStatus(void)
+{
+
+ sprintf(HostIf.strTempBuf,"%c#ST#%d#%c",STX,MVars.nMessZustand[0], ETX);
+ MVars.m_fSendStatus = false;
+ RpaDev.puts(HostIf.strTempBuf);
+}
+
+/*-----------------------------------------------------------------------
+// SendTelToHost: Sendemethode fuer alle Telegramme. Die rufende Methode
+uebergibt des zu sendenden String.
+Findet sich in dem String ein CR, dann wird das uebersprungen. Findet sich ein
+LF, dann wird dies durch ein $ ersetzt. Folgen weitere Telegramme zu einem
+Funktionsblock, dann wird kein ETX gesendet.
+Handelt es sich um laengere Telegramme wie z.B. um Messdateien, dann werden
+groessere Bloecke mit Kennung, STX und ETX gesendet. Das letzte Telegramm bekommt
+dann eine EOF vor das ETX, damit kann das Zielsystem erkennen, das die Datei
+fertig ist.
+-----------------------------------------------------------------------*/
+void SendTelToHost(bool fMoreThanOne, bool fEof, int fReplace)
+{
+ int Len, i, j, k;
+
+ Len = strlen(HostIf.strTempBuf);
+ j = 0; // zur Sicherheit
+ for(i=0, j=0, k=0;i<Len;i++, j++)
+ {
+ if(HostIf.strTempBuf[i] == 0x0D) j--; // das naechste j++ wird ausgeglichen
+ else if(HostIf.strTempBuf[i] == 0x0A)
+ {
+ if(fReplace == 0)
+ HostIf.strFinalSendBuf[j] = REPLACE_LATTEN_ZAUN; // Zeilenende wird mit # gekennzeichnet
+ else if(fReplace == 1)
+ HostIf.strFinalSendBuf[j] = REPLACE_LF; // Zeilenende wird mit $ gekennzeichnet
+ else
+ HostIf.strFinalSendBuf[j] = HostIf.strTempBuf[i];
+ }
+ else
+ HostIf.strFinalSendBuf[j] = HostIf.strTempBuf[i];
+
+ }
+ if(fMoreThanOne == true)
+ {
+ HostIf.strFinalSendBuf[j] = 0x00; // kein ETX, es geht weiter
+ }
+ else
+ {
+ if(fEof == true) // war eine grosse Datei, muss mit EOF gesendet werden
+ {
+ HostIf.strFinalSendBuf[j] = MCU_EOF; j++;
+ }
+ if(Len == 0) j = 0;
+ HostIf.strFinalSendBuf[j] = ETX;
+ HostIf.strFinalSendBuf[j+1] = 0x00;
+ }
+ RpaDev.puts((const char *)HostIf.strFinalSendBuf);
+#ifdef TFT_DEBUG
+// printf("WriteFile is: %s\n",TcpSendBuf);
+#endif
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/RawSerial/SendTelToHost.h Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,21 @@ +/*------------------------------------------------------------------------------- +Programm Name: SendTelToHost.h +Version: 1.0 +Sprache: C +Compiler: mbed Ver. 5.0 +Autor: PS +Copyright: PS + +Funktion: Sendet die Telegramme an den EcmWin Rechner +28.10.2012: +-------------------------------------------------------------------------------*/ + + +extern int SendAnalogValues(); +extern int SendAnalogFromTouch(); +extern int SendAnalogFromEdu(); +extern void SendStatus(void); +extern void SendRpaStatus(void); +extern void SendInfo(void); +extern void SendTelToHost(bool fMoreThanOne, bool fEof, int nReplace); +extern int SendRpaAnalogValues();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SdCard/SdCard.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,437 @@
+/*-------------------------------------------------------------------------------------------------------------
+Program Name: SDCard.cpp
+Version: 1.x
+Sprache: C++
+Compiler: mbed
+Autors: UFa/PS
+
+Funktion: Lesen und Schreiben der SD-Card
+
+History:
+30.09.2019:
+Vorsicht, es gibt zwei Dateien zum Autospeichern. Die Datei autostart.CFG, welche die Konfigurationsdaten
+zum Handling der Autostart Messfunktion aufnimmt und die Datei(en) MW_AUTO%d, welche die Messwerte aufnimmt und
+durchnummeriert wird. Folgende Variablen und Methoden liegen dem zugrunde:
+autostart.cnf:
+FileNames.AutoFileName,"/SDCard/autostart.CFG"
+clSdCard.OpenAutoFile(FileNames.AutoFileName, FileNames.FileReadMode);
+clSdCard.ReadAutoLine(strFileRwBuf, FILE_RW_BUF_LEN);
+clSdCard.WriteAutoLine(); schreibt den Puffer clSdCard.cSdLine
+clSdCard.CloseAutoFile();
+
+
+Messdateien:
+AutoStart.MwFileName, "/SDCard/data/MW_AUTO_%d.ASC"
+clSdCard.OpenMwAutoFile(AutoStart.MwFileName, FileNames.FileWriteMode);
+clSdCard.WriteMwAutoLine(); schreibt den Puffer strFileRwBuf
+
+
+ --------------------------------------------------------------------------------------------------------------*/
+
+#include "Headers.h"
+
+
+
+
+/*-----------------------------------------------------------------------------------------------
+Init: Initialisieren der Startwerte
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::Init()
+{
+ m_fFileIsOpen = false;
+ m_fHeaderIsOpen = false;
+ m_Fp = NULL;
+ m_FpHeader = NULL;
+ m_FpAutoFile = NULL;
+ m_fAutoFileIsOpen = false;
+ m_FpMwAutoFile = NULL;
+ m_fMwAutoFileIsOpen = false;
+ return(true);
+}
+/*-----------------------------------------------------------------------------------------------
+OpenFile: Öffnet eine Datei über den Namen der im Aufrufparameter enthalten ist
+Returnwert ist true bei erfolgreichem Öffnen
+Returnwert ist false bei fehlerhaftem Öffnen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::OpenFile(char *FName, char *OpenMode)
+{
+ if(m_fFileIsOpen == true) // eine andere Datei ist geöffnet. Sollte eigentlich nicht vorkommen,
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#Error open file %s, another file is opened. %c\r\n", STX, FName, ETX); //
+ if(g_fOnDuringInit)
+ printf("%s",HostIf.strErrorBuf);
+ else
+ HostIf.fSendError = true;
+ return(false); // ist nur zur Sicherheit
+ }
+ m_Fp = fopen(FName, OpenMode); // Datei im OpenMode öffnen
+ if(m_Fp == NULL) // Fehler beim Öffnen der Datei, der wesentliche Grund ist, das die Datei nicht vorhanden ist.
+ // Die Konsequenz ist, daß die Quelldaten initialisiert werden müssen, eine Fehlermeldung muss nicht ausgegeben werden,
+ // es dürfen jedoch keine weiteren Daten aus der Datei gelesen werden.
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#File could not opened: %s %c\r\n", STX, FName, ETX); //
+ if(g_fOnDuringInit)
+ printf("%s",HostIf.strErrorBuf);
+ else
+ HostIf.fSendError = true;
+ return(false);
+ }
+ m_fFileIsOpen = true;
+
+ rewind(m_Fp);
+ return(true);
+
+}
+/*-----------------------------------------------------------------------------------------------
+OpenFile: Öffnet eine Header-Datei über den Namen der im Aufrufparameter enthalten ist
+Returnwert ist true bei erfolgreichem Öffnen
+Returnwert ist false bei fehlerhaftem Öffnen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::OpenHeaderFile(char *FName, char *OpenMode)
+{
+ if(m_fHeaderIsOpen == true) // eine andere Datei ist geöffnet. Sollte eigentlich nicht vorkommen,
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#Error open file %s, another file is opened. %c\r\n", STX, FName, ETX); //
+ if(g_fOnDuringInit)
+ printf("%s",HostIf.strErrorBuf);
+ else
+ HostIf.fSendError = true;
+ return(false); // ist nur zur Sicherheit
+ }
+
+ m_FpHeader = fopen(FName, OpenMode); // Datei im OpenMode öffnen
+ if(m_FpHeader == NULL) // Fehler beim Öffnen der Datei, der wesentliche Grund ist, das die Datei nicht vorhanden ist.
+ // Die Konsequenz ist, daß die Quelldaten initialisiert werden müssen, eine Fehlermeldung muss nicht ausgegeben werden,
+ // es dürfen jedoch keine weiteren Daten aus der Datei gelesen werden.
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#Error open Header-File %s. %c\r\n", STX, FName, ETX); //
+ HostIf.fSendError = true;
+ return(false);
+ }
+ m_fHeaderIsOpen = true;
+
+ rewind(m_FpHeader);
+ return(true);
+}
+
+/*-----------------------------------------------------------------------------------------------
+CloseFile: Schließt eine geöffnete Datei
+Returnwert ist true bei erfolgreichem Schliessen
+Returnwert ist false bei fehlerhaftem Schliessen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::CloseHeaderFile()
+{
+ if(m_fHeaderIsOpen == true)
+ {
+ clearerr(m_FpHeader);
+ fflush(m_FpHeader);
+ fclose(m_FpHeader); // Datei zu
+ m_fHeaderIsOpen = false;
+ m_FpHeader = NULL;
+ return(true);
+ }
+ return(false);
+}
+
+/*-----------------------------------------------------------------------------------------------
+ReadLine: Liest eine Zeile aus der geöffneten Datei
+Wenn der Pointer von fgets nach dem Leseversuch NULL ist, dann wurde nichts mehr gelesen
+und die Datei wird automatisch geschlossen, d.h. die lesende Funktion muss nur so lange lesen
+bis false zurückkommt.
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::ReadLine(char *Dest, int MaxLen)
+{
+ if(m_fFileIsOpen == true)
+ {
+ if(fgets(Dest , MaxLen , m_Fp) != NULL )
+ return(strlen(Dest));
+ clearerr(m_Fp);
+ }
+ return(false);
+}
+/*-----------------------------------------------------------------------------------------------
+WriteLine: Schreibt eine Zeile in die geöffneten Datei
+Wenn beim Schreiben ein Fehler auftrifft, dann wird false zurückgegeben, ansonsten true.
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::WriteLine()
+{
+ if(m_fFileIsOpen == true)
+ {
+ fputs(cSdLine, m_Fp);
+ if (ferror (m_Fp))
+ {
+ clearerr(m_Fp);
+ fclose(m_Fp);
+ m_fFileIsOpen = false;
+ return(false);
+ }
+ fflush(m_Fp);
+ return(true);
+ }
+
+ return(false);
+}
+/*-----------------------------------------------------------------------------------------------
+WriteHeaderLine: Schreibt eine Zeile in die geöffneten Datei
+Wenn beim Schreiben ein Fehler auftrifft, dann wird false zurückgegeben, ansonsten true.
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::WriteHeaderLine()
+{
+ if(m_fHeaderIsOpen == true)
+ {
+ fputs(strFileRwBuf, m_FpHeader);
+ if (ferror (m_FpHeader))
+ {
+ clearerr(m_FpHeader);
+ fclose(m_FpHeader);
+ m_fHeaderIsOpen = false;
+ return(false);
+ }
+ return(true);
+ }
+ return(false);
+}
+
+/*-----------------------------------------------------------------------------------------------
+CloseFile: Schließt eine geöffnete Datei
+Returnwert ist true bei erfolgreichem Schliessen
+Returnwert ist false bei fehlerhaftem Schliessen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::CloseFile()
+{
+ if(m_fFileIsOpen == true)
+ {
+ clearerr(m_Fp);
+ fflush(m_Fp);
+ fclose(m_Fp); // Datei zu
+ m_fFileIsOpen = false;
+ m_Fp = NULL;
+#ifdef TFT_DEBUG
+ printf("In CloseFile of SdCard \n");
+#endif
+ return(true);
+ }
+ return(false);
+}
+/*-----------------------------------------------------------------------------------------------
+ReadFile: Lesen einer kompletten Datei über Klassenmethoden
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::ReadFile(char *fName, char *DestBuf, int MaxLen)
+{
+ int Ret, Len;
+
+ if(OpenFile(fName, FileNames.FileReadMode) == false)
+ return(false);
+
+ Len = 0;
+ do
+ {
+ Ret = ReadLine(strFileRwBuf, FILE_RW_BUF_LEN);
+ if(Ret > 0) // es wurden Zeichen gelesen
+ {
+ Len += Ret;
+ if(Len < MaxLen)
+ strcat(DestBuf, strFileRwBuf);
+ }
+ }
+ while(Ret > 0);
+
+ CloseFile();
+ return true;
+
+}
+
+/*-----------------------------------------------------------------------------------------------
+WriteFile: Schreiben einer kompletten Datei über Klassenmethoden
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::WriteFile(char *fName, char *SrcBuf)
+{
+ int Ret;
+
+ if(OpenFile(fName, FileNames.FileWriteMode) == false)
+ return(false);
+
+ Ret = fputs(SrcBuf,m_Fp);
+
+ CloseFile();
+ if(Ret == EOF)
+ return(false);
+ return true;
+}
+/*-----------------------------------------------------------------------------------------------
+RemoveFile: Löschen einer Datei auf der SD Card
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::RemoveFile(char *fName)
+{
+ return(remove(fName));
+}
+/*-----------------------------------------------------------------------------------------------
+AppendSdValueToLine: Löschen einer Datei auf der SD Card
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::AppendSdValueToLine()
+{
+ strcat (cSdLine, cSdValue);
+ return(true);
+}
+// Methoden speziell fuer die KonfigurationsDatei mit den Autostartvariablen
+/*-----------------------------------------------------------------------------------------------
+OpenAutoFile: Öffnet eine Datei fuer den AutoStart
+Returnwert ist true bei erfolgreichem Öffnen
+Returnwert ist false bei fehlerhaftem Öffnen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::OpenAutoFile(char *FName, char *OpenMode)
+{
+ if(m_fAutoFileIsOpen == true) // ist bereits geoeffnet oder wurde nicht geschlossen
+ {
+ printf("AutoFileIsOpened\n");
+ return(false); // ist nur zur Sicherheit
+ }
+/* else
+ {
+ sprintf(HostIf.strErrorBuf,"%c#ER#Error open Autofile %s. %c\r\n", STX, FName, ETX); //
+ HostIf.fSendError = true;
+ return(false); // ist nur zur Sicherheit
+ }
+*/
+ m_FpAutoFile = fopen(FName, OpenMode); // Datei im OpenMode öffnen
+ if(m_FpAutoFile == NULL) // Fehler beim Öffnen der Datei, der wesentliche Grund ist, das die Datei nicht vorhanden ist.
+ // Die Konsequenz ist, daß die Quelldaten initialisiert werden müssen, eine Fehlermeldung muss nicht ausgegeben werden,
+ // es dürfen jedoch keine weiteren Daten aus der Datei gelesen werden.
+ {
+ printf("AutoFilePointer is zero, no File with Autostart configurations\n");
+ return(false);
+ }
+ m_fAutoFileIsOpen = true;
+
+ rewind(m_FpAutoFile);
+ return(true);
+}
+/*-----------------------------------------------------------------------------------------------
+ReadAutoLine: Liest eine Zeile aus der geöffneten AutoDatei
+Wenn der Pointer von fgets nach dem Leseversuch NULL ist, dann wurde nichts mehr gelesen
+und die Datei wird automatisch geschlossen, d.h. die lesende Funktion muss nur so lange lesen
+bis false zurückkommt.
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::ReadAutoLine(char *Dest, int MaxLen)
+{
+ if(m_fAutoFileIsOpen == true)
+ {
+ if(fgets(Dest, MaxLen , m_FpAutoFile) != NULL )
+ return(strlen(Dest));
+ clearerr(m_FpAutoFile);
+ }
+ return(false);
+}
+
+/*-----------------------------------------------------------------------------------------------
+WriteAutoLine: Schreibt eine Zeile in die geöffneten Datei
+Wenn beim Schreiben ein Fehler auftrifft, dann wird false zurückgegeben, ansonsten true.
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::WriteAutoLine()
+{
+ if(m_fAutoFileIsOpen == true)
+ {
+ fputs(cSdLine, m_FpAutoFile);
+ if (ferror (m_FpAutoFile))
+ {
+ clearerr(m_FpAutoFile);
+ fclose(m_FpAutoFile);
+ m_fAutoFileIsOpen = false;
+ return(false);
+ }
+ fflush(m_FpAutoFile);
+#ifdef RWFILE_DEBUG
+ printf ("%s",cSdLine);
+#endif
+ return(true);
+ }
+
+ return(false);
+}
+
+/*-----------------------------------------------------------------------------------------------
+CloseAutoFile: Schließt eine geöffnete Datei
+Returnwert ist true bei erfolgreichem Schliessen
+Returnwert ist false bei fehlerhaftem Schliessen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::CloseAutoFile()
+{
+ if(m_fAutoFileIsOpen == true)
+ {
+ clearerr(m_FpAutoFile);
+ fflush(m_FpAutoFile);
+ fclose(m_FpAutoFile); // Datei zu
+ m_fAutoFileIsOpen = false;
+ m_FpAutoFile = NULL;
+ return(true);
+ }
+ return(false);
+}
+
+
+// Methoden fuer das Schreiben von Automessdaten
+/*-----------------------------------------------------------------------------------------------
+OpenAutoFile: Öffnet eine Datei fuer den AutoStart
+Returnwert ist true bei erfolgreichem Öffnen
+Returnwert ist false bei fehlerhaftem Öffnen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::OpenMwAutoFile(char *FName, char *OpenMode)
+{
+ if(m_fMwAutoFileIsOpen == true) // ist bereits geoeffnet oder wurde nicht geschlossen
+ {
+#ifdef SEND_DEBUG_TO_HOST
+ printf("MwAutoFileIsOpened\n");
+#endif
+ return(false); // ist nur zur Sicherheit
+ }
+ m_FpMwAutoFile = fopen(FName, OpenMode); // Datei im OpenMode öffnen
+ if(m_FpMwAutoFile == NULL) // Fehler beim Öffnen der Datei, der wesentliche Grund ist, das die Datei nicht vorhanden ist.
+ // Die Konsequenz ist, daß die Quelldaten initialisiert werden müssen, eine Fehlermeldung muss nicht ausgegeben werden,
+ // es dürfen jedoch keine weiteren Daten aus der Datei gelesen werden.
+ {
+ return(false);
+ }
+ m_fMwAutoFileIsOpen = true;
+
+ rewind(m_FpMwAutoFile);
+ return(true);
+
+}
+/*-----------------------------------------------------------------------------------------------
+WriteAutoLine: Schreibt eine Zeile in die geöffneten Auto Datei
+Wenn beim Schreiben ein Fehler auftrifft, dann wird false zurückgegeben, ansonsten true.
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::WriteMwAutoLine()
+{
+ if(m_fMwAutoFileIsOpen == true)
+ {
+ fputs(strFileRwBuf, m_FpMwAutoFile);
+ if (ferror (m_FpMwAutoFile))
+ {
+ clearerr(m_FpMwAutoFile);
+ fclose(m_FpMwAutoFile);
+ m_fMwAutoFileIsOpen = false;
+ return(false);
+ }
+ return(true);
+ }
+ return(false);
+}
+/*-----------------------------------------------------------------------------------------------
+CloseAutoFile: Schließt die Auto Datei
+Returnwert ist true bei erfolgreichem Schliessen
+Returnwert ist false bei fehlerhaftem Schliessen
+-----------------------------------------------------------------------------------------------*/
+int StorageCard::CloseMwAutoFile()
+{
+ if(m_fMwAutoFileIsOpen == true)
+ {
+ clearerr(m_FpMwAutoFile);
+ fflush(m_FpMwAutoFile);
+ fclose(m_FpMwAutoFile); // Datei zu
+ m_fMwAutoFileIsOpen = false;
+ m_FpMwAutoFile = NULL;
+ return(true);
+ }
+ return(false);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SdCard/SdCard.h Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,71 @@
+/*-------------------------------------------------------------------------------------------------------------
+Program Name: SDCard.h
+Version: 1.0
+Sprache: C++
+Compiler: mbed
+Autors: UFa/PS
+
+Funktion: Lesen und Schreiben der SD-Card
+
+History:
+2018-02-02 UFa: Erstellung
+
+ --------------------------------------------------------------------------------------------------------------*/
+#ifndef SDCARD_H_
+#define SDCARD_H_
+
+class StorageCard
+{
+ private:
+
+ public:
+
+ int Init();
+ int OpenFile(char *FName, char *OpenMode);
+ int OpenHeaderFile(char *FName, char *OpenMode);
+ int ReadLine(char *Dest, int MaxLen);
+ int WriteLine();
+ int WriteHeaderLine();
+ int CloseFile();
+ int CloseHeaderFile();
+ int RemoveFile(char *FileName); // Datei löschen
+
+ int ReadFile(char *fName, char *DestBuf, int MaxLen);
+ int WriteFile(char *fName, char *SrcBuf);
+ int AppendSdValueToLine();
+
+ int OpenAutoFile(char *FName, char *OpenMode);
+ int ReadAutoLine(char *Dest, int MaxLen);
+ int WriteAutoLine();
+ int CloseAutoFile();
+
+ int OpenMwAutoFile(char *FName, char *OpenMode);
+ int ReadMwAutoLine(char *Dest, int MaxLen);
+ int WriteMwAutoLine();
+ int CloseMwAutoFile();
+
+// STR_SD_CARD StrSdCard; // Struktur zum Speichern der Daten
+
+ FILE *m_Fp;
+ bool m_fFileIsOpen;
+ FILE *m_FpHeader;
+ bool m_fHeaderIsOpen;
+
+ FILE *m_FpAutoFile;
+ bool m_fAutoFileIsOpen;
+
+ FILE *m_FpMwAutoFile;
+ bool m_fMwAutoFileIsOpen;
+
+ char cSdValue[128];
+ char cSdLine[512];
+ char MessFileName[128];
+
+};
+
+
+#endif /* SDHCARD_H_ */
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SdCard/SdGlobals.cpp Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,110 @@
+/*-------------------------------------------------------------------------------------------------------------
+Program Name: SDGlobals.cpp
+Version: 1.x
+Sprache: C++
+Compiler: mbed
+Autors: UFa/PS
+
+Funktion: Globale Variablen für die SD-Card Zugriffe
+
+Modified:
+17.04.16 PS: entfernen der Stringklassen
+
+ --------------------------------------------------------------------------------------------------------------*/
+
+#include "mbed.h"
+
+#include <stdio.h>
+#include <algorithm>
+
+#include "SdGlobals.h"
+#include "SdCard.h"
+
+#include "SDBlockDevice.h"
+#include "FATFileSystem.h"
+
+// Globale Variablen und Klassen
+
+//SDFileSystem sd_x(PTE3, PTE1, PTE2, PTE4, "sd"); // MOSI, MISO, SCK, CS
+SDBlockDevice bd(
+ MBED_CONF_SD_SPI_MOSI,
+ MBED_CONF_SD_SPI_MISO,
+ MBED_CONF_SD_SPI_CLK,
+ MBED_CONF_SD_SPI_CS);
+
+FATFileSystem fs("SDCard");
+
+STR_FILE_NAMES FileNames;
+
+StorageCard clSdCard;
+STR_SD_CARD SdCard; // Variablen Struktur fuer die SdCard
+
+char strFileRwBuf[512];
+
+
+bool g_SdInitSuccess;
+
+
+// Funktionen
+
+/*-------------------------------------------------------------------------------------------------------*/
+/*--------------------------------------------------------------------------------------------------------
+Initialisieren der SD-FileSystem Klasse.
+---------------------------------------------------------------------------------------------------------*/
+int InitSdFileSystem()
+{
+ int FReturn;
+
+ FReturn = false;
+ InitFileNames();
+
+ // OLD MySd = new SDFileSystem(PTE3, PTE1, PTE2, PTE4, "SDCard"); // MOSI, MISO, SCK, CS
+ // OLD MySd->disk_initialize();
+
+ g_SdInitSuccess = true;
+ if(g_SdInitSuccess == true)
+ {
+ // OLD Ret = CheckDiscStatus();
+ FReturn = true;
+ }
+
+ InitclSdCard();
+ bd.init();
+ fs.mount(&bd);
+ return(FReturn);
+}
+/*--------------------------------------------------------------------------------------------------------
+InitFileNames: Zeichenfelder mit Dateinamen und Pfaden vorbelegen
+---------------------------------------------------------------------------------------------------------*/
+void InitFileNames()
+{
+ strcpy(FileNames.IniFileName, "/SDCard/ecmini.CFG");
+ strcpy(FileNames.DevIdFileName,"/SDCard/DevIni.cfg");
+ strcpy(FileNames.ParaFileName, "/SDCard/cfg/parameters.CFG");
+ strcpy(FileNames.ConfigFileName,"/SDCard/cfg/config.CFG");
+ strcpy(FileNames.DataPathName,"/SDCard/data/");
+ strcpy(FileNames.SeqPathName,"/SDCard/scandat/");
+ strcpy(FileNames.FileReadMode,"r+");
+ strcpy(FileNames.FileWriteMode,"w+");
+ strcpy(FileNames.FileAppendMode,"a");
+
+ strcpy(FileNames.AutoFileName,"/SDCard/autostart.CFG");
+}
+/*--------------------------------------------------------------------------------------------------------
+Initialisieren der SD-Card. Das Anlegen der
+---------------------------------------------------------------------------------------------------------*/
+int CheckDiscStatus()
+{
+ // OLD return(MySd->disk_status());
+ return(true);
+}
+
+/*--------------------------------------------------------------------------------------------------------
+Initialisieren der eigenen SD-Card Klasse.
+---------------------------------------------------------------------------------------------------------*/
+void InitclSdCard()
+{
+ clSdCard.Init();
+}
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SdCard/SdGlobals.h Fri Aug 07 07:24:21 2020 +0000
@@ -0,0 +1,77 @@
+/*-------------------------------------------------------------------------------------------------------------
+Program Name: SDGlobals.h
+Version: 1.x
+Sprache: C++
+Compiler: mbed
+Autors: UFa/PS
+
+Funktion: Globale Variablen für die SD-Card Zugriffe
+
+Modified:
+2018-02-02 UFa: Initiale Erstellung
+
+ --------------------------------------------------------------------------------------------------------------*/
+
+// #define UF_EQUAL "="
+#define BLANK " "
+
+#define FILE_RW_BUF_LEN 512
+
+
+
+// Strukturen -------------------------------------
+/*===========================================================================
+Die nachfolgende Struktur dient zur Bearbeitung der SD-Card
+===========================================================================*/
+struct strSdCard
+{
+ int MWString;
+// char MethInfo[4];
+
+ char SeqFileName[128];
+ char GenFile[128]; // wird für Sequenzmessung genommen
+
+};
+typedef struct strSdCard STR_SD_CARD;
+
+
+/*===========================================================================
+Die nachfolgende Struktur dient zur Speicherung der Dateinamen
+===========================================================================*/
+struct strFileNames
+{
+ char IniFileName[32];
+ char DevIdFileName[32];
+ char ParaFileName[32];
+ char ConfigFileName[32];
+ char DataPathName[32];
+ char SeqPathName[32];
+ char AutoFileName[32]; // Datei mit den Variablen fuer den Autostart
+ char FileReadMode[4];
+ char FileWriteMode[4];
+ char FileAppendMode[4];
+
+};
+typedef struct strFileNames STR_FILE_NAMES;
+
+
+
+
+
+// Variablen-------------------------------------
+
+extern class StorageCard clSdCard;
+extern STR_SD_CARD SdCard; // Variablen Struktur fuer die SdCard
+extern STR_FILE_NAMES FileNames;
+
+extern bool g_SdInitSuccess; // Fehler bei der Initialisierung der SD Karte, möglicherweise nicht gesteckt.
+extern char strFileRwBuf[512]; // Lese und Schreibpuffer für Dateizugriffe
+
+
+
+// Funktionen -------------------------------------
+extern int InitSdFileSystem();
+extern int CheckDiscStatus();
+extern void InitclSdCard();
+extern void InitFileNames();
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed-dev-OS5_10_4.lib Fri Aug 07 07:24:21 2020 +0000 @@ -0,0 +1,1 @@ +https://os.mbed.com/users/kevman/code/mbed-dev-OS5_10_4/#7aab896b1a3b