PIC O que significa "Demo Limit" no Mikroc?

Tarcisio Zewe Duarte · 12 de julho de 2020

// ===============================================================================
// --- Mapeamento de Hardware ---
#define clockPin RB4_bit
#define dataPin RB5_bit
#define latchPin RB6_bit

/////////////////////

#define MAX 20

// ===============================================================================
// --- VariÃ¡veis Globais ---

// --- Mapa de CaractÃ©res ---
const char DOIS_PONTOS[7][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 0, 0, 0, 0}};
const char ESP[7][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}};
const char ZERO[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 1, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 1, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char UM[7][6] = {{0, 0, 1, 0, 0, 0}, {0, 1, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 1, 1, 0, 0}};
const char DOIS[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}};
const char TRES[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char QUATRO[7][6] = {{0, 0, 0, 1, 0, 0}, {0, 0, 1, 1, 0, 0}, {0, 1, 0, 1, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 1, 1, 1, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}};
const char CINCO[7][6] = {{1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char SEIS[7][6] = {{0, 0, 1, 1, 0, 0}, {0, 1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char SETE[7][6] = {{1, 1, 1, 1, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}};
const char OITO[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char NOVE[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 1, 1, 0, 0, 0}};
const char LETRA_A[7][6] = {{0, 0, 1, 0, 0, 0}, {0, 1 ,0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}};
const char LETRA_B[7][6] = {{1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}};
const char LETRA_C[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char LETRA_D[7][6] = {{1, 1, 1, 0, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 1, 0, 0}, {1, 1, 1, 0, 0, 0}};
const char LETRA_E[7][6] = {{1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}};
const char LETRA_F[7][6] = {{1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}};
const char LETRA_G[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 1, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char LETRA_H[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}};
const char LETRA_I[7][6] = {{0, 1, 1, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 1, 1, 0, 0}};
const char LETRA_J[7][6] = {{0, 0, 1, 1, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0}, {1, 0, 0, 1, 0, 0}, {0, 1, 1, 0, 0, 0}};
const char LETRA_K[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 1, 0, 0, 0}, {1, 1, 0, 0, 0, 0}, {1, 0, 1, 0, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}};
const char LETRA_L[7][6] = {{1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}};
const char LETRA_M[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 1, 0, 1, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}};
const char LETRA_N[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 0, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 0, 1, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}};
const char LETRA_O[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char LETRA_P[7][6] = {{1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}};
const char LETRA_Q[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 0, 1, 0, 0}, {0, 1, 1, 0, 1, 0}};
const char LETRA_R[7][6] = {{1, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0}, {1, 0, 1, 0, 0, 0}, {1, 0, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}};
const char LETRA_S[7][6] = {{0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 0, 0}, {0, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char LETRA_T[7][6] = {{1, 1, 1, 1, 1, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}};
const char LETRA_U[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 0}};
const char LETRA_V[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}};
const char LETRA_W[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {1, 0, 1, 0, 1, 0}, {0, 1, 0, 1, 0, 0}};
const char LETRA_X[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 0, 1, 0, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}};
const char LETRA_Y[7][6] = {{1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 1, 0}, {0, 1, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 0, 0}};
const char LETRA_Z[7][6] = {{1, 1, 1, 1, 1, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0}};
// --------------------------

char mascara_2[80][7];
int k, l, m, o, lin, col, novacoluna, linha, coluna;


void Caracteres(char frase[MAX+1]) {
  int t = 0;
  int i, j;
  int inicio = 0;
  int fim = 5;

  while(frase[t] != '\0') {

    switch(frase[t]) {

        case ' ':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = ESP[j][i - inicio];
            }
          } break;

        case '0':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = ZERO[j][i - inicio];
            }
          } break;

        case '1':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = UM[j][i - inicio];
            }
          }

        case '2':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = DOIS[j][i - inicio];
            }
          } break;

        case '3':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = TRES[j][i - inicio];
            }
          } break;

        case '4':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = QUATRO[j][i - inicio];
            }
          } break;

        case '5':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = CINCO[j][i - inicio];
            }
           } break;

         case '6':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = SEIS[j][i - inicio];
            }
          } break;

         case '7':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = SETE[j][i - inicio];
            }
           } break;

          case '8':
            for (j = 0; j <= 6; j++) {
              for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = OITO[j][i - inicio];
            }
          } break;

         case '9':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = NOVE[j][i - inicio];
             }
           } break;

         case 'A':
            for (j = 0; j <= 6; j++) {
              for (i = inicio; i <= fim; i++) {
                mascara_2[i][j] = LETRA_A[j][i - inicio];
             }
          } break;

         case 'B':
            for (j = 0; j <= 6; j++) {
              for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = LETRA_B[j][i - inicio];
           }
          } break;

         case 'C':
           for (j = 0; j <= 6; j++) {
             for (i = inicio; i <= fim; i++) {
               mascara_2[i][j] = LETRA_C[j][i - inicio];
            }
           } break;

    case 'D':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_D[j][i - inicio];
        }
      } break;

    case 'E':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_E[j][i - inicio];
        }
      } break;

    case 'F':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_F[j][i - inicio];
        }
      } break;

    case 'G':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_G[j][i - inicio];
        }
      } break;

    case 'H':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_H[j][i - inicio];
        }
      } break;

    case 'I':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_I[j][i - inicio];
        }
      } break;

    case 'J':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
          mascara_2[i][j] = LETRA_J[j][i - inicio];
        }
      } break;

    case 'K':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_K[j][i - inicio];
        }
      } break;

    case 'L':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_L[j][i - inicio];
        }
      } break;

    case 'M':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_M[j][i - inicio];
        }
      } break;

    case 'N':
      for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_N[j][i - inicio];
        }
      } break;

    case 'O':
      for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_O[j][i - inicio];
        }
      } break;

    case 'P':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_P[j][i - inicio];
        }
      } break;

    case 'Q':
      for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_Q[j][i - inicio];
        }
      } break;

     case 'R':
      for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_R[j][i - inicio];
        }
      } break;

    case 'S':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_S[j][i - inicio];
        }
      } break;

    case 'T':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_T[j][i - inicio];
        }
      } break;

     case 'U':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_U[j][i - inicio];
        }
      } break;

     case 'V':
      for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_V[j][i - inicio];
        }
      } break;

    case 'W':
      for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_W[j][i - inicio];
        }
      }
    case 'X':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_X[j][i - inicio];
         }
      } break;

    case 'Y':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_Y[j][i - inicio];
        }
      } break;
    case 'Z':
       for (j = 0; j <= 6; j++) {
         for (i = inicio; i <= fim; i++) {
           mascara_2[i][j] = LETRA_Z[j][i - inicio];
        }
      } break;
   }

     inicio = inicio + 6;
     fim = fim + 6;
     ++t;
    }
}


