PSOC und die verlorene Zeit... Wer mag helfen? Workshop?

[Raja_Kentut]

Moin,
nach einem Ausflug über BASCOM (eigentlich super) und Arduino (eigentlich ziemlich super) möchte ich nun "professionell" werden.
Auserkoren habe ich den PSOC von Cypress.
Warum ? Weil ich davon eine Kiste voller Kits rumliegen habe, die Kits kosten zwischen 3,50€ und 30€, es ist eine Menge analoger Preipherie auf dem Chip UND es gibt eine vollständige
professionelle IDE, die es erlaubt I/O's und peripherals grafisch zu parametrisieren - Datenblatt kann ziemlich weit weg liegen...
Das Ding hab ich mir installiert, bin echt beeindruckt und kriege Demos zum laufen. Es gibt tonnenweise Doku und fertige Projekte...

Jetzt kommts aber :
Alle Demos sind für Leute geschrieben die perfekt C können. Also nicht für mich. Bei mir hakt es schon einen PIN einzulesen oder zu schalten...einen ADC Wert auszulesen...
FRAGE:
Hat jemand Lust sich mit mir hinzusetzen und die ersten Trivialitäten auszuräumen ?
- define ? d.h. wie kriege ich meinen PIN / ADC Wert ins Programm ?
- wie hängen die millionen von Files zusammen, die beim build / compile entstehen ?
- also die Überbrückung des "ich weiß wie's theoretisch geht" auf "irgendwas funktioniert auch"

Evtl.als kleiner Workshop übers Wochenende, vielleicht haben ja noch Leute Lust (Kits stelle ich), evtl.als SKYPE, ich komme sonstwohin, Du, (ihr) kommt nach Veitsbronn, alles ginge...
Falls sich was á la Workshop ergäbe würde ich für Kost und Logis sorgen - wäre ja auch vielleicht was für "zwischen den Jahren"...

DAUmäßige Grüße
RK

[Matt]

Hallo

Da brauchst du Unterstützung bei C Sprache ?

Ich denke, ich kann mal daran versuchen, ich schreibe schon C Sprache, aber eben für AVR..

grüss
Matt

[Raja_Kentut]

es geht hauptsächlich darum den PSOC Creator in den Griff zu kriegen.
Da scheitere ich an C ProblemCHEN die mich daran hindern schonmal ein Programm zu compilieren.
Ich weiß dann nicht : WO ist denn nun der Fehler ??
Der PSOC Creator ( die umsonste IDE ) weist Pins / Registern Namen zu und Parametriert z.B. ein PWM Modul. Das kann man grafisch parametrisieren. So weit so gut. Aber wie sag ich meinem Programm das es z.B. bei einem ADC Wert von 167 einen LED Pin auf HIGH schaltet ?
Sowas triviales also...
Ja, es gibt Filmchen, z.B. https://www.youtube.com/watch?v=RGTbvivbfwY aber ich komm nicht voran.

In der Tat, ich brauche Unterstützung auf "C" Fußpilzlevel... und wenn mir die vielen Onlinekurse und Tutorials helfen würden, gäbe es diesen Faden nicht...
Ich lerne am besten beim gemeinsamen schaffen und machen. Warscheinlich bin ich so ne Art Lehrbuch-Legastheniker...

[Fritzler]

Zeig doch mal nen ADC Auslesecode aus nem Beispiel und den LED Blinkcode.
Dann gucken wir mal wie man das verheiratet.

Die Librarys abstrahieren das ja nur weg und ich kenn die Libs auch ned.
Habe ja bisher nicht mit diesen PSOC gearbeitet.

[Raja_Kentut]

sowas hier. Da ist ein Sampleprogramm, das alles mögliche beinhaltet und verwurstet.
Da steig ich als DAU nicht durch bzw. rein. Das ist eben das Problem an den ganzen Beispielprojekten, die setzen zwei Etagen zu hoch an. Gleich mit Interrupts, UART Kommunikation und was weis ich für Gedöhns.



