ASM51

Bom dia a todos os amigos.

Estou com um problema e não sei como resolver,

Eu estou com um matriz e ela esta com a extenção .txt, eu quero gravar essa matriz (dados) em uma memória eeprom externa, porém para fazer isso os dados devem estar no formato binário com extenção .bin.

Como eu faço para converter esse .txt em bin?

Caso contrário vou ter que escrever byte a byte no editor da gravadora...uffa.

Obrigado

Vonnilmam escreveu:Bom dia a todos os amigos.

Estou com um problema e não sei como resolver,

Eu estou com um matriz e ela esta com a extenção .txt, eu quero gravar essa matriz (dados) em uma memória eeprom externa, porém para fazer isso os dados devem estar no formato binário com extenção .bin.

Como eu faço para converter esse .txt em bin?

Caso contrário vou ter que escrever byte a byte no editor da gravadora...uffa.

Obrigado

Simples, altere a extensão e mande gravar.
Um texto não passa de uma matriz de caracteres ascii. Já é um arquivo binário, o que um editor de texto faz é apenas converter em texto para exibir na tela, e tratar caracteres especiais: tabulações, quebra de linhas...

Para ficar mais claro eu sugiro que você procure o programa WINHEX. Abre o seu arquivo de texto nele, e veja como texto é formado, você vai ver os códigos, cada letra/simbolo já é um valor "binário"... mais ou menos isso, num sou muito bom em explicar.

Obrigado pelo retorno,

Eu acho que não expliquei direito, veja eu tenho um arquivo com extenção .txt, eu utilizo esse arquivo dentro do meu programa para ser compilado com o main, trata-se de uma matriz de caracteres. Porém eu quero gravar essa matriz em uma eeprom externa (24lc256), meu problema é aprender como migrar esse arquivo originalmente com extenção .txt para extenção .bin.

Obrigado e desculpas pelo mal entendido.

Perdão, esqueci de mencionar que utilizo o compilador mikroc,

A matriz é essa cedida pelo amigo andrepron...
Ela esta em um arquivo com extensão .txt e eu quero aprender se é possível migrar (se existe um programa que faça isso), para o formato .bin, caso contrário terei que fritar byte a byte na eeprom, ou fazer uma rotina que extraia isso do meu programa direito para um eepron...

00 00 00 00 00
00 00 6f 00 00
00 07 00 07 00
14 7f 14 7f 14
00 07 04 1e 00
23 13 08 64 62
36 49 56 20 50
00 00 07 00 00
00 1c 22 41 00
00 41 22 1c 00
14 08 3e 08 14
08 08 3e 08 08
00 50 30 00 00
08 08 08 08 08
00 60 60 00 00
20 10 08 04 02
3e 51 49 45 3e
00 42 7f 40 00
42 61 51 49 46
21 41 45 4b 31
18 14 12 7f 10
27 45 45 45 39
3c 4a 49 49 30
01 71 09 05 03
36 49 49 49 36
06 49 49 29 1e
00 36 36 00 00
00 56 36 00 00
08 14 22 41 00
14 14 14 14 14
00 41 22 14 08
02 01 51 09 06
3e 41 5d 49 4e
7e 09 09 09 7e
7f 49 49 49 36
3e 41 41 41 22
7f 41 41 41 3e
7f 49 49 49 41
7f 09 09 09 01
3e 41 49 49 7a
7f 08 08 08 7f
00 41 7f 41 00
20 40 41 3f 01
7f 08 14 22 41
7f 40 40 40 40
7f 02 0c 02 7f
7f 04 08 10 7f
3e 41 41 41 3e
7f 09 09 09 06
3e 41 51 21 5e
7f 09 19 29 46
46 49 49 49 31
01 01 7f 01 01
3f 40 40 40 3f
0f 30 40 30 0f
3f 40 30 40 3f
63 14 08 14 63
07 08 70 08 07
61 51 49 45 43
3c 4a 49 29 1e
02 04 08 10 20
00 41 7f 00 00
04 02 01 02 04
40 40 40 40 40
00 00 03 04 00
20 54 54 54 78
7f 48 44 44 38
38 44 44 44 20
38 44 44 48 7f
38 54 54 54 18
08 7e 09 01 02
0c 52 52 52 3e
7f 08 04 04 78
00 44 7d 40 00
20 40 44 3d 00
00 7f 10 28 44
00 41 7f 40 00
7c 04 18 04 78
7c 08 04 04 78
38 44 44 44 38
7c 14 14 14 08
08 14 14 18 7c
7c 08 04 04 08
48 54 54 54 20
04 3f 44 40 20
3c 40 40 20 7c
1c 20 40 20 1c
3c 40 30 40 3c
44 28 10 28 44
0c 50 50 50 3c
44 64 54 4c 44
00 08 36 41 41
00 00 7f 00 00
41 41 36 08 00
04 02 04 08 04

