Merge pull request #11 from instantiator/006-new-graphics

006 - new graphics

Author: instantiator

resistors/images/box_8x22.png

@@ -33,18 +33,31 @@ void app_init_resistor(App* app, ResistorType rtype) {
     app->state->resistor_type = rtype;
     app->state->edit_selection = 0;
     switch(rtype) {
-    case Resistor4Band:
+    case R3:
+        app->state->resistor_bands[0] = BandRed;
+        app->state->resistor_bands[1] = BandOrange;
+        app->state->resistor_bands[2] = BandYellow;
+        break;
+    case R4:
+        app->state->resistor_bands[0] = BandRed;
+        app->state->resistor_bands[1] = BandOrange;
+        app->state->resistor_bands[2] = BandYellow;
+        app->state->resistor_bands[3] = BandGreen;
+        break;
+    case R5:
         app->state->resistor_bands[0] = BandRed;
         app->state->resistor_bands[1] = BandOrange;
         app->state->resistor_bands[2] = BandYellow;
         app->state->resistor_bands[3] = BandGreen;
+        app->state->resistor_bands[4] = BandBlue;
         break;
-    case Resistor5Band:
+    case R6:
         app->state->resistor_bands[0] = BandRed;
         app->state->resistor_bands[1] = BandOrange;
         app->state->resistor_bands[2] = BandYellow;
         app->state->resistor_bands[3] = BandGreen;
         app->state->resistor_bands[4] = BandBlue;
+        app->state->resistor_bands[5] = BandPurple;
         break;
     default:
         FURI_LOG_E(TAG, "Unknown resistor type in app_init_resistor");

resistors/images/r3.png

@@ -7,7 +7,7 @@
 typedef struct AppState {
     uint8_t edit_selection;
     ResistorType resistor_type;
-    BandColour resistor_bands[5];
+    BandColour resistor_bands[6];
 } AppState;
 
 typedef struct App {

resistors/images/r4.png

@@ -3,202 +3,222 @@
 #include "resistor_logic.h"
 #include <math.h>
 
-// Xx_Xx_Xx_Xx_-_Xx\0 = 17 characters
-const char blank_descriptor_R4[14] = "             ";
-const char blank_descriptor_R5[17] = "                ";
-
-const int RESISTOR_NUMERIC_CHARS = 3;
-const int RESISTOR_MULTIPLIER_UNIT_CHARS = 7;
-const int RESISTOR_TOLERANCE_CHARS = 7;
-
-const int RESISTOR_NUMERIC_POSITION = 0;
-const int RESISTOR_MULTIPLIER_UNIT_POSITION = 4;
-const int RESISTOR_TOLERANCE_POSITION = 14;
+const int CHARS_NUMERIC = 3;
+const int CHARS_MULTIPLIER = 7;
+const int CHARS_TOLERANCE = 7;
+const int CHARS_TEMP_COEFF = 3;
+const int CHARS_CALCULATION = 12;
+
+const char BLANK_CALCULATION[] = "           "; // "nnn x 10^nn"
+const char BLANK_TOLERANCE[] = "       ";
+const char BLANK_TEMP_COEFF[] = "   ";
+
+const int INDEX_NUMERIC = 0;
+const int INDEX_MULTIPLIER = 4;
+const int INDEX_TOLERANCE = 0;
+
+const int NUMERIC_BANDS_PER_RESISTOR[6] = {-1, -1, 2, 2, 3, 3};
+const int MULTIPLIER_INDEX_PER_RESISTOR[6] = {-1, -1, 2, 2, 3, 3};
+const int TOLERANCE_INDEX_PER_RESISTOR[6] = {-1, -1, -1, 3, 4, 4};
+const int TEMP_COEFF_INDEX_PER_RESISTOR[6] = {-1, -1, -1, -1, -1, 5};
+
+bool has_tolerance(ResistorType rtype) {
+    return TOLERANCE_INDEX_PER_RESISTOR[rtype - 1] > -1;
+}
 
-//                                 "nnn x 10^nn @ nnnn%";
-const char blank_calculation[24] = "                   ";
+bool has_temp_coeff(ResistorType rtype) {
+    return TEMP_COEFF_INDEX_PER_RESISTOR[rtype - 1] > -1;
+}
 
 bool is_numeric_band(ResistorType rtype, int index) {
-    return index < (rtype - 2);
+    return index < NUMERIC_BANDS_PER_RESISTOR[rtype - 1];
 }
 
 bool is_multiplier_band(ResistorType rtype, int index) {
-    return index == (rtype - 2);
+    return index == MULTIPLIER_INDEX_PER_RESISTOR[rtype - 1];
 }
 
 bool is_tolerance_band(ResistorType rtype, int index) {
-    return index == (rtype - 1);
+    return index == TOLERANCE_INDEX_PER_RESISTOR[rtype - 1];
+}
+
+bool is_temp_coefficient_band(ResistorType rtype, int index) {
+    return index == TEMP_COEFF_INDEX_PER_RESISTOR[rtype - 1];
 }
 
 bool is_numeric_colour(BandColour colour) {
     return colour <= 9;
 }
 
-bool is_multiplier_colour() {
+bool is_multiplier_colour(BandColour colour) {
+    UNUSED(colour);
     return true;
 }
 
 bool is_tolerance_colour(BandColour colour) {
-    return colour == BandBrown || colour == BandRed || colour == BandGreen || colour == BandBlue ||
+    return colour == BandBrown || colour == BandRed || colour == BandOrange ||
+           colour == BandYellow || colour == BandGreen || colour == BandBlue ||
            colour == BandPurple || colour == BandGray || colour == BandGold ||
            colour == BandSilver;
 }
 
+bool is_temp_coeff_colour(BandColour colour) {
+    return colour == BandBrown || colour == BandRed || colour == BandOrange ||
+           colour == BandYellow || colour == BandBlue || colour == BandPurple;
+}
+
 BandColour
     alter_resistor_band(ResistorType rtype, int band, BandColour current_colour, int direction) {
     int colour = current_colour;
     bool accepted = false;
     while(!accepted) {
         colour += direction;
         if(colour > 11) colour = 0;
-        if(colour < 0) colour = 12;
+        if(colour < 0) colour = 11;
         if(is_numeric_band(rtype, band) && is_numeric_colour(colour)) accepted = true;
+        if(is_multiplier_band(rtype, band) && is_multiplier_colour(colour)) accepted = true;
         if(is_tolerance_band(rtype, band) && is_tolerance_colour(colour)) accepted = true;
-        if(is_multiplier_band(rtype, band) && is_multiplier_colour()) accepted = true;
+        if(is_temp_coefficient_band(rtype, band) && is_temp_coeff_colour(colour)) accepted = true;
     }
     return colour;
 }
 
-void update_resistance_number(ResistorType rtype, BandColour colours[], char string[], int index) {
-    int bands = rtype - 2;
+int decode_resistance_number(ResistorType rtype, BandColour colours[]) {
+    int bands = NUMERIC_BANDS_PER_RESISTOR[rtype - 1];
     int value = 0;
     for(int b = 0; b < bands; b++) {
         int pwr = bands - b - 1;
         int delta = ((int)pow(10.0, pwr)) * colours[b];
         value += delta;
     }
+    return value;
+}
 
+void update_resistance_number(ResistorType rtype, BandColour colours[], char string[]) {
+    int value = decode_resistance_number(rtype, colours);
     int length = snprintf(NULL, 0, "%d", value);
     char* str = malloc(length + 1);
     snprintf(str, length + 1, "%d", value);
 
-    char* target = string + index;
+    char* target = string + INDEX_NUMERIC;
     strncpy(target, str, length);
     free(str);
 }
 
-void update_resistance_multiplier_unit(BandColour colour, char string[], int index) {
-    char unit[] = "x 10^  ";
+char* decode_resistance_multiplier(BandColour colour) {
+    static char unit[] = "x 10^  ";
     if(colour > 9) {
         unit[5] = '-';
         unit[6] = (char)(48 + colour - 9);
     } else {
         unit[5] = (char)(48 + colour);
-        unit[6] = ' ';
+        unit[6] = '\0';
     }
-    char* target = string + index;
-    strncpy(target, unit, RESISTOR_MULTIPLIER_UNIT_CHARS);
+    return unit;
+}
+
+void update_resistance_multiplier(ResistorType rtype, BandColour colours[], char string[]) {
+    int multiplier_index = MULTIPLIER_INDEX_PER_RESISTOR[rtype - 1];
+    char* unit = decode_resistance_multiplier(colours[multiplier_index]);
+    char* target = string + INDEX_MULTIPLIER;
+    strncpy(target, unit, CHARS_MULTIPLIER);
 }
 
-void update_resistance_tolerance(BandColour colour, char string[], int index) {
-    char* target = string + index;
+char* decode_resistance_tolerance(BandColour colour) {
     switch(colour) {
     case BandBrown:;
-        char tolerance_brown[8] = "@ 1%   ";
-        strncpy(target, tolerance_brown, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "1%";
     case BandRed:;
-        char tolerance_red[8] = "@ 2%   ";
-        strncpy(target, tolerance_red, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "2%";
+    case BandOrange:;
+        return "3%";
+    case BandYellow:;
+        return "4%";
     case BandGreen:;
-        char tolerance_green[8] = "@ 0.5% ";
-        strncpy(target, tolerance_green, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "0.5%";
     case BandBlue:;
-        char tolerance_blue[8] = "@ 0.25%";
-        strncpy(target, tolerance_blue, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "0.25%";
     case BandPurple:;
-        char tolerance_purple[8] = "@ 0.1% ";
-        strncpy(target, tolerance_purple, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "0.1%";
     case BandGray:;
-        char tolerance_gray[8] = "@ 0.05%";
-        strncpy(target, tolerance_gray, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "0.05%";
     case BandGold:;
-        char tolerance_gold[8] = "@ 5%   ";
-        strncpy(target, tolerance_gold, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "5%";
     case BandSilver:;
-        char tolerance_silver[8] = "@ 10%  ";
-        strncpy(target, tolerance_silver, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "10%";
+    default:;
+        return "--";
+    }
+}
+
+void update_resistance_calculation(ResistorType rtype, BandColour bands[], char* string) {
+    strcpy(string, BLANK_CALCULATION);
+    update_resistance_number(rtype, bands, string);
+    update_resistance_multiplier(rtype, bands, string);
+}
+
+void update_resistance_tolerance(ResistorType rtype, BandColour colours[], char string[]) {
+    strcpy(string, BLANK_TOLERANCE);
+    int tolerance_index = TOLERANCE_INDEX_PER_RESISTOR[rtype - 1];
+    char* unit = decode_resistance_tolerance(colours[tolerance_index]);
+    char* target = string + INDEX_TOLERANCE;
+    strncpy(target, unit, CHARS_TOLERANCE);
+}
+
+char* decode_resistance_temp_coeff(BandColour colour) {
+    switch(colour) {
+    case BandBrown:;
+        return "100";
+    case BandRed:;
+        return "50";
+    case BandOrange:;
+        return "15";
+    case BandYellow:;
+        return "25";
+    case BandBlue:;
+        return "10";
+    case BandPurple:;
+        return "5";
     default:;
-        char tolerance_nk[8] = "@ ????%";
-        strncpy(target, tolerance_nk, RESISTOR_TOLERANCE_CHARS);
-        break;
+        return "--";
     }
 }
 
-void update_calculation(ResistorType rtype, BandColour bands[], char string[]) {
-    strcpy(string, blank_calculation);
-    update_resistance_number(rtype, bands, string, RESISTOR_NUMERIC_POSITION);
-    update_resistance_multiplier_unit(bands[rtype - 2], string, RESISTOR_MULTIPLIER_UNIT_POSITION);
-    update_resistance_tolerance(bands[rtype - 1], string, RESISTOR_TOLERANCE_POSITION);
-}
-
-void update_resistor_descriptor(ResistorType bands, BandColour resistor_bands[], char descriptor[]) {
-    if(bands == Resistor4Band) strcpy(descriptor, blank_descriptor_R4);
-    if(bands == Resistor5Band) strcpy(descriptor, blank_descriptor_R5);
-
-    for(int i = 0; i < bands; i++) {
-        int c = i * 3;
-        bool last_band = i == bands - 1;
-        if(last_band) {
-            descriptor[c] = '-';
-            c += 2;
-        }
-        switch(resistor_bands[i]) {
-        case BandBlack:
-            descriptor[c] = 'B';
-            descriptor[c + 1] = 'k';
-            break;
-        case BandBrown:
-            descriptor[c] = 'B';
-            descriptor[c + 1] = 'r';
-            break;
-        case BandRed:
-            descriptor[c] = 'R';
-            descriptor[c + 1] = 'e';
-            break;
-        case BandOrange:
-            descriptor[c] = 'O';
-            descriptor[c + 1] = 'r';
-            break;
-        case BandYellow:
-            descriptor[c] = 'Y';
-            descriptor[c + 1] = 'e';
-            break;
-        case BandGreen:
-            descriptor[c] = 'G';
-            descriptor[c + 1] = 'r';
-            break;
-        case BandBlue:
-            descriptor[c] = 'B';
-            descriptor[c + 1] = 'l';
-            break;
-        case BandPurple:
-            descriptor[c] = 'P';
-            descriptor[c + 1] = 'u';
-            break;
-        case BandGray:
-            descriptor[c] = 'G';
-            descriptor[c + 1] = 'y';
-            break;
-        case BandWhite:
-            descriptor[c] = 'W';
-            descriptor[c + 1] = 'h';
-            break;
-        case BandGold:
-            descriptor[c] = 'G';
-            descriptor[c + 1] = 'o';
-            break;
-        case BandSilver:
-            descriptor[c] = 'S';
-            descriptor[c + 1] = 'i';
-            break;
-        }
-    } // i
+void update_resistance_temp_coeff(ResistorType rtype, BandColour colours[], char string[]) {
+    strcpy(string, BLANK_TEMP_COEFF);
+    int temp_coeff_index = TEMP_COEFF_INDEX_PER_RESISTOR[rtype - 1];
+    char* unit = decode_resistance_temp_coeff(colours[temp_coeff_index]);
+    char* target = string + INDEX_TOLERANCE;
+    strncpy(target, unit, CHARS_TEMP_COEFF);
+}
+
+char* get_colour_short_description(BandColour colour) {
+    switch(colour) {
+    case BandBlack:
+        return "Bk";
+    case BandBrown:
+        return "Br";
+    case BandRed:
+        return "Re";
+    case BandOrange:
+        return "Or";
+    case BandYellow:
+        return "Ye";
+    case BandGreen:
+        return "Gr";
+    case BandBlue:
+        return "Bl";
+    case BandPurple:
+        return "Pu";
+    case BandGray:
+        return "Gy";
+    case BandWhite:
+        return "Wh";
+    case BandGold:
+        return "Go";
+    case BandSilver:
+        return "Si";
+    default:
+        return "--";
+    }
 }