void LimpaMatriz() {
  for (k = 0; k <= 6; k++) {
    for (l = 0; l <= 79; l++) {
      mascara_2[k][l] = 0;
    }
  }
}

void escreveMatriz() {
  bit pinState;
  char row = 0B1000000;
  for (linha = 0; linha <= 6; linha++) {
    latchPin = 0;
    for (coluna = 79; coluna >= 0; coluna--) {
      if (mascara_2[coluna][linha] == 1) {
        dataPin = 1; // Turn on this led
      }
      else {
        dataPin = 0; // Turn off this led
      }
      clockPin = 0;
      clockPin = 1;
      clockPin = 0;
    }
    for (o = 0; o <= 6; o++) {
      if ( row & (1 << o) ) {
        pinState = 0;
      }
      else {
        pinState = 1;
      }
      dataPin = pinState;
      clockPin = 0;
      clockPin = 1;
      clockPin = 0;
    }

    latchPin = 1;

    row = row >> 1;
  }
}


void interrupt() {                             //função reservada da interrupção

   if(TMR0IF_bit)                              //ocorreu overflow do Timer0?
   {                                           //sim

      TMR0IF_bit = 0x00;                       //limpa flag TMR0IF

      escreveMatriz();
   }
 }

void main() {

  CMCON        = 0x07;                        //desabilita os comparadores internos
  INTCON       = 0xE0;                        //habilita interrupção global, por periférico, e do Timer0
  T0CON        = 0xC8;                        //prescaler 1:1 para o Timer0
  TRISB        = 0x00;                        //Configura o PORTB como saída
  PORTB        = 0x00;                        //Inicializa o PORTB em 0

  LimpaMatriz();

  while(1) {

     Caracteres("OLA MUNDO");
     }
}

Boa noite

Estou tentando escrever um códico em C no Mikroc para um circuito integrado PIC 18F4550. Ao compilar o código, ele compila normalmente, quer dizer não aponta nenhum erro para nenhuma linha, mas no final aparece a fease "Demo Limit", e não é gerado o arquivo hexadecimal para gravação. Alguém sabe o que signica isso, e por que o compilador está agindo desta forma?

