Timer Steuern

[Prim3]

Bin jetzt leider jetzt nicht mehr an meinem Heimischem PC. Schicke es morgen mal durch!

Besten Dank

Bis morgen

Prim3

[Unix-Tom]

Was ich nicht ganz verstehe ist:
Du verschiebst Grafiken an eine XY-Achse und weißt nicht wie man eine Membervariable hochzählt?

int x = 0;

void func()
{
  x++;
}

void funcz()
{

for(int i = 0;i<= 100;++i)
{
func();

// Schauen ob x bereits 50 ist und dann die Schleife abbrechen
if(x == 50) break;
}

}

[Prim3]

Das ist mein Auszug von View.. so wie das jetzt ist Läuft RectSchlitten auf der Y-Achse nach oben aus dem Bild... Das ist überhaupt das erste mal das ich mich mit dem Programmieren beschäftige..Das bischchen hier hat mich jetzt schon 3 wochen gekostet.

// VisuView.cpp : Implementierung der Klasse CVisuView
//

#include "stdafx.h"
#include "Visu.h"

#include "VisuDoc.h"
#include "VisuView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CVisuView

IMPLEMENT_DYNCREATE(CVisuView, CView)

BEGIN_MESSAGE_MAP(CVisuView, CView)
	//{{AFX_MSG_MAP(CVisuView)
	ON_WM_TIMER()
	ON_WM_CREATE()
	ON_WM_LBUTTONDOWN()
	ON_WM_RBUTTONDOWN()
	ON_WM_MOVE()
	//}}AFX_MSG_MAP
	// Standard-Druckbefehle
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CVisuView Konstruktion/Destruktion

CVisuView::CVisuView()
{		
	m_XRect=0;
	// ZU ERLEDIGEN: Hier Code zur Konstruktion einfügen,

}

CVisuView::~CVisuView()
{
}