/*******************************************************************************
* File: main.c
*
* Version: 2.2
*
* Description:
* This is a basic design source code.
*
* Note:
* Pin_Vin pin (P0[4]) should be connected to the VR.
* Verify that VR_PWR(J11) is jumpered to ON.
*
* Hardware Dependency:
* CY8CKIT-001 DVK
*
********************************************************************************
* Copyright 2013, Cypress Semiconductor Corporation. All rights reserved.
* This software is owned by Cypress Semiconductor Corporation and is protected
* by and subject to worldwide patent and copyright laws and treaties.
* Therefore, you may use this software only as provided in the license agreement
* accompanying the software package from which you obtained this software.
* CYPRESS AND ITS SUPPLIERS MAKE NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* WITH REGARD TO THIS SOFTWARE, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT,
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*******************************************************************************/

#include <project.h>

#define ADC_NUMBER_SAMPLES (15)

/* Initialize array elements to zero. */
int16 samples[ADC_NUMBER_SAMPLES] = {0};

/* Defining and initializing the index */
int8 sampleIndex = 0u;

/* Sample read from ADC */
volatile int16 currentSample;

/* Indicator for when sample is available */
volatile uint8 sampleAvailable = 0u;


/*******************************************************************************
* Function Name: InterruptHandler
********************************************************************************
*
* Summary:
* The Interrupt Service Routine for isr_1.
*
* Parameters:
* None.
*
* Return:
* void.
*
*******************************************************************************/
CY_ISR(InterruptHandler)
{
/* Get the result */
currentSample = ADC_DelSig_1_GetResult16();
sampleAvailable = 1u;
}


/*******************************************************************************
* Function Name: main
********************************************************************************
*
* Summary:
* Main function performs following functions:
* 1: Start the LCD
* 2: Start ADC DelSig and its interrupt
* 3: Start the Timer
* 4: Testing for sample available from ADC
* 5: Storing the sample into the array
* 6: Calculate and show average voltage
*
* Parameters:
* None.
*
* Return:
* None.
*
*******************************************************************************/
int main()
{
int8 i;
int16 voltageMv;
int32 sampleAverage;

/* Start and initialize the LCD */
LCD_Start();
LCD_PrintString("ADC OUTPUT: ");
LCD_Position(1u, 0u);
LCD_PrintString("Voltage= mV");

/* Start the ADC */
ADC_DelSig_1_Start();

/* Start the embedded in the DelSig Interrupt and change the vector to the InterruptHandler */
ADC_DelSig_1_IRQ_StartEx(InterruptHandler);

/* Start the Timer which will start the ADC conversion */
Timer_1_Start();

CyGlobalIntEnable;

for(;;)
{
/* Check whether ADC conversion complete or not */
if (sampleAvailable)
{
sampleAvailable = 0u;

/* storing the sample into the array, based on the index */
samples[sampleIndex++] = currentSample;

/* Print the ADC result on LCD */
LCD_Position(0u, 11u);
LCD_PrintInt16(currentSample);

/* Calculate average result */
if (sampleIndex == ADC_NUMBER_SAMPLES)
{
sampleAverage = 0u;
for (i = 0u; i < ADC_NUMBER_SAMPLES; i++)
{
sampleAverage += samples;
}
sampleAverage /= ADC_NUMBER_SAMPLES;
sampleIndex = 0u;

/* Convert results to mV */
voltageMv = ADC_DelSig_1_CountsTo_mVolts(sampleAverage);

/* Print the averaged ADC voltage on LCD */
LCD_Position(1u, 8u);
LCD_PrintString(" ");
if(voltageMv < 0)
{
LCD_Position(1u, 8u);
LCD_PrintString("-");
voltageMv = -voltageMv;
}
LCD_Position(1u, 9u);
LCD_PrintNumber(voltageMv);
}
}
}
}


/* [] END OF FILE */

[Fritzler]

Als Einrückzerstörtes Posting steig ich da aber auch ned durch

[andreas6]

Dito. Poste Quellcode bitte immer als

code

Sonst kann das niemand lesen.

