using dynamic_cast with template classes. - C / C++ / MFC Discussion Boards

It's similar if you look only at the very basic Kernel but things can be much more complex, painful and they may already have known problems

Some examples

1.) ARM Security/protection ring system usually at least two levels EL0 and EL1 and possibly EL2 & EL3 on an ARM8.
As an example FreeRTOS was not designed with those in mind, none of the existing ports will utilize the scheme with any intelligence.

2.) Multicore support on ARM cpus like ARM7 & ARM8.
You usually have to bring the MMU up to get cache coherency and that often means memory virtualization will need to be operating. For example on Free-RTOS I know of only a simple SMP port on a multicore system, no AMP and no BMP implementations. So FreeRTOS was not designed in an era with multicore support in mind.

3.) Multiple implementations which adds a whole complexity as your implementation becomes one of x number and not the most efficient or best suited to your CPU. You may struggle with massive code complexity on code that may not even compile in your implementation

If you are on a multicore cpu like a cortex-a53 points 1 & 2 will probably cause you a great deal of problem. That is why there are no real fully functional ports of Free-RTOS on things like Raspberry Pi 3 and beagle board blacks (there are a couple of half functional ports). So Free-RTOS is easy to port for simple single CPU it is harder to port and often at odds with how you want to operate complex multicore CPU's. Hence we come back to the problem what CPU are you talking about?

I would also add FreeRTOS has some obvious shortcomings of features you may like, like no concept of task aging etc (Aging (scheduling) - Wikipedia[^]

As with everything you are better of playing and working out what is a good system rather than mindlessly porting some system and not understanding it properly. So I might for example port FreeRTOS on a simple ARM5 or 6 cpu but I wouldn't bother about it on an ARM8 the later being far to different for what Free-RTOS was designed around.

Again I say if we know what CPU we are dealing with it is easier to make more detailed and helpful suggestions.

In vino veritas

modified 11-Jun-18 9:02am.

leon de boer wrote:
Again I say if we know what CPU we are dealing with it is easier to make more detailed and helpful suggestions.

Single core (STM32F4 and STM32F7). Since I'm working with rather basic microcontrollers and my applications really aren't that heavy, it's seems a bit overkill to do the context switching like an RTOS would do.

modified 11-Jun-18 9:21am.

You can't reach your goals without some switcher, I believe you already worked that our yourself it gets more and more complex.

There is actually less code in writing the switcher it's a couple hundred lines of code and it's faster as your CPU is designed to context switch Smile | :)

From "The Definitive Guide to ARM Cortex M3 and Cortex-M4" that is a 4 task round robin switcher in 150 lines of code.
You just need to change the scheduler (SysTick_Handler) to a priority based one .. you will find dozens on the net
You can extend the number of task etc, the code is very very obvious and easier than your current scheme you have reached.