BOOL CVisuView::PreCreateWindow(CREATESTRUCT& cs)
{
	// ZU ERLEDIGEN: Ändern Sie hier die Fensterklasse oder das Erscheinungsbild, indem Sie
	//  CREATESTRUCT cs modifizieren.

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CVisuView Zeichnen

void CVisuView::OnDraw(CDC* pDC)
{	int Wert; 
	int cx,cy;

	CPen GruenStift, *pOldPen;
	GruenStift.CreatePen(PS_SOLID,2,RGB(0,0,0));

	CBrush GruenBrush, *pOldBrush;
	GruenBrush.CreateSolidBrush(RGB(0,255,0));

	CBrush RotBrush, *pNewBrush;
	RotBrush.CreateSolidBrush(RGB(255,0,0));

	CBrush GelbBrush, *pNew1Brush;
	GelbBrush.CreateSolidBrush(RGB(255,255,0));

	CBrush OrangeBrush, *pNew2Brush;
	OrangeBrush.CreateSolidBrush(RGB(255,165,0));

	CBrush SteelBlueBrush, *pNew3Brush;
	SteelBlueBrush.CreateSolidBrush(RGB(70,130,180));

	CBrush SpringGreenBrush, *pNew4Brush;
	SpringGreenBrush.CreateSolidBrush(RGB(250,145,0));

	CBrush ForestBrush, *pNew5Brush;
	ForestBrush.CreateSolidBrush(RGB(34,139,34));

	CBrush PinkBrush, *pNew6Brush;
	PinkBrush.CreateSolidBrush(RGB(255,20,147));

	CBrush VioletBrush, *pNew7Brush;
	VioletBrush.CreateSolidBrush(RGB(148,0,211));

	CBrush LavenderBrush, *pNew8Brush;
	LavenderBrush.CreateSolidBrush(RGB(230,230,250));

	Wert=50;

	CString str;

		CRect rectclient,rectRahmen,rectSchlitten,rect1,rect2,rect3,rect4,rect5,rect6,rect7;

	GetClientRect(&rectclient);

                          //Deklaration Rechteckclient//

	str.Format("Wert=%d",rectclient.bottom);           
	cx=rectclient.right;
	cy=rectclient.bottom;

	rect1.top=cy*0.05;
	rect1.bottom=cy*0.95;

	rect1.right=cx*0.95;
	rect1.left=cx*0.9;

	rect2.top=cy*0.05;
	rect2.bottom=cy*0.15;

	rect2.right=cx*0.9;
	rect2.left=cx*0.6;

	rect3.top=cy*0.05;
	rect3.bottom=cy*0.95;

	rect3.right=cx*0.6;
	rect3.left=cx*0.55;

	rect4.top=cy*0.85;
	rect4.bottom=cy*0.95;

	rect4.right=cx*0.9;
	rect4.left=cx*0.6;

	rect5.top=cy*0.2;
	rect5.bottom=cy*0.3;

	rect5.right=cx*0.55;
	rect5.left=cx*0.3;

	rect6.top=cy*0.3;
	rect6.bottom=cy*0.65;

	rect6.right=cx*0.35;
	rect6.left=cx*0.3;

	rect7.top=cy*0.65;
	rect7.bottom=cy*0.75;

	rect7.right=cx*0.55;
	rect7.left=cx*0.3;

	rectRahmen.top=cy*0.98;
	rectRahmen.bottom=cy*0.02;

	rectRahmen.right=cx*0.98;
	rectRahmen.left=cx*0.02;

	rectSchlitten.top=cy*0.5-m_XRect;          ///Ausführung Verschieben////
	rectSchlitten.bottom=cy*0.4-m_XRect;

	rectSchlitten.right=cx*0.95;
	rectSchlitten.left=cx*0.9;

	pNew8Brush=pDC->SelectObject(&LavenderBrush);

	pDC->Rectangle(&rectRahmen);

    pNewBrush=pDC->SelectObject(&RotBrush);   

	pDC->Rectangle(&rect1);                   //Ausführungsbefehle//

	pNew1Brush=pDC->SelectObject(&GelbBrush); 

	pDC->Rectangle(&rect2);

	pNew2Brush=pDC->SelectObject(&OrangeBrush); 

	pDC->Rectangle(&rect3);

	pNew3Brush=pDC->SelectObject(&SteelBlueBrush); 

	pDC->Rectangle(&rect4);

	pNew4Brush=pDC->SelectObject(&SpringGreenBrush); 

	pDC->Rectangle(&rect5);

	pNew5Brush=pDC->SelectObject(&ForestBrush); 

	pDC->Rectangle(&rect5);

	pNew6Brush=pDC->SelectObject(&PinkBrush); 

	pDC->Rectangle(&rect6);

	pNew7Brush=pDC->SelectObject(&VioletBrush); 

	pDC->Rectangle(&rect7);

	pDC->TextOut(250,20,"Visualisierung einer Fertigungs-Strasse");

	pOldPen=pDC->SelectObject(&GruenStift);

	pOldBrush=pDC->SelectObject(&GruenBrush);

	pDC->Rectangle(&rectSchlitten);

	str.Format("Wert=%d",rectclient.right);           ///Rahmen Abmessung/////

	pDC->TextOut (100,50,str);

	str.Format("Wert=%d",rectclient.bottom);

	pDC->TextOut (170,50,str);

	pDC->SelectObject(pOldPen);

	pDC->SelectObject(pOldBrush);

	CVisuDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// ZU ERLEDIGEN: Hier Code zum Zeichnen der ursprünglichen Daten hinzufügen
}

/////////////////////////////////////////////////////////////////////////////
// CVisuView Drucken

BOOL CVisuView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// Standardvorbereitung
	return DoPreparePrinting(pInfo);
}

void CVisuView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// ZU ERLEDIGEN: Zusätzliche Initialisierung vor dem Drucken hier einfügen
}

void CVisuView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// ZU ERLEDIGEN: Hier Bereinigungsarbeiten nach dem Drucken einfügen
}