Verstehen kann ich Dich schon, als langjähriger Basic/Assembler/Pascal-Nutzer ist mir C auch schwer gefallen. Dennoch habe ich damit schon einige Dinge realisiert. Auch ganz ab Null, also ohne jede Quelle. Greife Dir ein einfaches, fertiges Projekt und baue es 1:1 nach. Wenn das läuft, passe Kleinigkeiten an. Bis sie laufen. Dann blende alles aus, was Du nicht brauchst. Wieder anpassen, bis keine Fehler mehr auftauchen. Eigene Zutaten einsetzen, auf Basis der bisherigen Erfahrungen, bis sie laufen.

C ist eine ganz doofe Sprache bezüglich der Syntax. Sie mag zwar mächtig sein, aber keineswegs selbsterklärend oder logisch. Du wirst daran noch etliche Stunden und Haare verlieren. Habe ich auch durch. Haare sind noch da, aber das Alter lässt sich nicht verleugnen.

MfG. Andreas

[xoexlepox]

Poste Quellcode bitte immer als "code"... Sonst kann das niemand lesen.

Jau, insbesondere die (Übersicht erleichternden, aber nicht zwingend notwendigen) Einrückungen verschwinden sonst.

C ist eine ganz doofe Sprache bezüglich der Syntax. Sie mag zwar mächtig sein, aber keineswegs selbsterklärend oder logisch.

Das hängt vom Standpunkt (->u.a. Kenntnissen) und dem Schreibstil ab. "C" ist "streng logisch", aber wenn die Operatoren "kreativ" verwendet werden, und der Stil "eigenwillig" ist, kann da ein unleserliches Kauderwelsch bei herauskommen

Du wirst daran noch etliche Stunden und Haare verlieren.

Jau!

Soweit ich es begriffen habe, initialisiert dieses Programm die globalen Variablen, und wirft die erste A/D-Konvertierung an, um dann in einer Endlosschleife auf (von der Interruptroutine ausgelesene) Werte zu warten, weitere Konvertierungen anzuwerfen und ggf. einen Mittelwert zu bilden, und ihn auf dem Display auszugeben. Ca. 60% davon brauchst du vermutlich nicht, um einen Portpin zu steuern, der ab einem bestimmten A/D-Wert gesetzt wird. Etwas Code zur Ansteuerung eines digitalen Ausgangs wäre noch notwendig...

[berlinerbaer]

C ist eine ganz doofe Sprache bezüglich der Syntax. Sie mag zwar mächtig sein, aber keineswegs selbsterklärend oder logisch.

Wer das nicht glaubt, kann sich ja mal ein paar Beispiele vom leider etwas eingeschlafenen International Obfuscated C Code Contest anschauen:

http://www.ioccc.org/index.html

Glücklicherweise braucht man bei Mikrocontrollern ja typischerweise nicht die gesamte Sprachwucht von C.

Ich würde, wie bereits empfohlen, ganz sachte anfangen, funktionierenden Beispielcode zu modifizieren.

Wenn dabei was kaputtgeht, ist der Fehler schnell einzugrenzen.

Wer noch auf der Suche nach der für ihn passenden µC-Familie ist, liest diesen ausführlichen Test sicher mit Gewinn:
https://jaycarlson.net/microcontrollers

[Marsupilami72]

So, ich hoffe, ich habe keine Einrückung vergessen:

Code: Alles auswählen

/*******************************************************************************
* File: main.c
*
* Version: 2.2
*
* Description:
* This is a basic design source code.
*
* Note:
* Pin_Vin pin (P0[4]) should be connected to the VR.
* Verify that VR_PWR(J11) is jumpered to ON.
*
* Hardware Dependency:
* CY8CKIT-001 DVK
*
********************************************************************************
* Copyright 2013, Cypress Semiconductor Corporation. All rights reserved.
* This software is owned by Cypress Semiconductor Corporation and is protected
* by and subject to worldwide patent and copyright laws and treaties.
* Therefore, you may use this software only as provided in the license agreement
* accompanying the software package from which you obtained this software.
* CYPRESS AND ITS SUPPLIERS MAKE NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* WITH REGARD TO THIS SOFTWARE, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT,
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*******************************************************************************/

#include <project.h>

#define ADC_NUMBER_SAMPLES (15)

/* Initialize array elements to zero. */
int16 samples[ADC_NUMBER_SAMPLES] = {0};

