void Convert(char *Str, void *pCh)
{
   float F;
   sscanf(Str, "%f", &F);
   *(float *)pCh= F;
}

  unsigned char mCh[4];
   ......
   Convert("0012.5000", mCh);

void Convert(char *Str, void *pCh)
{
    sscanf(Str, "%f", pCh);
}

  unsigned char mCh[4];
   ......
   sscanf("0012.5000", "%f", mCh);

f = float('0012.5000')
bytes = struct.pack('f', f)

#include <stdlib.h>
volatile float f;
char s[] = "2.4137";
int main (void)
{
f = atof(s);
return 0;
}

import struct

def strToFloat(string):
#для контроля преобразования строки во флоат используем функци. pack из модуля struct
res = struct.pack('f', float(string))
dd3 = hex(ord(res[3]))
dd2 = hex(ord(res[2]))
dd1 = hex(ord(res[1]))
dd0 = hex(ord(res[0]))
#print dd3, dd2, dd1, dd0

#ищем указатели на знак и точку
psighn = string.find('-')
ppoint = string.find('.')

#определяем знак мантиссы, выделяем целу. и дробну. часть
sighn = 0
integer = 0
fract = 0
if(psighn != -1):
sighn = 1
integer = string[1:ppoint]
else:
integer = string[:ppoint]
fract = string[ppoint+1:]+'0'
#print 'integer=', integer
#print 'fract=', fract


#определяем сколько бит занимает целая часть числа
int_data = int(integer, 10)
int_bit = 0
mask = 0x800000
if(int_data > 0):
for int_bit in range(0,24,1):
if((int_data & mask) == 0):
mask = mask >> 1

else:
int_bit = 23 - int_bit
#print 'MSB position =',int_bit
break

#print 'num of bits=',int_bit

#формируем смещённый показатель степени и добавляем его до флоат-числа
power = 127 + int_bit
#print 'power=',power
float_data = (power<<23)
#print 'float_data=',hex(float_data),'\n'

#добавляем до флоат-числа целу. часть без старшего единичного бита
#зануляем старший бит
temp = int_data&(~(2**int_bit))
#print temp
#добавляем целу. часть
float_data = float_data | (temp*(2**(23-int_bit)))
#print float_data

#определяем сколько бит осталось для дробной части
fract_bit = 23-int_bit
#print fract_bit

#само дробное число
fract_data = int(fract, 10)
#print fract_data

#определяем порядок числа
val = 0
if((fract_data > 0) and (fract_data <= 10)):
val = 10
elif((fract_data > 10) and (fract_data <= 100)):
val = 100
elif((fract_data > 100) and (fract_data <= 1000)):
val = 1000
elif((fract_data > 1000) and (fract_data <= 10000)):
val = 10000
elif((fract_data > 10000) and (fract_data <= 100000)):
val = 100000
#print val

#формируем дробну. часть числа
fract_float = 0
for k in range(0,fract_bit,1):
fract_data = fract_data*2
fract_float = fract_float << 1
if(fract_data >= val):
fract_data = fract_data-val
fract_float = fract_float|0x1
#print k
#print hex(fract_float)
#print fract_float

fract_data = fract_data*2
if(fract_data >= val):
fract_float = fract_float|0x1

#присоединяем дробну. часть к всему числу
float_data = float_data|fract_float
#print float_data
result=[0,0,0,0]
result[3]=0
if(sighn == 1):
result[3] = 0x80
result[3] = result[3]|(float_data>>24)&0xff
result[2] = (float_data>>16)&0xff
result[1] = (float_data>>8)&0xff
result[0] = (float_data)&0xff

print '\nethalon=', dd3, dd2, dd1, dd0
print 'my func=', hex(result[3]),hex(result[2]),hex(result[1]),hex(result[0])
return result

strToFloat('-25123.456')
strToFloat('1025.23')
trToFloat('36511.99')
strToFloat('23999.9988')