/////////////////////////////////////////////////////////////////////////////
// CVisuView Diagnose

#ifdef _DEBUG
void CVisuView::AssertValid() const
{
	CView::AssertValid();
}

void CVisuView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CVisuDoc* CVisuView::GetDocument() // Die endgültige (nicht zur Fehlersuche kompilierte) Version ist Inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CVisuDoc)));
	return (CVisuDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CVisuView Nachrichten-Handler

void CVisuView::OnTimer(UINT nIDEvent) 
{
	Beep(750,100);
	m_XRect=m_XRect+5;                                         //Deklaration Verschieben//
	Invalidate();	                                       		//Deklaration Neuzeichnen//
	CView::OnTimer(nIDEvent);
}

int CVisuView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;

	return 0;
}

void CVisuView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	SetTimer(1,300,NULL);	
	CView::OnLButtonDown(nFlags, point);
}

void CVisuView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	KillTimer(1);	
	CView::OnRButtonDown(nFlags, point);
}

void CVisuView::OnMove(int x, int y) 
{
	CView::OnMove(x, y);

	// TODO: Code für die Behandlungsroutine für Nachrichten hier einfügen

}

[estartu]

Prim3 schrieb:

Habe hier eine Grafik die ich mit einem Timer auf der X-Achse nach Oben bewege. Diese möchte ich nun nach dem 20sten Takt auf die Y-Achse umsteuern und nach links laufen lassen.

Du hast X und Y getauscht!
X ist rechts-links und Y ist hoch-runter.
Ich habe es so angewendet, wie man es in Mathe lernt.

Ich kürze mal, damit du die Änderungen auch findest.

/////////////////////////////////////////////////////////////////////////////
// CVisuView Nachrichten-Handler

void CVisuView::OnTimer(UINT nIDEvent) 
{
	if (m_nY < 20)
		m_nY++; // runter bewegen
	else
		m_nX++; // Seitlich bewegen
	Beep(750,100);
	m_XRect=m_XRect+5;                                         //Deklaration Verschieben//
	Invalidate();	                                       		//Deklaration Neuzeichnen//
	CView::OnTimer(nIDEvent);
}

void CVisuView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	SetTimer(1,300,NULL);	
	m_nX = 0; // Reset, los gehts
	m_nY = 0; // Reset, los gehts
	CView::OnLButtonDown(nFlags, point);
}

void CVisuView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	KillTimer(1);	
	CView::OnRButtonDown(nFlags, point);
}

Jetzt musst du m_nX und m_nY noch in OnDraw auswerten. Ich vermute, das gehört in diese Zeilen:

rectSchlitten.top=cy*0.5-m_XRect;          ///Ausführung Verschieben////
    rectSchlitten.bottom=cy*0.4-m_XRect;

    rectSchlitten.right=cx*0.95;
    rectSchlitten.left=cx*0.9;

Nur wie du da was rechnen muss kriege ich ohne Kenntnis deiner Rechnung (und der Idee dahinter) grade nicht hin.

[Prim3]

Jo Danke...muss da nichts Rechnen! Das ist die Bahn einer Fertigungs Strasse bei uns im Schul Labor.. Die Farblich unterteilten Bahnen sind verschiedene Sektoren die bereits mit Indukiv Sensoren bestückt sind... Es läuft alles drauf hinaus das die Signale von den Sensoren von einem Microcontroller erfasst werden und ich mit dessen Signalen in c++ darstellen kann wo welcher Schlitten sich befindet! Also noch jede Menge Arbeit.. so Probier es mal so aus wie du sagst! :p

[Prim3]

Glaube das Prinzip von der if else an der Stelle habe ich kapiert. Habe dann jetzt versucht nach dem else anfängt mit an einem bestimmtem Takt die ganze Sache wieder mit nem neuem if wieder auf der Y-Achse nach unten laufen tu lassen! Bin da mit if aber wohl auf dem Holzweg. Kannst du mir noch einer sagen wie ich dann nach else weiter machen muss damit noch ein paar mehr Richtungsänderungen einbauen kann???