Vonnilmam escreveu:Porém eu quero gravar essa matriz em uma eeprom externa (24lc256)

Na verdade, voce teria de saber qual é o gravador e o respectivo programa pra gravar nessa EEPROM, pra saber quais os formatos necessários. A propósito, sugiro voce dar uma olhada nos editores avançados, como Ultraedit, Notepad++, etc... que deve ter recursos pra isso, ainda que voce tenha que alterar algo na mão ou de outro modo, como substituir o caratere espaço " " pelo prefixo "0x", e por aí afora.

Então, a gravadora que utilizo é a Elnec beeprog2...grava quase tudo, rss...

Por falar em gravar quase tudo, eu achei por caso do meu receptor de satélite, ter bugado numa atualização, um gravador de eeprom, muito interessante e que grava memórias 24 e 25, cavalares em tamanho...o aparelhinho funciona muito bem e ainda vira uma serial tx rx...gostei muito e aqui fica a dica: CH341, pesquise no sr google, tem dele no mercado livre...Deu até vontade de colocar meu projeto engavetado de bateria eletrônica, usando essas memórias 25l6406e, utilizada nesses receptores, são nada mais nada menos que 8 mega bytes...

Bom, não fugindo do tópico, estou com esse pepino para resolver, minha cuca não tá mais como era antes...

Acho que vou fazer uma rotininha (assembler é claro) para pegar essa matriz e socar tudo na eeprom, depois leio a bagacinha na gravadora, acho que será o caminho mais fácil para expostar o txt para bin...mas se alguém tiver outra idéia, por favor não se acanhe em compartilhar.

Depois postarei o código para vocês, se der tempo faço isso essa semana...

Obrigado a todos pela paciência com o véio vonnilmam.

Simples, Texto esta codificado em ASCII - Ver Tabela ASCII

Basta subtrair 30h

Ex.:
ASCII 30h = 0Oh
ASCII 31h = O1h
ASCII 39h = O9h

ASCII 40h = 1Oh => Letra A

Assim por diante

Dj.

vonnilman
Eu olhei o manual do seu programador e não achei que formatos ele suporta, mas a propaganda do site diz que ele suporta todos. Nesse caso eu escreveria um programinha em C para converter esse txt e formato hex da Intel que é simples e com certeza compatível com o seu gravador

https://en.wikipedia.org/wiki/Intel_HEX

Insisto em dizer, num precisa converter nada. Seu gravador grava arquivo .bin?

Um arquivo .bin nada mais é do que um arquivo sem formato nenhum, como se o primeiro byte dele fosse o primeiro byte do dispositivo onde vc vai gravar.

portanto, basta alterar a extensão de .TXT para .BIN no seu PC e mandar gravar com o seu gravador.

Tente fazer isso para ver o que acontece.

Agora, se você quiser formato .HEX da INTEL, ou seja , converter o .TXT para o .HEX da intel, faça o seguinte:

Baixe o WinHex
Abra o arquivo .TXT
Clique em Edit -> Convert file
Escolha o formato.

Nesse caso eu escreveria um programinha em C para converter esse txt e formato hex da Intel

Ao que parece, já fizeram isso no linux, e parece que nem precisa compilar....tá em script:
https://github.com/stffrdhrn/intelhex

Ou esse outro aqui em C#:
https://www.planet-source-code.com/vb/s ... &lngWId=10

Pô ! Já não fazem mais essas coisas online ?

ola vonnilmam! como eu suponho que o arquivo em questao sao aqueles caracteres do display que vc armazenar, eu montei um programinha em C que gera eles como binario:

Código: Selecionar todos

#include <stdio.h>

