|Message||The operating system cannot run %1.|
This appears to be a raw Win32 error. More information may be available in error 0x800700C2.
This is a Blue Screen of Death stop code. More information is available in the Knowledge Base article Bug Check 0xC2: BAD_POOL_CALLER.
This code indicates success, rather than an error. This may not be the correct interpretation of this code, or possibly the program is handling errors incorrectly.
|Description||The default facility code.|
|Error Code||194 (0x00c2)|
For microcontollers, you typically have to define your own
putc function to send bytes to whichever UART you're using.
Check the documentation for the libraries supplied with your compiler.
Note that this is entirely unrelated to how you intialise your UART. All that matters is which UART you're using.
(On an unrelated issue, rather than saying:
PINSEL0 = 0x00050000; /* Enable RXD1 TxD1 */ U1LCR = 0x00000083; /*8 bits, 1 Stop bit */
there are typically
#defines for registers which (usually) aid readability, provide a link to the bit names in the documentation, and reduce the need for comments to be added and maintained on every line like these. For example:
PINSEL0 = PICSEL0_RXD1EN | PICSEL0_TXD1EN; U1LCR = U1LCR_8BITS | U1LCR_1STOPBIT;
..and so on.)
puts() etc work on an embedded platform, you need to implement some hooks that work with the C library. This is typically dependent on the C libraries provided with your compiler, so is probably compiler-dependent. But in many cases the library just requires you to provide a
putc() function (or similar name), which takes a character (generated by the
printf() library function) and sends it to your chosen output device. That could be a memory buffer, serial port, USB message, whatever.
From the point of view of the C library, the
putc() function would be run-to-completion, so it's up to you whether you implement it to be a simple blocking function (waiting until the serial port is free and sending the character), or non-blocking (putting it into a buffer, to be sent by a background interrupt task; but the buffer might fill up if you output enough bytes fast enough, and then you have to either block or discard characters). You can also make it work properly with your RTOS if you have one, implementing a blocking write that sleeps on a semaphore until the serial port is available.
So, in summary, read the documentation for your compiler and its C library, and it should tell you what you need to do to make
Example links for AVR micro with GCC compiler:
ARM GCC compiler using newlib C library:
HvpRecoverData suggests corrupted registry. Fault during recovery process points to damaged hive log file (according to Windows Research Kernel sources). When I had this problem, deleting all
C:\Documents and Settings\<USERNAME>\NTUSER.DAT.LOG files helped. No user data or settings were lost in process in my case.
Here is some repeated advice from several forums:
I'd try booting from the install disk and running a repair.
ok, the RAM timings are ok. So it is no RAM issue. From the dumps, I can see that you use Windows 7 RTM at a patch level from June 2012. In April 2013 MS stopped releasing Updates for Win7 RTM. So install the Windows 7 Sp1 to get newer updates which also fix bugs.
This looks like a bad memory to me. Before changing the modules it would be worth a try to clean the contacts on them with isopropyl alcohol and give them a gentle rub to get rid of any oxidation. Also if running in a dual-channel mode make sure you are using exactly the same modules in each paired slot.
You're experiencing the problem due to several reasons- such as corrupt OS files, recent hardware changes, incorrect system settings, corrupt cache contents and other reasons. Repair your system files through System File Checker tool, disconnect recently connected hardware, revert-back newly applied system settings and delete temporary files and cache contents.
Download Hotfix and check if the problem still persists. Alternatively, perform manual steps given below until your problem is completely fixed. The actual steps are given below:
Step 1: Repair System Files
Step 2: Disconnect Recently Installed Hardware
Disconnect any recently installed hardware devices. Check for "Compatible for Windows" logo on the hardware package.
Step 3: Delete Cache Contents
Step 4: Restore Recent Settings
Are you sure you're handling the Disconnect callback accordingly ? As in do you clear and reload all your resources after a Surface::Diconnect ? If you do not handle Disconnect at all, your app will crash on resume. If you do handle it and you're not doing it the proper way your app will start using more and more memory and will crash if it goes past 170MB or so.
BAD_POOL_CALLER bug check that you've received has a value of 0x000000C2. This indicates that the current thread is making a bad pool request.
You can refer to the MSDN WIndows - Bug Check 0xC2: BAD_POOL_CALLER to identify the codes that you've received.
I would say that you either have:
e.g., Removing a USB device without using the
Safely remove USB devices can be sufficient to get that error.
Disconnect all external devices (printers, USB devices, etc...) and then boot up.
If this corrects the issue, connect the devices one at a time until you discover the piece of hardware causing the issue. An updated driver\software for the device should fix it.
Last known good configuration from the Windows Advanced Options menu.
If this option resolves the issue then look for any recent updates, or recently installed software that may have caused this problem.
Boot to Safe Mode from the Windows Advanced Options menu.
If you can enter windows using
safe mode, the issue is most likely related with a driver or software.
From within Safe Mode run a System Restore. (article with instruction here)
Perform a Clean Boot.
I would say it's a driver issue. I've used a free utility from Nirsoft - BlueScreenView. It scans all minidump files and presents them in a single table that makes identifying the culprit a lot easier.
I'm not sure about ARM in particular...
For some chips, within the IDE, you need to specify that you need a heap to use the printf, and how big it should be. The programmer won't automatically put one on.
Check in the menus of your programmer/IDE and see if there is a place to specify the heap size.
And I agree with Steve, this is only if you can actually use the printf, otherwise write your own little snippet.
You need to find the roots that holds these strings in memory. I have a few examples in my article: http://alexatnet.com/articles/net-memory-management-and-garbage-collector but generally what you might need to do is to use
!gcroot command - it should traverse object graph to one of the roots that holds this object.
There are two different heap types: native heaps (heaps of the heap manager) and managed heaps (heaps created by the .NET runtime). What you see as the output of
!dumpheap is only the managed part. Since your COM objects are also using native memory, this is not included in the output.
To see the native part of the memory, try
!address -summary. .NET memory will show up as
<unknown> and native memory will be listed as
Heap in the usage summary.
!dumpheap can be helpful, e.g. to see the number of RCW objects created by your application. RCWs are not very large, therefore they might not be listed near the end of the output. Try
!dumpheap -stat -type Interop to find them (if you`re using the default interop assembly).
If you know how large your COM objects are on native side, you can just multiply the number of object by the memory usage. In my typical environment, I'm using different COM objects with 5 MB to 100 MB in size, so even a few ones can cause
Knowing the exact size of a COM object is good for the use of GC.AddMemoryPressure which you can then use.
Sounds to me like a hard drive problem .. may be possible to recover by booting using a 'Live' CD with 'Parted Magic' & doing a complete format ..
User contributions licensed under CC BY-SA 3.0