Danke

Prim3

[Uruk-h4j]

ziemlich schwer zu lesen dein Programm....

Aber ich würde für die 4 Richtungen 2 Boolsche variablen anlegen die man dann kombinieren kann.

nennen wir wie mal

BOOL A;
BOOL B;

dann wäre:

A=0 und B=0 -> bewegung nach oben
A=0 und B=1 -> Bewegung nach rechts
A=1 und B=0 -> Bewegung nach unten
A=1 und B=1 -> Bewegung nach links

Wenn du jetzt festlegst, ab wann die Bewegung zu ende wäre, dann kannst du die Variablen setzen.

Z.B.

//Nach RECHTS
if((A == 0) && (B == 1))
{
 for(int i=0; i<=20; i++)
 { 
  //20schritte
  //Deine Funktionen

  if(i==20)
  {
    A = 0; //TRUE
    B = 0; //FALSE
  }
 }
}

//Nach OBEN
if((A == 0) && (B == 0))
{
 for(int j=0; j<=30; j++)
 { 
  //30 schritte
  //Deine Funktionen

  if(i==30)
  {
    A = 1; //TRUE
    B = 1; //FALSE
  }
 }
}

//USW

Ist recht pirmitiv, aber mit dem Prinzip kannst du deine Grafik theoretisch in alle ecken schubsen.

[Prim3]

BOOL A;
BOOL B;

Die Varaiblen BOOL A & B was ist das für nen Typ mit int habe ich das probiert. Oder wie lege ich das an damit der nicht mekert?

[Uruk-h4j]

verwende mal satzzeichen

BOOL ist ein Boolscher Wert, der "TRUE" (wahr) und "FALSE" (unwar / falsch) sein kann. Hat nichts mit Integer zu tun. Mit Integer das zu relisieren, was ich da gepostet hab ist umständlich und inffizient. ich glaiub man kann BOOL auch klein schreiben, also "bool". Sollte aber eigenlich keinen unterschied machen. VS kennt beide varianten.

[Martin Richter]

Uruk-h4j schrieb:

BOOL ist ein Boolscher Wert, der "TRUE" (wahr) und "FALSE" (unwar / falsch) sein kann. Hat nichts mit Integer zu tun. Mit Integer das zu relisieren, was ich da gepostet hab ist umständlich und inffizient. ich glaiub man kann BOOL auch klein schreiben, also "bool". Sollte aber eigenlich keinen unterschied machen. VS kennt beide varianten.

Du irrst schwer.
BOOL (großgeschrieben) ist ein int und kann jeden Wert eines int annehmen (auch -1, oder 4711). Deshalb sollte man eine BOOL Variable nicht mit TRUE vergleichen!

bool (kleingeschrieben) kann dagegen wirklich nur die Werte true (1) und false(0) (kleingeschrieben annehmen).

Ich verwende wo es geht nur bool!

[estartu]

Martin Richter schrieb:

Deshalb sollte man eine BOOL Variable nicht mit TRUE vergleichen!

Womit dann?

bool (kleingeschrieben) kann dagegen wirklich nur die Werte true (1) und false(0) (kleingeschrieben annehmen).

Ich verwende wo es geht nur bool!

Genau, aber sobald man eine GUI dabei hat, wird es bunt gemischt.

[Martin Richter]

[quote="estartu"]

Martin Richter schrieb:

Deshalb sollte man eine BOOL Variable nicht mit TRUE vergleichen!

Womit dann?
[quote="estartu"]

Meistens kann man sich einen Vergleich sparen. In einem if und while genügt es einfach die Variable zu schreiben ohne == oder !=.

Ansonsten ist nur der Vergleich zu FALSE sicher.

BOOL bMyState = 56; // Das geht!

