4. fortlaufende sinuskurve

fortlaufende sinuskurve

  • ?

    hallo zusammen,

    hab ein riesen problem:

    ich muss in edv ein pendel programmieren, das hin und her schwingt und parallel dazu, die aktuelle auslenkung bzw abstand zur 'befestigungsdecke' an hand eines höhe/zeit diagramms aufzeigen.

    das pendel hab ich so weit. es schwingt wunderschön mit hilfe eines timers hin und her. nur leider hab ich keine ahnung wie ich die kurve hinbekommen soll.

    bin echt ein totales winapigreenhorn.

    würd mich über hilfe freuen,
    thx

    0
  • F

    Wenn du das Pendel schon hast, dann kannst du doch einfach davon die y-Position als Höhe verwenden, oder was genau ist dein Problem / dein Frage 😕

    0
  • ?

    mathematisch ist mir das ganze klar.

    ich weiß einfach nicht wie ich es handwerklich mit winapi hinbekommen soll eine fortlaufende sinuskurve zu erhalten. wie gesagt, ich kenn mich damit so gut wie nicht aus ... edv ist ein lästiges anhängsel meines studiums...

    über vorschläge würde ich mich sehr freuen

    0
  • F

    Geht es dir also eher um die Darstellung, also die Zeitliche Verschiebung in x-Richtung? Also quasi sowas wie ein Schreiber, der die Auslenkung über der Zeit aufzeichnet 🙂

    0
  • T

    Hallo,

    meinst du sowas hier??

    der code ist aber MFC brauchst den einfach nur in API umschreiben 😉

    CWnd *wp; 
    CDC *pDC; 
    CRect Rect; 
    double y,von,bis; 
    int i,width,height; 
    von=-1.2; //scalierung 
    bis=+1.2; 

    wp = GetDlgItem(IDC_STATIC_DIAGRAMM); 
    pDC = wp->GetDC(); 
    wp->GetWindowRect(&Rect); 
    width=abs(Rect.TopLeft().x-Rect.BottomRight().x); 
    height=abs(Rect.TopLeft().y-Rect.BottomRight().y); 

    for(i=0;i<width;++i){ 
        double wert=sin(i*3.14/180);    
        if(bis>=wert && von<=wert){ 
            y=height-(height*(wert-von)/(bis-von)); 
            pDC->SetPixel(i,(int)y,RGB(255,0,0)); 
	}  
    }
    wp->ReleaseDC(pDC);

    wen du dich nicht mit MFC auskenst dan schreib nochmal da stelle ich es dir um 🙂

    MfG TaccoGo

    0
  • ?

    flenders hat recht: ich suche ein schreiber, der mir eine kurve aufzeichnet und immer wenn eine bestimmte zeit erreicht ist soll die bereits gezeichnete kurve wieder gelöscht werden und am ursprungspunkt der kurve weitergemacht werden.

    danke taccogo, leider hab ich von mfc keine ahnung. wäre also nett wenn du es mir umschreiben könntest... das non plus ultra wäre natürlich wenn du mir es unter berücksichtigung meiner obigen wünsche und an beispiels eines timers machen könntest.

    besten dank

    0
  • F

    Also soll dein Schreiber quasi bei x=0 starten und dann von links nach rechts bis z.B. x=100 laufen und wenn er dort ist, das Bild wieder löschen, und wieder bei x=0 anfangen. Oder soll er kontinuierlich durchlaufen - was etwas aufwändiger wäre.

    Zur Variante 1 würde ich so vorgehen, dass du ein Backbuffer (CreateCompatibleDC, CreateCompatibleBitmap, SelectObject) in Größe des Schreibers anlegst.
    In deinem Timer (hast du ja wohl für das Pendel schon) zählst du jetzt x von 0 bis zur Breite hoch (bei jedem WM_TIMER um eins hochsetzen). Dann setzt du an der Stelle x / y-Pendel mit SetPixel einen Punkt (besser wahrscheinlich mit einer Linie -> evtl. letzten Punkt merken. Dann verannlasst du per InvalidateRect eine WM_PAINT-Message, in der du dann mittels BitBlt den Backbuffer in dein Fenster zeichnest (so wie du es wohl auch beim Pendel schon machst)

    0
  • ?

    genau: muss dann halt bei x=0 mit der amblitude weitermachen die sie am ende hatte ... du hast mich aber glaub schon richtig verstanden.

    danke für deine vorschläge. aber wie gesagt: ich habe von winapi keine ahnung. ich hab von unserem prof beispielprogramme einfach kopiert und soweit ich verstanden habe einfach umgeschrieben, dass es ein pendel wird:

    BOOL pendeltimer_setzen(HWND hwnd)
    {

    SetTimer (hwnd, PENDELTIMER, 10, NULL);
    return 1;
    }

    BOOL pendeltimer_loeschen(HWND hwnd)
    {
    KillTimer (hwnd, PENDELTIMER);
    return 1;
    }

    BOOL pendel (HWND hwnd, double zeit)
    {

    int hoehe, breite;
    int ScreenColor;
    double phi_max=0.52359,x_komp,y_komp;

    HDC hdc ;
    PAINTSTRUCT ps ;
    RECT Rect;

    InvalidateRect (hwnd, NULL, TRUE) ;
    hdc = BeginPaint (hwnd, &ps) ;

    SetBkMode(hdc, TRANSPARENT);

    GetClientRect (hwnd, &Rect);

    hoehe = Rect.bottom;
    breite = Rect.right;

    ScreenColor = RGB(0, 0, 255);
    SelectBrush(hdc, CreateSolidBrush(ScreenColor));

    x_komp=(200*sin(phi_max*cos(sqrt(9.81/0.051)*zeit))); y_komp=(200*cos(phi_max*cos(sqrt(9.81/0.051)*zeit)));

    Ellipse(hdc, breite/4 - x_komp - 10, hoehe/4 + y_komp - 10, breite/4 -x_komp + 10, hoehe/4 +y_komp + 10);

    MoveToEx (hdc, breite/4, hoehe/4, NULL) ; LineTo (hdc, breite/4 - x_komp, hoehe/4 + y_komp) ;
    EndPaint (hwnd, &ps) ;

    UpdateWindow(hwnd);
    return 1;

    }

    0
  • F

    pendel wird dann in WM_PAINT aufgerufen?! Was wird bei WM_TIMER gemacht?
    Wenn du fertigen Code willst, wäre es geschickt dein bisherigen Rahmen zu haben, sodass es dann auch nachher richtig funktioniert und man sich Arbeit spart 😉

    0
  • ?

    hab grad meinen quellcode nicht zur hand da nicht zu hause an meinem rechner bin ...

    das ganze funktioniert glaub so:

    ich starte mein programm timer, dann gehts in WM_Timer von dort aus wird das pendelprogramm mit einem jeweils neuen wert (zeit + delta t) aufgerufen. und das passiert immer wieder bis ich in das programm timer gehe und der timer gelöscht wird.

    ich hoffe ich habs richtig erklärt ....

    thx

    0
  • ?

    @flenders

    würde mich immer noch sehr freuen, wenn du mir helfen könntest.
    das ganze bisherige programm habe ich jetzt auch zur verfügung.

    thx

    0
  • F

    Wenn du den Code irgendwie online stellen kannst, kann ich mir das mal anschauen - hab allerdings wahrscheinlich frühestens Sonntag-Abend wieder Zeit.

    0
  • ?

    wie gesagt,... ich komm echt nicht mehr weiter ... hab schon alles ausprobiert, gesucht und gelesen.

    hier der code (zwar goddes viel aber was solls):

    /*@@ Wedit generated application. Written Sat Oct 30 22:12:40 2004
 @@header: c:\programme\lcc\projects\pendel_1\pendel_1res.h
 @@resources: c:\programme\lcc\projects\pendel_1\pendel_1.rc
 Do not edit outside the indicated areas */
/*<---------------------------------------------------------------------->*/
/*<---------------------------------------------------------------------->*/
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <string.h>
#include "pendel_1res.h"
#include <math.h>									//wird zur trig. berechnung benoetigt

//BOOL pendelfaden (HWND hwnd, double zeit);
BOOL pendeltimer_setzen(HWND hwnd);
BOOL pendeltimer_loeschen(HWND hwnd);
BOOL pendel (HWND hwnd, double zeit);

/*<---------------------------------------------------------------------->*/
HINSTANCE hInst;		// Instance handle
HWND hwndMain;		//Main window handle

LRESULT CALLBACK MainWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
/* --- The following code comes from C:\Programme\lcc\lib\wizard\statbar.tpl. */

// Global Variables for the status bar control.

HWND  hWndStatusbar;

/*------------------------------------------------------------------------
 Procedure:     UpdateStatusBar ID:1
 Purpose:       Updates the statusbar control with the appropiate
                text
 Input:         lpszStatusString: Charactar string that will be shown
                partNumber: index of the status bar part number.
                displayFlags: Decoration flags
 Output:        none
 Errors:        none

------------------------------------------------------------------------*/
void UpdateStatusBar(LPSTR lpszStatusString, WORD partNumber, WORD displayFlags)
{
    SendMessage(hWndStatusbar,
                SB_SETTEXT,
                partNumber | displayFlags,
                (LPARAM)lpszStatusString);
}

/*------------------------------------------------------------------------
 Procedure:     MsgMenuSelect ID:1
 Purpose:       Shows in the status bar a descriptive explaation of
                the purpose of each menu item.The message
                WM_MENUSELECT is sent when the user starts browsing
                the menu for each menu item where the mouse passes.
 Input:         Standard windows.
 Output:        The string from the resources string table is shown
 Errors:        If the string is not found nothing will be shown.
------------------------------------------------------------------------*/
LRESULT MsgMenuSelect(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
{
    static char szBuffer[256];
    UINT   nStringID = 0;
    UINT   fuFlags = GET_WM_MENUSELECT_FLAGS(wparam, lparam) & 0xffff;
    UINT   uCmd    = GET_WM_MENUSELECT_CMD(wparam, lparam);
    HMENU  hMenu   = GET_WM_MENUSELECT_HMENU(wparam, lparam);

    szBuffer[0] = 0;                            // First reset the buffer
    if (fuFlags == 0xffff && hMenu == NULL)     // Menu has been closed
        nStringID = 0;

    else if (fuFlags & MFT_SEPARATOR)           // Ignore separators
        nStringID = 0;

    else if (fuFlags & MF_POPUP)                // Popup menu
    {
        if (fuFlags & MF_SYSMENU)               // System menu
            nStringID = IDS_SYSMENU;
        else
            // Get string ID for popup menu from idPopup array.
            nStringID = 0;
    }  // for MF_POPUP
    else                                        // Must be a command item
        nStringID = uCmd;                       // String ID == Command ID

    // Load the string if we have an ID
    if (0 != nStringID)
        LoadString(hInst, nStringID, szBuffer, sizeof(szBuffer));
    // Finally... send the string to the status bar
    UpdateStatusBar(szBuffer, 0, 0);
    return 0;
}

/*------------------------------------------------------------------------
 Procedure:     InitializeStatusBar ID:1
 Purpose:       Initialize the status bar
 Input:         hwndParent: the parent window
                nrOfParts: The status bar can contain more than one
                part. What is difficult, is to figure out how this
                should be drawn. So, for the time being only one is
                being used...
 Output:        The status bar is created
 Errors:
------------------------------------------------------------------------*/
void InitializeStatusBar(HWND hwndParent,int nrOfParts)
{
    const int cSpaceInBetween = 8;
    int   ptArray[40];   // Array defining the number of parts/sections
    RECT  rect;
    HDC   hDC;

   /* * Fill in the ptArray...  */

    hDC = GetDC(hwndParent);
    GetClientRect(hwndParent, &rect);

    ptArray[nrOfParts-1] = rect.right;
    //---TODO--- Add code to calculate the size of each part of the status
    // bar here.

    ReleaseDC(hwndParent, hDC);
    SendMessage(hWndStatusbar,
                SB_SETPARTS,
                nrOfParts,
                (LPARAM)(LPINT)ptArray);

    UpdateStatusBar("Ready", 0, 0);
    //---TODO--- Add code to update all fields of the status bar here.
    // As an example, look at the calls commented out below.

//    UpdateStatusBar("Cursor Pos:", 1, SBT_POPOUT);
//    UpdateStatusBar("Time:", 3, SBT_POPOUT);
}

/*------------------------------------------------------------------------
 Procedure:     CreateSBar ID:1
 Purpose:       Calls CreateStatusWindow to create the status bar
 Input:         hwndParent: the parent window
                initial text: the initial contents of the status bar
 Output:
 Errors:
------------------------------------------------------------------------*/
static BOOL CreateSBar(HWND hwndParent,char *initialText,int nrOfParts)
{
    hWndStatusbar = CreateStatusWindow(WS_CHILD | WS_VISIBLE | WS_BORDER|SBARS_SIZEGRIP,
                                       initialText,
                                       hwndParent,
                                       IDM_STATUSBAR);
    if(hWndStatusbar)
    {
        InitializeStatusBar(hwndParent,nrOfParts);
        return TRUE;
    }

    return FALSE;
}

/*<---------------------------------------------------------------------->*/
/*@@0->@@*/
static BOOL InitApplication(void)
{
	WNDCLASS wc;

	memset(&wc,0,sizeof(WNDCLASS));
	wc.style = CS_HREDRAW|CS_VREDRAW |CS_DBLCLKS ;
	wc.lpfnWndProc = (WNDPROC)MainWndProc;
	wc.hInstance = hInst;
	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
	wc.lpszClassName = "pendel_1WndClass";
	wc.lpszMenuName = MAKEINTRESOURCE(IDMAINMENU);
	wc.hCursor = LoadCursor(NULL,IDC_ARROW);
	wc.hIcon = LoadIcon(NULL,IDI_APPLICATION);
	if (!RegisterClass(&wc))
		return 0;
/*@@0<-@@*/
	// ---TODO--- Call module specific initialization routines here

	return 1;
}

/*<---------------------------------------------------------------------->*/
/*@@1->@@*/
HWND Creatependel_1WndClassWnd(void)
{
	return CreateWindow("pendel_1WndClass","pendel_1",
		WS_MINIMIZEBOX|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZEBOX|WS_CAPTION|WS_BORDER|WS_SYSMENU|WS_THICKFRAME,
		CW_USEDEFAULT,0,CW_USEDEFAULT,0,
		NULL,
		NULL,
		hInst,
		NULL);
}
/*@@1<-@@*/
/*<---------------------------------------------------------------------->*/
/* --- The following code comes from C:\Programme\lcc\lib\wizard\defOnCmd.tpl. */
void MainWndProc_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
	switch(id) {
		// ---TODO--- Add new menu commands here
		/*@@NEWCOMMANDS@@*/
		case IDM_EXIT:
		PostMessage(hwnd,WM_CLOSE,0,0);
		break;

		case IDM_PENDELTIMER_SETZEN:						//springt in pendeltimer setzen
			pendeltimer_setzen(hwnd);
		break;

		case IDM_PENDELTIMER_LOESCHEN:						//springt in pendeltimer loeschen
			pendeltimer_loeschen(hwnd);
		break;
	}
}

/*<---------------------------------------------------------------------->*/
/*@@2->@@*/
LRESULT CALLBACK MainWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{

	static double delta_t=0.001;							//zeitschritte
	static double zeit=0.0;									//vergangene zeit

	switch (msg) {
/*@@3->@@*/
	case WM_SIZE:
		SendMessage(hWndStatusbar,msg,wParam,lParam);
		InitializeStatusBar(hWndStatusbar,1);
		break;
	case WM_MENUSELECT:
		return MsgMenuSelect(hwnd,msg,wParam,lParam);
	case WM_COMMAND:
		HANDLE_WM_COMMAND(hwnd,wParam,lParam,MainWndProc_OnCommand);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
		case WM_TIMER:
		switch (wParam)
		{
			case PENDELTIMER:								//pendeltimer meldet sich
				//pendelfaden (hwnd, zeit=zeit + delta_t);	//springt in pendelfaden mit veraenderter zeit
				pendel (hwnd, zeit=zeit + delta_t);
			break;
        }
	default:
		return DefWindowProc(hwnd,msg,wParam,lParam);
	}
/*@@3<-@@*/
	return 0;
}
/*@@2<-@@*/

/*<---------------------------------------------------------------------->*/
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, INT nCmdShow)
{
	MSG msg;
	HANDLE hAccelTable;

	hInst = hInstance;
	if (!InitApplication())
		return 0;
	hAccelTable = LoadAccelerators(hInst,MAKEINTRESOURCE(IDACCEL));
	if ((hwndMain = Creatependel_1WndClassWnd()) == (HWND)0)
		return 0;
	CreateSBar(hwndMain,"Ready",1);
	ShowWindow(hwndMain,SW_SHOW);
	while (GetMessage(&msg,NULL,0,0)) {
		if (!TranslateAccelerator(msg.hwnd,hAccelTable,&msg)) {
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
	return msg.wParam;
}

BOOL pendeltimer_setzen(HWND hwnd)
{

	SetTimer (hwnd, PENDELTIMER, 10, NULL);  					// timer setzt alle 10ms ein
	return 1;
}

BOOL pendeltimer_loeschen(HWND hwnd)
{
	KillTimer (hwnd, PENDELTIMER);
	return 1;
}

BOOL pendel (HWND hwnd, double zeit)
{

    int hoehe, breite;
	int ScreenColor;
	double phi_max=0.52359,x_komp,y_komp;						// phi_max = maximaler auslenkwinkel
																// verschiebung des pendelendes zu aufhaengepunkt

	HDC hdc ;
	PAINTSTRUCT  ps ;
	RECT Rect;

	InvalidateRect (hwnd, NULL, TRUE) ;
	hdc = BeginPaint (hwnd, &ps) ;

	SetBkMode(hdc, TRANSPARENT); // Hintergrund setzen ... muss undurchsichtig werden

	GetClientRect (hwnd, &Rect);

	hoehe  = Rect.bottom;
	breite = Rect.right;

    ScreenColor = RGB(0, 0, 255);
    SelectBrush(hdc, CreateSolidBrush(ScreenColor));

	x_komp=(200*sin(phi_max*cos(sqrt(9.81/0.051)*zeit)));		//200 = radius vom pendel
	y_komp=(200*cos(phi_max*cos(sqrt(9.81/0.051)*zeit)));		//sqrt(9.81/0.51) = g/pendellänge real = konst. der diff. glg

    Ellipse(hdc,  breite/4 - x_komp - 10, hoehe/4 + y_komp - 10, breite/4 - x_komp + 10, hoehe/4 +y_komp + 10);   // zeichnet kugel
	                            // x-links, y-oben, x-rechts, y-unten

	MoveToEx (hdc, breite/4,      hoehe/4, NULL) ;  			// setzt pendelaufhaengung
    LineTo   (hdc, breite/4 - x_komp, 	  hoehe/4 + y_komp) ;  	// Zeichnet die Linie zu errechneten Koordinaten

	EndPaint (hwnd, &ps) ;

	UpdateWindow(hwnd);
	return 1;

}

    dankeschön

    0
  • F

    Sieht aus, als ob das immer noch nicht alles ist - den Code für pendel_1res.h hab ich z.B. nicht gefunden.

    Aber den Code sieht eh schon nicht ganz richtig aus - z.B. darfst du Begin-/EndPaint nur in WM_PAINT aufrufen (wo eigentlich auch alle Zeichenoperationen für das Fenster durchgeführt werden sollten). Deswegen denke ich solltest du dich erstmal ganz allgemein etwas belesen und dir ein paar Tutorials anschauen (später dann auch zu BackBuffering). Dir jetzt irgendeinen Code hinzuklatschen halte ich absolut nicht für sinnvoll, und habe derzeit auch nicht die Zeit dazu.

    0
  • W

    @TaccoGo
    hätte ich gewusst das dir der Code gefällt hätte ich vorher ein Patent drauf angemeldet 😃

    0
Anmelden zum Antworten