#include "stm32f4xx.h"
// Keil::Device:STM32Cube HAL:Common

    #define LED0 (1<<7)
    #define LED1 (1<<8)
    #define LED2 (1<<9)
    #define LED3 (1<<10)

    /* Macros for word accesses */
    #define HW32_REG(ADDRESS) (*((volatile unsigned long *)(ADDRESS)))
    /* Use Breakpoint to stop when error is detected
    (KEIL MDK specific intrinsic) */
    /* it can be changed to while(1) XXif needed */
    #define stop_cpu __breakpoint(0)
    void LED_initialize(void); // Initialize LED
    void task0(void); // Toggle LED0
    void task1(void); // Toggle LED1
    void task2(void); // Toggle LED2
    void task3(void); // Toggle LED3
    // Event to tasks
    volatile uint32_t systick_count=0;
    // Stack for each task (8Kbytes each - 1024 x 8 bytes)
    long long task0_stack[1024], task1_stack[1024],
    task2_stack[1024], task3_stack[1024];
    // Data use by OS
    uint32_t curr_task=0; // Current task
    uint32_t next_task=1; // Next task
    uint32_t PSP_array[4]; // Process Stack Pointer for each task
    // -------------------------------------------------------------
    // Start of main program
    int main(void)
    {
    SCB->CCR |= SCB_CCR_STKALIGN_Msk; // Enable double word stack alignment
    //(recommended in Cortex-M3 r1p1, default in Cortex-M3 r2px and Cortex-M4)
    LED_initialize();
    // Starting the task scheduler
    // Create stack frame for task0
    PSP_array[0] = ((unsigned int) task0_stack)
    + (sizeof task0_stack) - 16*4;
    HW32_REG((PSP_array[0] + (14<<2))) = (unsigned long) task0;
    // initial Program Counter
    HW32_REG((PSP_array[0] + (15<<2))) = 0x01000000; // initial xPSR
    // Create stack frame for task1
    PSP_array[1] = ((unsigned int) task1_stack)
    + (sizeof task1_stack) - 16*4;
    HW32_REG((PSP_array[1] + (14<<2))) = (unsigned long) task1;
    // initial Program Counter
    HW32_REG((PSP_array[1] + (15<<2))) = 0x01000000; // initial xPSR
    // Create stack frame for task2
    PSP_array[2] = ((unsigned int) task2_stack)
    + (sizeof task2_stack) - 16*4;
    HW32_REG((PSP_array[2] + (14<<2))) = (unsigned long) task2;
    // initial Program Counter
    HW32_REG((PSP_array[2] + (15<<2))) = 0x01000000; // initial xPSR
    // Create stack frame for task3
    PSP_array[3] = ((unsigned int) task3_stack)
    + (sizeof task3_stack) - 16*4;
    HW32_REG((PSP_array[3] + (14<<2))) = (unsigned long) task3;
    // initial Program Counter
    HW32_REG((PSP_array[3] + (15<<2))) = 0x01000000; // initial xPSR
    curr_task = 0; // Switch to task #0 (Current task)
    __set_PSP((PSP_array[curr_task] + 16*4)); // Set PSP to topof task 0 stack
    NVIC_SetPriority(PendSV_IRQn, 0xFF); // Set PendSV to lowest possible priority
    SysTick_Config(168000); // 1000 Hz SysTick interrupton 168MHz core clock
    __set_CONTROL(0x3); // Switch to use Process Stack, unprivilegedstate
    __ISB(); // Execute ISB after changing CONTROL (architecturalrecommendation)
    task0(); // Start task 0
    while(1){
    stop_cpu;// Should not be here
    };
    }
    // ------------------------------------------------------------
    void task0(void) // Toggle LED #0
    { while (1) {
    if (systick_count & 0x80) {GPIOE->BSRRL = LED0;} // Set LED 0
    else {GPIOE->BSRRH = LED0;} // Clear LED 0
    };
    }
    // ------------------------------------------------------------
    void task1(void) // Toggle LED #1
    { while (1) {
    if (systick_count & 0x100){GPIOE->BSRRL = LED1;} // Set LED 1
    else {GPIOE->BSRRH = LED1;} // Clear LED 1
    };
    }
    // ------------------------------------------------------------
    void task2(void) // Toggle LED #2
    { while (1) {
    if (systick_count & 0x200){GPIOE->BSRRL = LED2;} // Set LED 2
    else {GPIOE->BSRRH = LED2;} // Clear LED 2
    };
    }
    // ------------------------------------------------------------
    void task3(void) // Toggle LED #3
    { while (1) {
    if (systick_count & 0x400){GPIOE->BSRRL = LED3;} // Set LED 3
    else {GPIOE->BSRRH = LED3;} // Clear LED 3
    };
    }
    // ------------------------------------------------------------
    __asm void PendSV_Handler(void)
    { // Context switching code
    // Simple version - assume No floating point support
    // -------------------------
    // Save current context

      MRS R0, PSP // Get current process stack pointer value
      STMDB R0!,{R4-R11} // Save R4 to R11 in task stack (8 regs)
      LDR R1,=__cpp(&curr_task)
      LDR R2,[R1] // Get current task ID
      LDR R3,=__cpp(&PSP_array)
      STR R0,[R3, R2, LSL #2] // Save PSP value into PSP_array
      // -------------------------
      // Load next context
      LDR R4,=__cpp(&next_task)
      LDR R4,[R4] // Get next task ID
      STR R4,[R1] // Set curr_task = next_task
      LDR R0,[R3, R4, LSL #2] // Load PSP value from PSP_array
      LDMIA R0!,{R4-R11} // Load R4 to R11 from task   stack (8 regs)
      MSR PSP, R0 // Set PSP to next task
      BX LR // Return
      ALIGN 4
    }
    // ------------------------------------------------------------
    void SysTick_Handler(void) // 1KHz
    { // Increment systick counter for LED blinking
    systick_count++;
    // Simple task round robin scheduler
    switch(curr_task) {
    case(0): next_task=1; break;
    case(1): next_task=2; break;
    case(2): next_task=3; break;
    case(3): next_task=0; break;
    default: next_task=0;
    stop_cpu;
    break; // Should not be here
    }
    if (curr_task!=next_task){ // Context switching needed
    SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk; // Set PendSV to pending
    }
    return;
    }
    // ------------------------------------------------------------
    void LED_initialize(void)
    {
    // Configure LED outputs
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOEEN; // Enable Port D clock
    // Set pin 12, 13, 14, 15 as general purpose output mode(pull-push)
    GPIOE->MODER |= (GPIO_MODER_MODER7_0 |
    GPIO_MODER_MODER8_0 |
    GPIO_MODER_MODER9_0 |
    GPIO_MODER_MODER10_0 ) ;
    // GPIOE->OTYPER |= 0; // No need to change - use pull-push output
    GPIOE->OSPEEDR |= (GPIO_OSPEEDER_OSPEEDR7 | // 100MHz operations
    GPIO_OSPEEDER_OSPEEDR8 |
    GPIO_OSPEEDER_OSPEEDR9 |
    GPIO_OSPEEDER_OSPEEDR10 );
    GPIOE->PUPDR = 0; // No pull up , no pull down
    return;
    }

In vino veritas

modified 11-Jun-18 10:49am.

Thank you for your very elaborate answers.

I've done cooperative multitaskers on a number of platforms (not ARM, but I don't think it should present any unusual problems) and found them to be extremely handy in cases where the set of tasks is fixed. Even if a task would spend most of its time in a loop:

while(!x_ready)
  task_spin();

the cost to switch to the task, check x_ready, and then switch to the next task may be less than the cost of a more complicated scheduler trying to decide if it should switch to that task.

The biggest design issue with a cooperative task switcher is deciding what invariants are going to hold any time code does a task_spin(). While a preemptive multitasker would require that functions acquire locks before breaking any invariant even temporarily, and re-establish the invariant before releasing the lock, cooperative task switching doesn't require that. More significantly, it doesn't require that tasks do anything special to handle the fact that a lock isn't available. The gotcha is that if an invariant can't be upheld during some operation, and the time required to perform that operation could grow beyond the maximum amount of time one wants to go without a task_spin(), handling that situation may be complicated.

C#

String Area = AreaCBox.Text;
          DAL.CaseBarCode csbrt = new DAL.CaseBarCode();
          System.Data.DataSet csbrs = csbrt.GetPO(Area);
          foreach (DataRow dr in csbrs.Tables[0].Rows)
          {

              POCBox.Items.Add(dr["ProductionOrder"]);

          }

Hello,

In the above the code I am calling a stored procedure(csbrt.GetPO(Area)) which retrieves two values "ProductionOrder" and "colorflag" columns. I am inserting ProductionOrder into 'POCBox' combobox.

Now my requirement is to color the text for ProductionOrder in the combobox to green if the colorflag value is 0 and color it red if the colorflag value is 1. Please help with the code. Thanks in advance.

What you want is called an "owner drawn" combobox.

There's a great article right here on CP that explains how to do it with all the code you need:

Implementing an OwnerDrawn ComboBox[^]

And by the way, you posted this in the C++ forum instead of the C# forum where it belongs. Smile | :)

The difficult we do right away...
...the impossible takes slightly longer.

//  Demonstrate dynamic_cast on template classes.
#include <iostream>
using namespace std;

template <class T>
class Num {
protected:
    T val;
public:
    Num(T x) { val = x;}
    virtual T getval() {    return val;    }
};

template <class T>
class SqrNum : public Num<T> {
public:
    SqrNum(T x) : Num<T>(x) {}
    T getval()  {   return (val * val);   }
};

int main(){
    Num<int> *bp, numInt_ob(2);
    SqrNum<int> *dp, sqrInt_ob(3);
    Num<double> numDouble_ob(3.3);

    bp = dynamic_cast<Num<int>*> (&sqrInt_ob);          //sqrInt_ob is from a derived class of Num<int>.
    if(bp) {
        cout << "Cast from sqrNum<int>* to Num<int>* OK.\n"
             << "Value is " << bp->getval() << endl;
    }
    else
        cout << "Error !\n\n";

    dp = dynamic_cast<SqrNum<int>> (&numInt_ob);        //numInt_ob is base class object and SqrNum is a derived class.
    if(dp)
        cout << "Error !\n";
    else {
        cout << "Cast from Num<int>* to SqrNum<int>* not OK.\n"
             << "Can't cast a pointer to a base object into\n"
             << "a pointer to a derived object\n\n";
    }

    bp = dynamic_cast<Num<int>*> (&numDouble_ob);        //Num<int> of type int & numDouble_ob is of type Num<double>
    if(bp)
        cout << "Error" << endl;
    else {
        cout << "Can't cast from Num<double>* to Num<int>*.\n"
             << "These are 2 different types.\n\n";
    }

    return 0;
}

in the code above i m getting error that

Quote:
error: 'val' was not declared in this scope
T getval() { return (val val); }
^~~

but

Quote:
class SqrNum : public Num<t>

according to this the protected value in the base class should just work fine as protected value in the derived class, but it isn't ?
How do i solve this problem ?

EDIT :
below is the working code:

//  Demonstrate dynamic_cast on template classes.
#include <iostream>
using namespace std;

template <class T>
class Num {
protected:
    T val;
public:
    Num(T x) { val = x;}
    virtual T getval() {    return val;    }
};

template <class T>
class SqrNum : public Num<T> {
public:
    SqrNum(T x) : Num<T>(x) {}
    T getval()  {   return (Num<T>::val * Num<T>::val);   }
};

int main(){
    Num<int> *bp, numInt_ob(2);
    SqrNum<int> *dp, sqrInt_ob(3);
    Num<double> numDouble_ob(3.3);

    bp = dynamic_cast<Num<int>*> (&sqrInt_ob);          //sqrInt_ob is from a derived class of Num<int>.
    if(bp) {
        cout << "Cast from sqrNum<int>* to Num<int>* OK.\n"
             << "Value is " << bp->getval() << endl;
    }
    else
        cout << "Error !\n\n";

    dp = dynamic_cast<SqrNum<int>*> (&numInt_ob);        //numInt_ob is base class object and SqrNum is a derived class.
    if(dp)
        cout << "Error !\n";
    else {
        cout << "Cast from Num<int>* to SqrNum<int>* not OK.\n"
             << "Can't cast a pointer to a base object into\n"
             << "a pointer to a derived object\n\n";
    }

    bp = dynamic_cast<Num<int>*> (&numDouble_ob);        //Num<int> of type int & numDouble_ob is of type Num<double>
    if(bp)
        cout << "Error" << endl;
    else {
        cout << "Can't cast from Num<double>* to Num<int>*.\n"
             << "These are 2 different types.\n\n";
    }

    return 0;
}

Thank you

modified 6-Jun-18 0:49am.

C++

dp = dynamic_cast<SqrNum<int>*> (&numInt_ob);        //numInt_ob is base class object and SqrNum is a

Needs an '*' after <int>.

Code now runs successfully.

i added * after SqrNum<int> but it is still giving that error .

Did not give that error in the original code that I compiled.

Quote:
template <class t="">
class SqrNum : public Num<t> {
public:
SqrNum(T x) : Num<t>(x) {}
T getval() { return (val * val); }
};

Should be

C++

template <class T>
class SqrNum : public Num<T> {
public:
    SqrNum(T x) : Num<T>(x) {}
    T getval()  {   return (Num<T>::val * Num<T>::val);   }
};

Quote:
return (Num<t>::val * Num<t>::val);

but i have already inherited all the members of the base class to the derived class, then why i need to use scope resolution operator to point where to look for val ?

See [35.19] Why am I getting errors when my template-derived-class uses a member it inherits from its template-base-class?[^]

thank's

You are welcome.

How can i access the Device manager part of the Windows API?

I want to beable to show what certain devices are connected in a project in a custom application.
ill be Writing it in C++
Any ideas?

This may be a good starting point.

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

Hi everyone!

I've been, for the past days, searching for the smallest executable for Windows. The reason is that I want to start a small macro for a game (basically just presses a key and maybe draw some pixels on screen), and I'd like it to be tiny, just for the sake of it. I'll not use NASM, however; I intend to use Ollydbg or another such tool to directly "code" in the executable itself (sort of like a challenge).

I searched the web for the smallest executable, and it appears to be 97 bytes large. I couldn't find it for download, but I don't think it would run in any version of Windows (I want it to run from XP up (XP,7,8,10)). I found one called "hh2 golden.exe" (~400 bytes), which apparently runs from XP up, but it prints "Hello World!" in the screen (I'd like one that did nothing).

Also, I couldn't assemble them (I don't know how to properly use NASM or other assembler). I'd use "hh2 golden.exe", but or other assemblerthen I had the idea to ask here if one of you guys have a better executable that I could use in this adventure.

tl;dr: I'm asking for the smallest executable capable of running from winXP up. Preferrably it does nothing, since I want to modify it and put some functionality to it (but I need it to be completely clear at the beginning)

Thanks!

There was a competition some time back to make the smallest PE header for windows. If you ran across golden I was surprised you didn't find the link
Tiny PE[^]
The answer was 97 bytes but it won't work on Windows 2000, 133 bytes to get it to work on Windows 2000.
I don't believe any of those work on Windows 7,8 or 10.

This one works on windows 10 x64bit I tried it ... that is 268 bytes
DPE64small/DPE64small.asm at master · DrakoPensulo/DPE64small · GitHub[^]

Having looked at it I think the statement the smallest PE is 252 bytes on Win32, or 268 bytes on Win64 is correct.
Personally I would go with the 268 bytes because it works on every windows version that exists currently.

Here is the layout of the created 268 byte executable
https://github.com/LdB-ECM/Docs_and_Images/blob/master/Images/Small_PE.jpg?raw=true

This is how windows sees the details on the file
https://github.com/LdB-ECM/Docs_and_Images/blob/master/Images/SmallPE_report.jpg?raw=true

I did have fun messing around with it thanks to your question.

For reference a linux executable PE you can squeeze to 45 bytes.

In vino veritas

modified 5-Jun-18 10:42am.

How can i be good on coding to start programming?

Understand problem solving.
Ask questions.
Ability to think outside the box.
et al

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

You will work hardly.
You will learn hardly.
You will communicate with other programmers (in Forums, news groups, and so on) hardly.
...
Good luck! Smile | :)

Quote:
~~How can i be good on coding to start programming?~~ I start programming in order to be good on coding.

FFY.

Experience matters.

Programming is more than just writing code - it's about solving problems with code. You'll need to develop analysis and troubleshooting skills in addition to straight coding skills.

Having said that, the best way to learn how to write code is to actually write code. You could start by looking at Codecademy. It's free, it's all done in the browser (so you don't have to set up a development environment on your local machine), and they cover a useful range of languages.

I haven't used it much myself, so I can't comment on the quality of the instruction. It may be good, it may be awful. Depends on what you want to learn.