This course will teach participants about installing and configuring Python, syntax, importing, statements, types, strings, booleans, files, lists, tuples, comprehensions, functions, and classes.

Hello guys.

I've mounted a system that uses a latch and a shift register to send values to 4 7-segment displays.

The displays show whatever is sent to them, but on a hexadecimal base. I need to send a __int16 number, but it's conversion has to show only decimal digits. For instance, if I sent a sequency from 7 to 12 in decimal, it would bring:

0x00000007 ( = 7 decimal)

0x00000008 ( = 8 decimal)

0x00000009 ( = 9 decimal)

0x0000000A ( = 10 decimal)

0x0000000B ( = 11 decimal)

0x0000000C ( = 12 decimal)

and so on.

I need to send only:

0x00000007 ( = 7 decimal)

0x00000008 ( = 8 decimal)

0x00000009 ( = 9 decimal)

0x00000010 ( = 16 decimal)

0x00000011 ( = 17 decimal)

0x00000012 ( = 18 decimal)

and so on.

Does anyone have any ideas?

Thank you.

I've mounted a system that uses a latch and a shift register to send values to 4 7-segment displays.

The displays show whatever is sent to them, but on a hexadecimal base. I need to send a __int16 number, but it's conversion has to show only decimal digits. For instance, if I sent a sequency from 7 to 12 in decimal, it would bring:

0x00000007 ( = 7 decimal)

0x00000008 ( = 8 decimal)

0x00000009 ( = 9 decimal)

0x0000000A ( = 10 decimal)

0x0000000B ( = 11 decimal)

0x0000000C ( = 12 decimal)

and so on.

I need to send only:

0x00000007 ( = 7 decimal)

0x00000008 ( = 8 decimal)

0x00000009 ( = 9 decimal)

0x00000010 ( = 16 decimal)

0x00000011 ( = 17 decimal)

0x00000012 ( = 18 decimal)

and so on.

Does anyone have any ideas?

Thank you.

Given an integer m, calculate an integer n such that the representation of m in decimal is the same numeral sequence as the representation of n in hexadecimal.

The application is that you have a number m you want to display and an output device that shows the hexadecimal representation of the number, but you want to be able to read the value from the device in decimal. To do that, you would apply the algorithm and send n to the device.

Is this the problem?

here's an example that would work out only up to 153 in decimal (99 in hex)

int auxiliar = 0;

unsigned _int16 sendvalue = 0;

for (int decvalue = 0; decvalue < 154; decvalue++)

{

if(aux == 9)

{

sendvalue = sendvalue + 6; // this skips the hexadecimal char digits (A, B, C, D, E and F)

auxiliar = 0;

}

Outport32(0x378,sendvalue)

sendvalue++;

auxiliar++;

}

Everytime the auxiliar reaches 10, it adds 6 to sendvalue to skip the char digits in hexadecimal. Unfortunatelly the code above only works up to 99 in hex, because 99 in hex is equal to 153 in decimal, and 100 in hex (witch should be the next number to be displayed) is equal to 256 in hex.

I hope now it's understandable, and I'm sorry for my bad english.

examples:

0x12 = (1 x 16^1) + (2 x 16^0) = 18

0x4236 = (4 x 16^3) + (2 x 16^2) + (3 x 16^1) + (6 x 16^0) = 16950

or just simply assign to type int:

_int16 x16 = 0x1234;

int x10 = x16;

x10 will hold 4660;

-ray

for (unsigned _int16 n = startvalue; n < endvalue; ++n)

{

if (!hasHexDigit(n))

{

Outport32(0x378, n);

}

}

If this is the correct interpretation of the problem, the remaining problem is to write the hasHexDigit function. A hex digit is represented by four bits, so it will be convenient to do this with bit manipulation. Example pseudocode:

bool hasHexDigit(unsigned _int16 n)

{

for each 4-bit nibble in n

if nibble > 9

return true

return false

}

This design is somewhat inefficient, since once it hits 0xA, it is not smart enough to skip to 0x10. You could remedy that by having hasHexDigit identify which nibble had the hex digit. Then the main loop could add 6 to that nibble to skip past the next set of numbers it would skip anyway.

Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

All Courses

From novice to tech pro — start learning today.

First, you convert it into a string, "14".

Then you add "0x" in front, so it becomes "0x14".

And then you use the sscanf function to convert it into the respective decimal integer, which is 20.

#include <stdio.h>

int dec2hex(int i)

{

char buffer[20];

int result;

sprintf(buffer, "0x%d", i);

sscanf(buffer, "%X", &result);

return result;

}

int main(void)

{

printf("%X\n", dec2hex(14));

return 0;

}