/* Defining and initializing the index */
int8 sampleIndex = 0u;

/* Sample read from ADC */
volatile int16 currentSample;

/* Indicator for when sample is available */
volatile uint8 sampleAvailable = 0u;


/*******************************************************************************
* Function Name: InterruptHandler
********************************************************************************
*
* Summary:
* The Interrupt Service Routine for isr_1.
*
* Parameters:
* None.
*
* Return:
* void.
*
*******************************************************************************/
CY_ISR(InterruptHandler)
{
	/* Get the result */
	currentSample = ADC_DelSig_1_GetResult16();
	sampleAvailable = 1u;
}


/*******************************************************************************
* Function Name: main
********************************************************************************
*
* Summary:
* Main function performs following functions:
* 1: Start the LCD
* 2: Start ADC DelSig and its interrupt
* 3: Start the Timer
* 4: Testing for sample available from ADC
* 5: Storing the sample into the array
* 6: Calculate and show average voltage
*
* Parameters:
* None.
*
* Return:
* None.
*
*******************************************************************************/
int main()
{
	int8 i;
	int16 voltageMv;
	int32 sampleAverage;

	/* Start and initialize the LCD */
	LCD_Start();
	LCD_PrintString("ADC OUTPUT: ");
	LCD_Position(1u, 0u);
	LCD_PrintString("Voltage= mV");

	/* Start the ADC */
	ADC_DelSig_1_Start();

	/* Start the embedded in the DelSig Interrupt and change the vector to the InterruptHandler */
	ADC_DelSig_1_IRQ_StartEx(InterruptHandler);

	/* Start the Timer which will start the ADC conversion */
	Timer_1_Start();

	CyGlobalIntEnable;

	for(;;)
	{
		/* Check whether ADC conversion complete or not */
		if (sampleAvailable)
		{
			sampleAvailable = 0u;

			/* storing the sample into the array, based on the index */
			samples[sampleIndex++] = currentSample;

			/* Print the ADC result on LCD */
			LCD_Position(0u, 11u);
			LCD_PrintInt16(currentSample);

			/* Calculate average result */
			if (sampleIndex == ADC_NUMBER_SAMPLES)
			{
				sampleAverage = 0u;
				for (i = 0u; i < ADC_NUMBER_SAMPLES; i++)
				{
					sampleAverage += samples[i];
				} 
				sampleAverage /= ADC_NUMBER_SAMPLES;
				sampleIndex = 0u;

				/* Convert results to mV */
				voltageMv = ADC_DelSig_1_CountsTo_mVolts(sampleAverage);

				/* Print the averaged ADC voltage on LCD */
				LCD_Position(1u, 8u);
				LCD_PrintString(" ");
				if(voltageMv < 0)
				{
					LCD_Position(1u, 8u);
					LCD_PrintString("-");
					voltageMv = -voltageMv;
				} 
				LCD_Position(1u, 9u);
				LCD_PrintNumber(voltageMv);
			}
		}
	}
}


/* [] END OF FILE */

Code: Alles auswählen

- globale Variablen deklarieren
- CY_ISR definiert, was beim Auslösen des Interrupts (s.u.) passieren soll: lese den Wert vom ADC aus und setze die Statusvariable sampleAvailable auf 1 (1u=1unsigned, also ohne Vorzeichen)

Routine main():
- Variablendeklarationen
- starte LCD und schreibe Beschriftung
- ADC starten und Interrupt zuordnen
- Timer starten (ist wohl für ADC notwendig...)
- Endlosschleife 
	- Ausführung nur, wenn sampleAvailable=1, also ein Wert vorhanden ist
		- sampleAvailable wieder auf 0 setzen
		- schreibe Samplewert in Array und erhöhe Arrayindex (das macht das "++" hinter sampleIndex)
		- schreibe Samplewert auf LCD
		- wenn das Array 15 Werte enthält (definiert durch ADC_NUMBER_SAMPLES), Durchschnittsberechnung ausführen
			- Array durchlaufen und Durchschnitt berechnen
			- ArrayIndex auf 0 zurücksetzen
			- Durchschnittswert zu mV konvertieren (integrierte Funktion) und auf LCD ausgeben
		 	 (das if-Konstrukt sorgt dafür, dass der Wert mit und ohne Vorzeichen immer an der gleichen Stelle steht)