if (bMyState) // OK
...
if (!bMyState) // OK
...
if (bMyState==FALSE) // OK
...
if (bMyState!=FALSE) // OK
...
if (bMyState==TRUE) // FAAAAALSCH!!!!!!
...
if (bMyState!=TRUE) // FAAAAALSCH!!!!!!
...

Ich verwendenur die Varianten 1 und 2!
Ein BOOL wir durch den Vergleich !=0 (!=FALSE) korrekt in einen bool gewandelt.

bool (kleingeschrieben) kann dagegen wirklich nur die Werte true (1) und false(0) (kleingeschrieben annehmen).

Ich verwende wo es geht nur bool!

Genau, aber sobald man eine GUI dabei hat, wird es bunt gemischt.

Aber das stört doch keinen. ein bool kann immer für ein BOOL herhalten!
Also bervorzuge ich grundsätzlich bool. Sag mir mal wo Du BOOL wirklich brauchst?

[estartu]

Kannst du das mit dem TRUE begründen?
Ich vergleiche tendenziell eher mit TRUE und habe noch keine direkten Nebenwirkungen bemerkt.

Alleine für die Wandlung BOOL nach bool mache ich das unzählige Male.

[Jochen Kalmbach]

estartu schrieb:

Kannst du das mit dem TRUE begründen?
Ich vergleiche tendenziell eher mit TRUE und habe noch keine direkten Nebenwirkungen bemerkt.

Vergelichst Du Variant-Bolls auch mit TRUE!? Dann machst Du aber was falsch... denn dort gibt es "VARIANT_TRUE"

FALSE ist eigentlich immer "0"! TRUE kann sich je nach (ungeschicktem) Define entweder 1 oder -1 sein...
Deswegen: Immer mit "FALSE" vergleichen und *nie* mit "TRUE"!

[Martin Richter]

estartu schrieb:

Kannst du das mit dem TRUE begründen?
Ich vergleiche tendenziell eher mit TRUE und habe noch keine direkten Nebenwirkungen bemerkt.

Alleine für die Wandlung BOOL nach bool mache ich das unzählige Male.

Horror!

Mein Beispiel, warum man es nie machen sollte:

BOOL bValue = 56; 
// Legaler Code und kann ein legaler return 
// wert einer SDK Funktion sein (dort steht nur !=0 bei success z.B.)

// boolValue ist nun false
bool boolValue = bValue==TRUE;

[estartu]

Okay, also ich verwende es eigentlich nur im Zusammenhang mit Checkboxen.
Da sollte es ja nicht so schlimm sein.

Martin Richter schrieb:

Mein Beispiel, warum man es nie machen sollte:

BOOL bValue = 56; 
// Legaler Code und kann ein legaler return 
// wert einer SDK Funktion sein (dort steht nur !=0 bei success z.B.)

// boolValue ist nun false
bool boolValue = bValue==TRUE;

Okay, wenn da "!=0 bei success" steht dann vergleiche ich auch auf 0.

[Martin Richter]

estartu schrieb:

Okay, also ich verwende es eigentlich nur im Zusammenhang mit Checkboxen.
Da sollte es ja nicht so schlimm sein.

Was prüfst Du da? Den Status?
Nur als Anmerkung: Auch hier sollte man vorsichtig sein. Eine Tristate-Checkbox kennt 0,1,2 und da 2!=TRUE ist, liegt hier mindestens auch solch ein Problem.
Du baust also die UI um und schon wirds lustig...

Man sollte ==TRUE niemals nicht und überhaupt nicht verwenden!

[estartu]

Hmm, viel zu viele Fallen für einen eigentlich so einfach scheinenden Datentyp.

[Martin Richter]

estartu schrieb:

Hmm, viel zu viele Fallen für einen eigentlich so einfach scheinenden Datentyp.

Die Falle ist immer der == Operator!

[hustbaer]

Martin Richter schrieb:

Man sollte ==TRUE niemals nicht und überhaupt nicht verwenden!

ACK!