AVR Z-LINK®

utilities.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
/* === Includes ============================================================ */
#include <stdint.h>
#include <stdbool.h>

#include "compiler.h"
#include "utilities.h"
/* ==== Macros ============================================================= */
/* === Typedefs ============================================================ */
/* === Variables =========================================================== */
/* === Prototypes ========================================================== */
/* === Implementation ====================================================== */


bool stringCompare( const uint8_t *str, const uint8_t __flash *fstr ){
        
        //Run until one of the strings are terminated.
        while( !( ( *str == END_OF_STRING ) || ( *fstr == END_OF_STRING ) ) ){
                
                //If they are not equal before END_OF_STRING, return false.
                if( *str != *fstr ){
                
                        break;
                }
                
                str++;
                fstr++;
        }
        
        //Both strings equal and of same length.
        if( ( ( *str == END_OF_STRING ) && ( *fstr == END_OF_STRING ) ) ){
        
                return true;  
        }
        
        //Equal, unequal or of different legth.
        else{
        
                return false;
        }
}

bool htoi8( uint8_t *hex, uint8_t *ret ){
        
        uint8_t i = 0x00;
        uint8_t radix = 1;
        *ret = 0x00;
        
        //Run through and check that the length is valid.
        while( *hex != '\0' ){
                
                //Return with false with the ascii char is not in 
                //the [0->F] range.
                if( !( ( ( *hex >= '0' ) && ( *hex <= '9' ) ) || 
                     ( ( *hex >= 'A' ) && ( *hex <= 'F' ) ) ) ){
                        
                        return false;  
                }
                
                hex++;
                i++;
        }
        
        //Only two or less digits. Valid conversion.
        if( i <= 0x02 ){
                
                hex--;
                
                //Do the actual conversion.
                for( ; i > 0; i-- ){
                
                        // 0->9
                        if( ( *hex >= '0' ) && ( *hex <= '9' ) ){
                
                                *ret += radix * ( *hex - '0' );  
                        }
                
                        //A->F
                        else{

                                *ret += radix * ( *hex - 'A' + 10 );                              
                        }
                
                        hex--;
                        radix = radix << 4; // Multiply by 16.
                }
                
                return true;  
        }
        
        //Return with an error.
        else{
          
                return false;
        }  
}

bool htoi16( uint8_t *hex, uint16_t *ret ){
        
        uint8_t i = 0x00;
        uint16_t radix = 1;
        *ret = 0x0000;
        
        //Run through and check that the length is valid.
        while( *hex != '\0' ){
                
                //Return with false with the ascii char is not in 
                //the [0->F] range.
                if( !( ( ( *hex >= '0' ) && ( *hex <= '9' ) ) || 
                     ( ( *hex >= 'A' ) && ( *hex <= 'F' ) ) ) ){
                        
                        return false;  
                }
                
                hex++;
                i++;
        }
        
        //Only Four or less digits. Valid conversion.
        if( i <= 0x04 ){
                
                hex--;
                
                //Do the actual conversion.
                for( ; i > 0; i-- ){
                
                        // 0->9
                        if( ( *hex >= '0' ) && ( *hex <= '9' ) ){
                
                                *ret += radix * ( *hex - '0' );  
                        }
                
                        //A->F
                        else{

                                *ret += radix * ( *hex - 'A' + 10 );                              
                        }
                
                        hex--;
                        radix = radix << 4;
                }
                
                return true;  
        }
        
        //Return with an error.
        else{
          
                return false;
        }
}