const char font[][5] = {
        {0x00,0x00,0x00,0x00,0x00},   //   0x20 32
        {0x00,0x00,0x6f,0x00,0x00},   // ! 0x21 33
        {0x00,0x07,0x00,0x07,0x00},   // " 0x22 34
        {0x14,0x7f,0x14,0x7f,0x14},   // # 0x23 35
        {0x00,0x07,0x04,0x1e,0x00},   // $ 0x24 36
        {0x23,0x13,0x08,0x64,0x62},   // % 0x25 37
        {0x36,0x49,0x56,0x20,0x50},   // & 0x26 38
        {0x00,0x00,0x07,0x00,0x00},   // ' 0x27 39
        {0x00,0x1c,0x22,0x41,0x00},   // ( 0x28 40
        {0x00,0x41,0x22,0x1c,0x00},   // ) 0x29 41
        {0x14,0x08,0x3e,0x08,0x14},   // * 0x2a 42
        {0x08,0x08,0x3e,0x08,0x08},   // + 0x2b 43
        {0x00,0x50,0x30,0x00,0x00},   // , 0x2c 44
        {0x08,0x08,0x08,0x08,0x08},   // - 0x2d 45
        {0x00,0x60,0x60,0x00,0x00},   // . 0x2e 46
        {0x20,0x10,0x08,0x04,0x02},   // / 0x2f 47
        {0x3e,0x51,0x49,0x45,0x3e},   // 0 0x30 48
        {0x00,0x42,0x7f,0x40,0x00},   // 1 0x31 49
        {0x42,0x61,0x51,0x49,0x46},   // 2 0x32 50
        {0x21,0x41,0x45,0x4b,0x31},   // 3 0x33 51
        {0x18,0x14,0x12,0x7f,0x10},   // 4 0x34 52
        {0x27,0x45,0x45,0x45,0x39},   // 5 0x35 53
        {0x3c,0x4a,0x49,0x49,0x30},   // 6 0x36 54
        {0x01,0x71,0x09,0x05,0x03},   // 7 0x37 55
        {0x36,0x49,0x49,0x49,0x36},   // 8 0x38 56
        {0x06,0x49,0x49,0x29,0x1e},   // 9 0x39 57
        {0x00,0x36,0x36,0x00,0x00},   // : 0x3a 58
        {0x00,0x56,0x36,0x00,0x00},   // ; 0x3b 59
        {0x08,0x14,0x22,0x41,0x00},   // < 0x3c 60
        {0x14,0x14,0x14,0x14,0x14},   // = 0x3d 61
        {0x00,0x41,0x22,0x14,0x08},   // > 0x3e 62
        {0x02,0x01,0x51,0x09,0x06},   // ? 0x3f 63
        {0x3e,0x41,0x5d,0x49,0x4e},   // @ 0x40 64
        {0x7e,0x09,0x09,0x09,0x7e},   // A 0x41 65
        {0x7f,0x49,0x49,0x49,0x36},   // B 0x42 66
        {0x3e,0x41,0x41,0x41,0x22},   // C 0x43 67
        {0x7f,0x41,0x41,0x41,0x3e},   // D 0x44 68
        {0x7f,0x49,0x49,0x49,0x41},   // E 0x45 69
        {0x7f,0x09,0x09,0x09,0x01},   // F 0x46 70
        {0x3e,0x41,0x49,0x49,0x7a},   // G 0x47 71
        {0x7f,0x08,0x08,0x08,0x7f},   // H 0x48 72
        {0x00,0x41,0x7f,0x41,0x00},   // I 0x49 73
        {0x20,0x40,0x41,0x3f,0x01},   // J 0x4a 74
        {0x7f,0x08,0x14,0x22,0x41},   // K 0x4b 75
        {0x7f,0x40,0x40,0x40,0x40},   // L 0x4c 76
        {0x7f,0x02,0x0c,0x02,0x7f},   // M 0x4d 77
        {0x7f,0x04,0x08,0x10,0x7f},   // N 0x4e 78
        {0x3e,0x41,0x41,0x41,0x3e},   // O 0x4f 79
        {0x7f,0x09,0x09,0x09,0x06},   // P 0x50 80
        {0x3e,0x41,0x51,0x21,0x5e},   // Q 0x51 81
        {0x7f,0x09,0x19,0x29,0x46},   // R 0x52 82
        {0x46,0x49,0x49,0x49,0x31},   // S 0x53 83
        {0x01,0x01,0x7f,0x01,0x01},   // T 0x54 84
        {0x3f,0x40,0x40,0x40,0x3f},   // U 0x55 85
        {0x0f,0x30,0x40,0x30,0x0f},   // V 0x56 86
        {0x3f,0x40,0x30,0x40,0x3f},   // W 0x57 87
        {0x63,0x14,0x08,0x14,0x63},   // X 0x58 88
        {0x07,0x08,0x70,0x08,0x07},   // Y 0x59 89
        {0x61,0x51,0x49,0x45,0x43},   // Z 0x5a 90
        {0x3c,0x4a,0x49,0x29,0x1e},   // [ 0x5b 91
        {0x02,0x04,0x08,0x10,0x20},   // \ 0x5c 92
        {0x00,0x41,0x7f,0x00,0x00},   // ] 0x5d 93
        {0x04,0x02,0x01,0x02,0x04},   // ^ 0x5e 94
        {0x40,0x40,0x40,0x40,0x40},   // _ 0x5f 95
        {0x00,0x00,0x03,0x04,0x00},   // ` 0x60 96
        {0x20,0x54,0x54,0x54,0x78},   // a 0x61 97
        {0x7f,0x48,0x44,0x44,0x38},   // b 0x62 98
        {0x38,0x44,0x44,0x44,0x20},   // c 0x63 99
        {0x38,0x44,0x44,0x48,0x7f},   // d 0x64 100
        {0x38,0x54,0x54,0x54,0x18},   // e 0x65 101
        {0x08,0x7e,0x09,0x01,0x02},   // f 0x66 102
        {0x0c,0x52,0x52,0x52,0x3e},   // g 0x67 103
        {0x7f,0x08,0x04,0x04,0x78},   // h 0x68 104
        {0x00,0x44,0x7d,0x40,0x00},   // i 0x69 105
        {0x20,0x40,0x44,0x3d,0x00},   // j 0x6a 106
        {0x00,0x7f,0x10,0x28,0x44},   // k 0x6b 107
        {0x00,0x41,0x7f,0x40,0x00},   // l 0x6c 108
        {0x7c,0x04,0x18,0x04,0x78},   // m 0x6d 109
        {0x7c,0x08,0x04,0x04,0x78},   // n 0x6e 110
        {0x38,0x44,0x44,0x44,0x38},   // o 0x6f 111
        {0x7c,0x14,0x14,0x14,0x08},   // p 0x70 112
        {0x08,0x14,0x14,0x18,0x7c},   // q 0x71 113
        {0x7c,0x08,0x04,0x04,0x08},   // r 0x72 114
        {0x48,0x54,0x54,0x54,0x20},   // s 0x73 115
        {0x04,0x3f,0x44,0x40,0x20},   // t 0x74 116
        {0x3c,0x40,0x40,0x20,0x7c},   // u 0x75 117
        {0x1c,0x20,0x40,0x20,0x1c},   // v 0x76 118
        {0x3c,0x40,0x30,0x40,0x3c},   // w 0x77 119
        {0x44,0x28,0x10,0x28,0x44},   // x 0x78 120
        {0x0c,0x50,0x50,0x50,0x3c},   // y 0x79 121
        {0x44,0x64,0x54,0x4c,0x44},   // z 0x7a 122
        {0x00,0x08,0x36,0x41,0x41},   // { 0x7b 123
        {0x00,0x00,0x7f,0x00,0x00},   // | 0x7c 124
        {0x41,0x41,0x36,0x08,0x00},   // } 0x7d 125
        {0x04,0x02,0x04,0x08,0x04}    // ~ 0x7e 126
    };