aphawk · 13 de julho de 2020

@Tarcisio Zewe Duarte ,

Significa que você está usando uma versão de demonstração do MikroC, a qual tem limite para o código binário criado.

No seu caso o tamanho do código gerado na compilação ultrapassa esse limite, porisso que não deixa gravar o resultado.

Tem de usar uma versão paga do MikroC ok ?

Paulo

Tarcisio Zewe Duarte · 13 de julho de 2020

@aphawk Pois é, eu pesquisei sobre isto ontem na internet, e li algo semelhante á isto. Mas o fato é que fiz um teste aqui, abri um programa que ja havia feito há um tempo, que era bem maior do que este, e ele compilou tranquilo, mas este que eu fiz estes dias não.

aphawk · 13 de julho de 2020

@Tarcisio Zewe Duarte ,

O tamanho do código fonte não tem relação direta com o objeto gerado.

Dependendo das funções utilizadas, quantidades de constantes, e comandos utilizados, dois programas aparentemente de mesmo tamanho podem gerar objetos um com o dobro do tamanho do outro.

Complicado ...

Paulo

Tarcisio Zewe Duarte · 13 de julho de 2020

@aphawk Entendo

adicionado 3 minutos depois

@aphawk Você é a primeira pessoa que vejo defender, ou pelo menos sugerir "pagar para utilizar um software", enquanto todo mundo está preocupado em 'crackear' e utilizar os programas livremente e de forma gratuita... hahaha

aphawk · 13 de julho de 2020

@Tarcisio Zewe Duarte ,

Kkkkkk olha, eu tenho alguns programas oficiais, os quais uso para ganhar dinheiro :

- Proteus com os módulos de Avrs e gráficos de simulação analogica

Valor na época ( com desconto após chorar muito mais de dois meses ) : US$ 2.700 se não me falha a memória.

- Bascom com as libraries I2C slave : na época 79 + 20 = 99 Euros.

O Proteus me dá um baita ganho de produtividade na simulação e de quebra me permite fazer as placas PCB.

Se parar para pensar, ele não é mais tão importante hoje pois tenho várias rotinas modularizadas prontas que uso em vários projetos, todas testadas com o Proteus durante o projeto de cada uma. O PCB Realmente eu poderia pagar para alguém fazer para mim pois enche o saco kkkkk

Mas o Bascom ... pelo suporte que eu tive tanto do Mark que é o autor quanto pelo Fórum sempre foi muito bom, muito rápido e eficiente. E a licença me permite dormir tranquilamente sem correr risco de tomar um processo ....

Eu acho que a questão se resume nisso :

Se vai fazer uso profissional, compre o programa.

Se vai apenas aprender e brincar, use os Demo.

Sei que existem programas crackeados de monte por aí , mas compensa o risco de manter um vírus ativo no seu computador ? Aí cada um escolhe o risco que quer correr, né ?

Paulo

Tarcisio Zewe Duarte · 13 de julho de 2020

@aphawk O Proteus é um baita programa para fazer placas, nunca vi outro melhor. A quem não goste dele, mas ele é melhor que o EASY EDA e o Altium. Além dele, tem outro que gosto bastante também, e também tenho um demo aqui, que é é o Microwind, o qual é um software para projetar circuitos integrados, mas por ser somente um demo, tem um monte de recursos dele que não d pra utilizar. Tenho formação em Elétrotécnica e Eletrônica, mas atualmente este não é meu "ganha pão", mesmo assim, nunca abandonei esta área, sempre estou fazendo alguma coisa nela, sou um autodidata.

aphawk · 13 de julho de 2020

@Tarcisio Zewe Duarte ,

Legal saber disso, meu amigo !

A formação não importa, conheçi muita gente sem formação superior que dava nó em muito engenheiro ....

Hoje em dia eu seria autodidata com certeza, a informação está disponível em alta qualidade em milhares de sites, não vejo nenhuma necessidade em se fazer um curso superior...

O Altium... nas mãos de um cara treinado, é muito superior ao Proteus como PCB, eu vi o Altium rotear uma placa cheia de SMD com 100% logo na primeira tentativa, sendo que no Proteus precisei fazer dezenas de tentativas e várias trilhas que ele deixava tentei no manual mesmo e mesmo assim não ia...

