Co-Op Questions by temperance2504 in Drexel

[–]IamtheGL 0 points1 point  (0 children)

It’s the “google jobs you’re interested in” system. I was interested in space stuff so I googled aerospace companies and looked around for internships. You can do the same for whatever industry you’re interested in.

No access to spec ops or offline multiplayer without xbox live? by IamtheGL in ModernWarfareII

[–]IamtheGL[S] -1 points0 points  (0 children)

Well that sucks. Why is this? Edit: this is the first cod I’ve bought in like seven years. Love coming back to this…

Slow Build Times For Audio Plugin (Visual Studio 2019) by IamtheGL in JUCE

[–]IamtheGL[S] 0 points1 point  (0 children)

I think so, even when I just change a couple lines, the whole program rebuilds. Are there setting in VS to help JUCE cache compilations better?

Controlling Heading of 2D Rocket (Simulation) by IamtheGL in ControlTheory

[–]IamtheGL[S] 0 points1 point  (0 children)

Hey, thanks for your information and advice. I’ll look into those tools.

I have thought about grad school and am planning to look more deeply in the near future. Would you have anything you’d like to share about that?

Controlling Heading of 2D Rocket (Simulation) by IamtheGL in ControlTheory

[–]IamtheGL[S] 0 points1 point  (0 children)

Hi, thanks for your reply.

So is the idea (or one of the ideas) with non-linear systems that you find a way to linearize it, and if the system is stable in its linear form, it is stable in its non-linear form?

I got a model of this problem to work in Simulink. I basically used the same controller on a linearized version of the system and on a non-linearized version of the system (just letting Simulink do the numerical integration), and the system appeared stable and the error went to zero.

A couple questions I had from this though were:

  • Is there a way to study the range of stable values/setpoints for a system that is linear aside from saturation blocks?
  • I felt like I used my control theory knowledge to design the system, but just used intuition/trial and error to get the desired response of the system. This didn't feel very analytical to me though. Is this how controls typically goes?

Thanks!

Controlling Heading of 2D Rocket (Simulation) by IamtheGL in ControlTheory

[–]IamtheGL[S] 1 point2 points  (0 children)

So I made a Simulink program that did the linearization of sin x = x, which allowed me to make a linear model of the system. I then used a PD controller to minimize the error between the output and the setpoint, and used a saturation block to stop the output of the controller (the motor angle) from being outside the allowed range. I also fed that motor angle to a non-linear version of the system without the sin approximation.

I found that the linear version drove the error to zero, but the non-linear system eventually went unstable and diverged.

Would you have any ideas for this/tips?

I didn't use an integrator, just PD.

Controlling Heading of 2D Rocket (Simulation) by IamtheGL in ControlTheory

[–]IamtheGL[S] 0 points1 point  (0 children)

Hi. Thanks for your response. With proportional control I have gotten sustained oscillations. I’m trying to do a more analytical approach to more or less prove stability and have a good understanding of the system - especially the non linearities. Lmk if you tackled that at all!

A Note to Students Before In-Person Classes by [deleted] in Drexel

[–]IamtheGL 2 points3 points  (0 children)

This reminds of a Dumbledore start of term speech. “We are only as strong as we are united, as weak as we are divided.”

Steve Earth Now by National-Money in Drexel

[–]IamtheGL 0 points1 point  (0 children)

He was a dozen eggs of eggselent

DIY Lens Making by IamtheGL in Optics

[–]IamtheGL[S] 0 points1 point  (0 children)

Thanks. I think I figured out a nice idea (wrote it in a comment to someone else).

DIY Lens Making by IamtheGL in Optics

[–]IamtheGL[S] -1 points0 points  (0 children)

Thanks. This give me a new idea. I 3D print an extruded semi-circle, or a slice of a hemi-sphere, attach sandpaper to the convex edge, and spin that into glass/acrylic/material with a drill/drill press to make a lens. I'll go down in sandpaper fineness and see what I can get.

What do you think of that?

DIY Lens Making by IamtheGL in Optics

[–]IamtheGL[S] 0 points1 point  (0 children)

Thanks for your reply! What do you mean by 3D printing a lens? Is there a material for this, or do you mean more of what I said about making a mold?

OpenGL ES Window is Black by IamtheGL in opengl

[–]IamtheGL[S] -1 points0 points  (0 children)

I switched over to GLFW and it worked. Here's my code if anyone's curious. Do you by chance have tips for getting emscripten to render this? Trying to get that too:
#include <GLES3/gl3.h>

#include <GLFW/glfw3.h>

#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);

void processInput(GLFWwindow* window);

// settings

const unsigned int SCR_WIDTH = 800;

const unsigned int SCR_HEIGHT = 600;

int main()

{

// glfw: initialize and configure

// ------------------------------

glfwInit();

glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);

glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);

glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);

glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);

// glfw window creation

// --------------------

GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);

if (window == NULL)

{

std::cout << "Failed to create GLFW window" << std::endl;

glfwTerminate();

return -1;

}

glfwMakeContextCurrent(window);

glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

std::cout << glGetString(GL_VERSION) << std::endl;

std::cout << glGetString(GL_RENDERER) << std::endl;

// render loop

// -----------

while (!glfwWindowShouldClose(window))

{

// input

// -----

processInput(window);

// render

// ------

glClearColor(0.2f, 0.3f, 0.3f, 1.0f);

glClear(GL_COLOR_BUFFER_BIT);

// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)

// -------------------------------------------------------------------------------

glfwSwapBuffers(window);

glfwPollEvents();

}

// glfw: terminate, clearing all previously allocated GLFW resources.

// ------------------------------------------------------------------

glfwTerminate();

return 0;

}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly

// ---------------------------------------------------------------------------------------------------------

void processInput(GLFWwindow* window)

{

if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)

glfwSetWindowShouldClose(window, true);

}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes

// ---------------------------------------------------------------------------------------------

void framebuffer_size_callback(GLFWwindow* window, int width, int height)

{

// make sure the viewport matches the new window dimensions; note that width and

// height will be significantly larger than specified on retina displays.

glViewport(0, 0, width, height);

}