Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

Unimportant

Member
  • Content Count

    937
  • Joined

  • Last visited

Awards


This user doesn't have any awards

1 Follower

About Unimportant

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. They're IGBT's , not MOSFETS. First and foremost, thermal pads and heatsink compound (thermal paste) should never be used both at the same time. So the fact that there is no heatsink compound on the thermal pads is a good thing. As for why they switched to thermal pads there could be many reasons. The IGBT's in the old board are electrically isolated, they don't have a exposed metal tab and thus can be mounted directly to the heatsink. Perhaps the new board has a other type of IGBT's that are not electrically isolated (not clear from the picture). In that case the pads are required for isolation, removing them would cause a short circuit in that case... Perhaps thermal pads are just easier to implement in their (automated) production process... In any case, it's safe to assume their engineers did their homework and the cooling capacity of the thermal pads is adequate for the job. While not impossible, beefy IGBT's like that don't really die without reason. There's probably some deeper defect that caused the IGBT to fail in the first place. Simply swapping out the IGBT is unlikely to fix it.
  2. Unimportant

    Calculate math from string // c++

    Don't reinvent the wheel. The first step is to write a lexical analyzer, or lexer. With that as a search term you can find lots of articles online discussing the canonical ways of doing things.
  3. Unimportant

    Program idea

    Sounds like something you can easily do with a plain database.
  4. Unimportant

    Need to find GS7133 chip

    The numbers underneath could mean various manufacturer specific things such as production dates, batch numbers, etc... But the actual part is a GSTek GS7133 3A linear low dropout voltage regulator It's output voltage is set by a resistive divider network in the feedback and thus depends on the application. Some thoughts: The part is not necessarily broken. Some other defect in the circuitry on the device's output might be broken and pulling the output down. Most integrated voltage regulators like this have overcurrent and overtemperature protection so they don't break easily - you might want to do a bit more testing first. The package is a PSOP8, the P stands for "power", a variant on the SO8 package with a metal pad on the bottom which allows it to dissipate more power (https://ae01.alicdn.com/kf/HTB1oc2uKXXXXXafaXXXq6xXFXXXE/5-PCS-G57133-GS7133-SOP8-baru.jpg ). You will need a hot air desoldering station to remove it from the board, a plain soldering iron won't work. Even with a proper hot air desoldering station it might be tough, given that GPU boards have multiple layers with large power planes and can sink lots and lots of heat.
  5. Unimportant

    Help with C program that prints contents of a file

    The simplest way is to read the file character by character and print each character out until EOF is reached: #include <stdio.h> int main(int argc, char *argv[]) { if (argc != 2) { printf("Incorrect amount of command line parameters!\n"); return 1; } FILE* fptr = fopen(argv[1], "r"); if (!fptr) { printf("Error opening file!\n"); return 2; } while (1) { int ch = getc(fptr); if (ch == EOF) { return 0; } putchar(ch); } }
  6. Unimportant

    Help with C program that prints contents of a file

    When you compile with the flag "-Wimplicit-function-declaration" you should get: Which means the compiler has not seen a prototype for the function "open" yet (put simply: it does not exist) and has implicitly declared one as: int open(); Which is where your first error comes from: The implicitly declared open function returns a "int" which you then try to assign to a "FILE" pointer. You should use "fopen" instead. The reason "fopen" does not work is because you're giving it wrong parameters. Your second error: Is due to the fact that you're passing the result of the "readfile" function, which is of type "int" to "printf", which expects a "char" pointer, pointing to the string to print. Here's an example of what I think you're trying to do: #include <stdio.h> #include <stdlib.h> int ReadFile(const char *infile) { int num; FILE *fptr; fptr = fopen(infile, "r"); if (!fptr) { printf("Error opening file!\n"); exit(1); //abort program with nonzero return code, indicating error. } /* fscanf returns the number of items successfully extracted, which should be 1... because we ask to read a single integer. */ if (fscanf(fptr, "%d", &num) < 1) { printf("Failed to read a valid number!\n"); exit(2); } return num; } int main(int argc, char *argv[]) { if (argc != 2) { printf("Incorrect amount of command line parameters!\n"); return 3; } printf("Number read from file: %d\n", ReadFile(argv[1])); return 0; } ( Note that this example is simply a modification of your code to make it work. The whole program structure is questionable tough - Opening and reading the file should be handled by separate functions, removing the need for "exit", for example ).
  7. Unimportant

    Bench power supply short?

    The current dial allows you to set a current limit. When the load tries to pull more current then the set limit, the power supply will lower the output voltage as much as is required to keep the current at the limit. Since it only comes into action when the load tries to pull too much current you will not see any effect with little or no load. Normally one shorts the power supply's output in order to set the current limit. So, with your broken power supply. Turn the current limit dial all the way down to the lowest setting and then short the supply's output terminals with a (thick, decent) piece of wire. If it still limits the current (voltage needle will go to nearly zero) then the output transistors are likely OK and the problem lies in the voltage control loop. If it does not limit the current and the fuse pops then likely the output transistors are shorted out.
  8. Unimportant

    Writing file in c++

    Failing to handle errors, especially in this case where a user could easily enter text in stead of a integer, and having the program run off a cliff is plain wrong. It also confuses the students because their program does not behave as they are taught it would.
  9. Unimportant

    Writing file in c++

    One of the main problems is that schools and many (older) textbooks teach this stuff wrong. They (hopefully) teach students to check the result of operations before continuing and handling errors. However, when it comes to basic console keyboard input they tend to touch upon operator ">>" and then press on, without discussing error handling and whether or not the operation consumes delimiters or not. Operator ">>" does not consume the delimiter, it's still in the stream and the next input operation will return immediately because of it. getline does consume the delimiter. Furthermore, both can fail and you should check the stream state after each input operation. Operator ">>" is particularly prone to failure in this case due to erroneous user input. For example, you ask for a integer and the user enters text. Here's a little example that does proper error checking and flushes the stream after a successful read: #include <iostream> #include <string> #include <limits> // Completely clears the cin input stream. void FlushCin() { std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); } // Keeps trying to read a integer from cin until successfull. int ReadInt() { // Loop forever, we will return to caller once we have a successfull read. while (1) { std::cout << "Enter a integer: "; int i; /* Read integer and test stream state afterward. Streams inherit a operator bool that evaluates to false if the stream state went bad. */ if (std::cin >> i) { // Stream state OK, read successfull... FlushCin(); // Clear stream because operator ">>" leaves the delimiter in the stream. return i; } else { // Stream state bad, read failed... std::cout << "Failed to read a valid integer!, "; std::cin.clear(); // Clear stream error state... FlushCin(); // Flush the erroneous data from the stream. } } } int main() { int i = ReadInt(); std::cout << "\nYou entered " << i << "\n"; return 0; }
  10. Unimportant

    Bench power supply short?

    @Pagusi This should be easy to test. Turn down the current limit dial and short the output. If it still limits the current then the output transistors are almost certainly fine and the problem lies somewhere in the voltage control loop. If it does not limit current and blows it's fuse then the output transistors are likely shorted.
  11. Unimportant

    Show some of your favourite quirky code

    The literal value "65536" is of the integer type (assuming int is wide enough to hold the value). So this is a narrowing signed to unsigned conversion. The standard says: K&R used a different definition which boils down to the same thing: So the answer should always be 0. As a side note, even if bits were to be chopped off, endianness should not play a role. The high order bits are the high order bits, regardless of how the machine arranges them internally.
  12. Unimportant

    Swapping capacitors psu osborne 1

    Unlike @Radium_Angel 's claim,caps are not caps. There would be little use in having so much different types of capacitors if they'd all behave the same. whether or not you'll be able to replace a film capacitor with a ceramic capacitor depends entirely on the circuit it's in. Each capacitor would have to be evaluated separately. One of the main issues is the fact that ceramic capacitors change in value under DC bias. If a subcircuit applies a DC bias to a capacitor and requires any kind of precision then it's a no go. Ceramic capacitors also suffer from a piezoelectric effects. Mechanical vibrations can therefore affect the ceramic capacitor. Again, whether this is a problem or not depends on the circuit. Furthermore, film capacitors are typically available in greater capacitance / voltage values. You might not even be able to find a suitable replacement for some of the film capacitors. Power supplies also use safety capacitors of the "X" and "Y" type in several places. Make sure you use proper equivalents of the same safety classifications when replacing those.
  13. Unimportant

    if (x ever equals y) C#

    Sounds like a perfect case to use exceptions. Wrap the bool in a class of it's own so you have to go trough the class's interface to assign a value to it (in C++ you can overload the assignment operator to add some syntax sugar). Then have the interface function throw an exception whenever the wrapped bool is to be set.
  14. Unimportant

    Powering a CRT Fly back with 120VAC

    Depending on the transformer, if you put a light bulb in series with the primary, it's possible that some small stray voltage will be induced in the secondary. A couple tens of volts, perhaps 100V, but nothing worthwhile considering the aim is to generate several kilo volts. It's designed to operate at a CRT's horizontal frequency of around 15 KHz. At 60 Hz only a tiny amount of energy is transferred before the core saturates each cycle.
  15. Unimportant

    Powering a CRT Fly back with 120VAC

    The transformer winding will still look like a dead short. The light bulb will light with full intensity and nothing much else will happen.
×