[felixh]

Ja, diese PSoCs sind schon was feines.
Ich durfte jetzt schon etwas erfahrung mit dem 5er LP sammeln.

Ich empfehle dir erstmal, mit der psoc-creator warm zu werden.
Ich habe jedenfalls den PSOC creator als sehr durchdacht wahrgenommen.

Als einstiegs-code-beispiel würde ich dir z.B. mal das demo-projekt "VDAC8-example" nahelegen.
Da hast du ein Display drauf, und kannst ne spannung ausgeben.
keine interrupts, und sonstige "magie"...

Und dann würde ich versuchen das Programm mal zu erweitern, z.B. eine rechteck-spannung ausgeben oder so.
Einfach um langsam warm zu werden.
Hab ich auch nicht anders gemacht


Bei bedarf kann ich auch mal ein Video-Tutorial machen, und deine dringendsten Fragen beantworten.
Oder per Teamviewer oder so...


PS:
warst du das nicht sogar, der mir mal ARM samplekits gegeben hat, mit den worten ARM wär total easy

[Raja_Kentut]

"warst du das nicht sogar, der mir mal ARM samplekits gegeben hat, mit den worten ARM wär total easy "

...das war ich bestimmt - ist ja auch richtig, wenn man "C" kann... und der richtige Einstieg per "trivial Projekt" ist genau richtig.
Hab für meine Boards aber keines gefunden. Also werd ich mir mal eins mit ADC besorgen und dann in deine Fußstapfen treten...
Das Weglassen in diesen komplexen Beispielen ist halt einfach gesagt - wenn man weiß was "überflüssig" ist. Das weiß man aber nur wenn man versteht was drin ist...

[Sir_Death]

Jein. Ich habe das beim Arduino so gemacht, dass ich einfach eine Zeile auskommentiert habe, und dann geschaut habe, ob das was ich brauche noch geht. Danach die nächste... so lange bis es nicht mehr ging. Die Zeile hab ich mir dann auseinandergepflückt was sie tut, und dann statt in schönem C in mir verständlichem hässlich C neu hingeschrieben.

Zum Schluss ist das Ding klein & hässlich, danach die hässlichen Teile mit den originalen vergleichen, und die einzelnen Befehlsteile verstehen. Dann (vereinfacht wo möglich) wieder behübschen.

Nach so einer Session hast du eine Menge über c gelernt.

[Hightech]

Das was man für Mikrokontroller an C braucht ist eigentlich nur die Sytax.

Der If then else Kram ist fast wie in allen Sprachen.
Für einen PIN ein und aus zu schalten muss man nun noch raus finden, wie der Pin über die PSOC - Library angesprochen werden will.

Bei Atmel ist es halt
PORTD|=(1<<PIN7); Pin 7 Port D AN
PORTD&=~(1<<PIN7); Pin 7 Port D AUS

Die Syntax |=(1<<) ist in C immer gültig, nun muss man rausfinden, wie die Ports und Pins bei Cypress heißen.

Dann kann man schreiben

Wenn ADC-Wert > 150 Pin7 Anschalten

Also

Code: Alles auswählen

if (ADC1=>1500){
PORTD|=(1<<PIN7);
}
else {
PORTD&=~(1<<PIN7);
}

Aber das sollte man schon grundlegend verstanden haben warum da steht 1<<PIN7 und PORTD|=(1<<PIN7)
sonst kann man das mit dem Programmieren besser sein lassen.

[andreas6]

Sooo viele Bits wird der Adc nicht haben, als dass da jemals ein Erfolg eintritt.

MfG. Andreas

[Raja_Kentut]

so, kaum hockt man sich mit einem Forumsmitglied zusammen, schon klappts mit dem Frickelfortschritt
Danke Alexander !
Ganz nebenbei hat sich noch herausgestellt, das wir quasi Nachbarn sind

Hier das erste Machwerk, nu komm ich alleine weiter. Weltherrschaft, ich komme !
->zoom