Mas o que vale é o aprendizado com as tentativas .... sempre falo aqui que você sempre aprende muito mais quando um projeto não dá certo !

Paulo

Tarcisio Zewe Duarte · 13 de julho de 2020

@aphawk A faculdade te ensina muito pouco pra falar bem a verdade, eu tenho formação superior em Design Pleno, e sei bem como isto funciona. Você costumava fazer as trilhas das tuas placas maualmente, ou usava o roteamento automático?

aphawk · 14 de julho de 2020

@Tarcisio Zewe Duarte ,

A faculdade apenas te ensina o básico, ir a fundo depende de você usar esse básico e querer evoluir.

Olha, eu posiciono os componentes, tento ir adaptando o tamanho da placa conforme vou percebendo que vai faltar área ... e depois eu faço o roteamento automático, e edito manualmente as trilhas que considero importante devido à frequência envolvida ou a corrente por elas. Tento sempre separar os Gnds analógico e digital para evitar surpresas ....

O roteamento automático ajuda muito, mas você tem de saber configurar direitinho as propriedades dos layers, das classes de trilhas, essas coisas básicas.

Paulo

Tarcisio Zewe Duarte · 14 de julho de 2020

1 hora atrás, aphawk disse:

@Tarcisio Zewe Duarte ,

A faculdade apenas te ensina o básico, ir a fundo depende de você usar esse básico e querer evoluir.

Olha, eu posiciono os componentes, tento ir adaptando o tamanho da placa conforme vou percebendo que vai faltar área ... e depois eu faço o roteamento automático, e edito manualmente as trilhas que considero importante devido à frequência envolvida ou a corrente por elas. Tento sempre separar os Gnds analógico e digital para evitar surpresas ....

O roteamento automático ajuda muito, mas você tem de saber configurar direitinho as propriedades dos layers, das classes de trilhas, essas coisas básicas.

Paulo

Se a placa for pequena e simples, até da pra encarar um roreamento manual, mas numa complexa, por exemplo com circuitos integrados com mais de 40 pinos, é loucura. Demora demais, além da grande chance de se cometer erros.

Você manda fazer tuas placas aqui no Brasil, ou na China?

adicionado 1 minuto depois

@aphawk

Se a placa for pequena e simples, até da pra encarar um roreamento manual, mas numa complexa, por exemplo com circuitos integrados com mais de 40 pinos, é loucura. Demora demais, além da grande chance de se cometer erros.

Você manda fazer tuas placas aqui no Brasil, ou na China?

aphawk · 14 de julho de 2020

@Tarcisio Zewe Duarte ,

Faço na China , na AllPCB, atendimento bem competente, qqr dúvida eles te perguntam para confirmar, a placa fica muito bem feita. O que complica é o frete via DHL... agora eles não podem declarar a menor então encareceu bastante , as últimas 40 placas que fiz eram de 5 modelos diferentes, uma era de cobre dupla espessura, todas eram razoavelmente grandes ( maiores do que 17 x 10 cm ), e paguei quando chegaram quase 700 reais de impostos e serviços “adicionais”, mesmo já tendo pago US$ 53 de frete na ALLPCB....

Paulo

Tarcisio Zewe Duarte · 29 de julho de 2020

@aphawk Eu normalmente faço na JLCPCB. Só pra você ter uma ideia, enquanto lá eu faço 5 placas de 4cm x 27cm por 90,00 reais, aqui no Brasil as empresas me cobraram 500, 700 ou até mesmo 1000,00 reais para fazer apenas uma única placa dessa.

aphawk · 30 de julho de 2020

@Tarcisio Zewe Duarte ,

Os preços chineses são imbatíveis, mas agora eles não estão mais alterando o valor das invoices e a taxação é quase 100% certa se vier via DHL ou FedEx.

Pode vir por outros fretes mas nesse caso sem rastreamento e prazos bem longos.

Hoje mesmo cotei 5 placas dupla face de 10,5 x 17 aqui numa empresa na Zona Leste de São Paulo, a qual já fechei vários pedidos no passado, e o preço foi bastante razoável, 300 reais para 5 placas, saiu 60 reais cada placa.

Se eu mandar fazer na China com frete via DHL passa de US$ 45 , e se for taxado então fica bem pior.... vou fechar aqui mesmo , fica pronto em 7 dias .

A importação tá complicando bastante agora , principalmente por DHL ou FedEx.

Paulo