int main()
{
    char *p = &font[0][0];

    int i;

    for(i=0;i!=sizeof(font);i++)
    {
        putchar(p[i]);
    }
}

soh mudei o const byte por const char, visto que "byte" nao eh reconhecido pelo compilador no meu PC. enfim, compilei, gerei o arquivo de 475 bytes e visualizei da seguinte forma:

$ make charset
cc charset.c -o charset
charset.c:103:11: warning: initializing 'char *' with an expression of type 'const char *' discards qualifiers
[-Wincompatible-pointer-types-discards-qualifiers]
char *p = &font[0][0];
^ ~~~~~~~~~~~
1 warning generated.
$ ./charset > charset.bin
$ ls -la charset.bin
-rw-r--r-- 1 marcelo staff 475 Aug 7 12:33 charset.bin
$ hexdump -C charset.bin
00000000 00 00 00 00 00 00 00 6f 00 00 00 07 00 07 00 14 |.......o........|
00000010 7f 14 7f 14 00 07 04 1e 00 23 13 08 64 62 36 49 |.........#..db6I|
00000020 56 20 50 00 00 07 00 00 00 1c 22 41 00 00 41 22 |V P......."A..A"|
00000030 1c 00 14 08 3e 08 14 08 08 3e 08 08 00 50 30 00 |....>....>...P0.|
00000040 00 08 08 08 08 08 00 60 60 00 00 20 10 08 04 02 |.......``.. ....|
00000050 3e 51 49 45 3e 00 42 7f 40 00 42 61 51 49 46 21 |>QIE>.B.@.BaQIF!|
00000060 41 45 4b 31 18 14 12 7f 10 27 45 45 45 39 3c 4a |AEK1.....'EEE9<J|
00000070 49 49 30 01 71 09 05 03 36 49 49 49 36 06 49 49 |II0.q...6III6.II|
00000080 29 1e 00 36 36 00 00 00 56 36 00 00 08 14 22 41 |)..66...V6...."A|
00000090 00 14 14 14 14 14 00 41 22 14 08 02 01 51 09 06 |.......A"....Q..|
000000a0 3e 41 5d 49 4e 7e 09 09 09 7e 7f 49 49 49 36 3e |>A]IN~...~.III6>|
000000b0 41 41 41 22 7f 41 41 41 3e 7f 49 49 49 41 7f 09 |AAA".AAA>.IIIA..|
000000c0 09 09 01 3e 41 49 49 7a 7f 08 08 08 7f 00 41 7f |...>AIIz......A.|
000000d0 41 00 20 40 41 3f 01 7f 08 14 22 41 7f 40 40 40 |A. @A?...."A.@@@|
000000e0 40 7f 02 0c 02 7f 7f 04 08 10 7f 3e 41 41 41 3e |@..........>AAA>|
000000f0 7f 09 09 09 06 3e 41 51 21 5e 7f 09 19 29 46 46 |.....>AQ!^...)FF|
00000100 49 49 49 31 01 01 7f 01 01 3f 40 40 40 3f 0f 30 |III1.....?@@@?.0|
00000110 40 30 0f 3f 40 30 40 3f 63 14 08 14 63 07 08 70 |@0.?@0@?c...c..p|
00000120 08 07 61 51 49 45 43 3c 4a 49 29 1e 02 04 08 10 |..aQIEC<JI).....|
00000130 20 00 41 7f 00 00 04 02 01 02 04 40 40 40 40 40 | .A........@@@@@|
00000140 00 00 03 04 00 20 54 54 54 78 7f 48 44 44 38 38 |..... TTTx.HDD88|
00000150 44 44 44 20 38 44 44 48 7f 38 54 54 54 18 08 7e |DDD 8DDH.8TTT..~|
00000160 09 01 02 0c 52 52 52 3e 7f 08 04 04 78 00 44 7d |....RRR>....x.D}|
00000170 40 00 20 40 44 3d 00 00 7f 10 28 44 00 41 7f 40 |@. @D=....(D.A.@|
00000180 00 7c 04 18 04 78 7c 08 04 04 78 38 44 44 44 38 |.|...x|...x8DDD8|
00000190 7c 14 14 14 08 08 14 14 18 7c 7c 08 04 04 08 48 ||........||....H|
000001a0 54 54 54 20 04 3f 44 40 20 3c 40 40 20 7c 1c 20 |TTT .?D@ <@@ |. |
000001b0 40 20 1c 3c 40 30 40 3c 44 28 10 28 44 0c 50 50 |@ .<@0@<D(.(D.PP|
000001c0 50 3c 44 64 54 4c 44 00 08 36 41 41 00 00 7f 00 |P<DdTLD..6AA....|
000001d0 00 41 41 36 08 00 04 02 04 08 04 |.AA6.......|
000001db
$

como nao sei se vc tem um compilador C no seu computador, eu converti os dados e coloquei online para vc baixar e gravar direto:

https://darklife.org/marcelo/public/asm51/charset.bin

Boa tarde, a todos os Amigos do Forum.

Meu, o problema não esta na gravadora, só comentei dela afim de fornecer o maior quantidade de dados possíveis, essa gravadora da ELNEC é muito boa, a utilizo a 10 anos, show de bola, recomendo ela a todos que desejam algo profissional.

Bom, voltando ao assunto, realmente eu preciso converter um arquivo com extensão .TXT para HEX INTEL (.HEX ou .BIN)...

O ilustre amigo msamsoniuk, matou a charada, alias com méritos, pois fez um programa que gera o .BIN como tem que ser,

Realmente existe um programa que faz essa conversão, mas é para linux, e acredito que o saudoso DOS também tinha esse poder...mas...

Obrigado a todos, inclusive ao esforço do msamsoniuk.

Realmente tem WINHEX, faz essa proeza, ele converte .TXT para .BIN, faz isso com excelencia, acabei de testar e deu tudo certinho...

Muito OBRIGADO a todos os colegas,

MEU DEUS, QUANDO EU VOU ENTENDER ESSE TREM DE "C".

OBRIGADO

Isso, esse mapa é referente a tabela de caracteres que o amigo AndreTpron, me indicou.

Como eu ainda estou na luta para fazer a bendita matriz de leds, e não estava conseguindo êxito em fazer em C, acabei fazendo em assembler mesmo, já consegui fazer o clone de uma rotina que peguei no microcontrolandos, porém consegui alterar para 3 digitos de 7x5.

Bom tá tudo funcionando, tô simulando no isis, depois postarei aqui no forum os resultados.

Eu acabei fazendo em assembler, porque ainda estou crú em C e acabei ficando na NEURA de resolver o assunto, nem tô dormindo direito,

Bom, o objetivo é gravar a tabela de caracteres na eeprom, por isso eu estava tentando algo que fize-se isso de forma simples (o winhex resolveu), assim ganho mais espaço e agilidade no MCU, também vou gravar os buffers de caracteres na eeprom...

O objetivo final é enviar as mensagens pelo celular via SMS, bluthoot...


Vejam, não é que desisti do C, muito pelo contrário, estou percebendo aos poucos o poder de programação que ele tem e quero ser *****, como vocês o são.
Já fiz vários coisinhas em C, só brincando, criei algumas libs, aos poucos chego lá e contarei com a ajuda de vocês.

Esse projeto em especial, me deixou doido e quero concluir mesmo que em ASM, depois aos poucos vou migrar para o C, o importante é aprender o fundamento das coisas, como se faz, esse é meu objetivo no aprendizado do C.

Mas Graças a Deus, e a boa vontade de vocês, o veio vonnilmam, tá aprendendo. Rss





Ufa....Obrigado pela paciência,

a grande dica para vc aprender C: aprenda a fazer primeiro programas basicos para o PC, depois pense em embarcados. a maioria dos sistemas operacionais (linux, bsd, macos, etc) jah vem com um compilador C, mas no caso do windows vc pode instalar um tal de mingw, soh procurar na internet sobre ele e jah aparece como instalar!

Vonnilmam escreveu:Isso, esse mapa é referente a tabela de caracteres que o amigo AndreTpron, me indicou.

Como eu ainda estou na luta para fazer a bendita matriz de leds, e não estava conseguindo êxito em fazer em C, acabei fazendo em assembler mesmo, já consegui fazer o clone de uma rotina que peguei no microcontrolandos, porém consegui alterar para 3 digitos de 7x5.

Bom tá tudo funcionando, tô simulando no isis, depois postarei aqui no forum os resultados.

Eu acabei fazendo em assembler, porque ainda estou crú em C e acabei ficando na NEURA de resolver o assunto, nem tô dormindo direito,

Bom, o objetivo é gravar a tabela de caracteres na eeprom, por isso eu estava tentando algo que fize-se isso de forma simples (o winhex resolveu), assim ganho mais espaço e agilidade no MCU, também vou gravar os buffers de caracteres na eeprom...

O objetivo final é enviar as mensagens pelo celular via SMS, bluthoot...


Vejam, não é que desisti do C, muito pelo contrário, estou percebendo aos poucos o poder de programação que ele tem e quero ser *****, como vocês o são.
Já fiz vários coisinhas em C, só brincando, criei algumas libs, aos poucos chego lá e contarei com a ajuda de vocês.

Esse projeto em especial, me deixou doido e quero concluir mesmo que em ASM, depois aos poucos vou migrar para o C, o importante é aprender o fundamento das coisas, como se faz, esse é meu objetivo no aprendizado do C.

Mas Graças a Deus, e a boa vontade de vocês, o veio vonnilmam, tá aprendendo. Rss





Ufa....Obrigado pela paciência,

Olá, msamsoniuk


Caro amigo, já que você atiçou minha curiosidade, o DEV C++ também seria uma boa opção?