0
Упс. Вот что бывает, когда невнимательно смотришь в док по асму и пишешь в блокнотик, а не в ассемблер:
ADD R1, #1         
...
ADD R1, #2

Нужно заменить или на
ORL 1, #1 ; Абсолютный адрес регистра R1 в нулевом банке - не помню уже синтаксис, возможно надо писать @1
...
ORL 1, #2

или на
INC R1
...
INC R1
INC R1
  • avatar
  • Vga
  • 20 июня 2016, 04:21
+1
Во-первых, какая разница, сколько байт туда выплюнуто? Имеет значение только решена ли задача (на это влияют время, потраченное на выплевывание, количество кода, занятого выплевыванием, etc — как именно влияют зависит от проекта).
Во-вторых, ты считаешь неправильно. Не изучал вплотную протокол TM1638, но выплюнуть туда требуется 16 байт данных и требуемое для этого количество команд (максимум 34 байта — если каждый байт данных надо предварять командой, минимум 17 байт — если адрес не передавать, а команду write достаточно послать один раз). Обрати внимание, для вывода на CC индикатор, подключенный к TM1638 требуется передать ровно столько же байт.
В-третьих, применение индикатора определяется не уебищностью его интерфейса (исключения бывают, но это не тот случай, к тому же со всей инициализацией типичная реализация интерфейса HD44780 занимает от 500 команд и больше), а его потребительскими качествами.

Отсюда вывод: ты нихрена не понял и гонишь пургу на вполне нормальный чип.
  • avatar
  • Vga
  • 20 июня 2016, 03:24
0
В личке можно кинуть ссылку на файлообменник, если не хочется код публиковать. Если это не проблема — можно и прямо к топику приколоть.
  • avatar
  • Vga
  • 20 июня 2016, 02:44
0
ОК, упакованного нет (хотя комменты его упоминают — «Подпрограмма вывода результата из буфера упакованных BCD цифр» — лишний раз показывая, что комментам верить нельзя, только коду). Но зачем тебе BCD? Для вывода на LCD тебе нужен ASCII, переводи сразу в него. А для вывода на LED — тебе нужен 7SEG-код, опять же, трансформируй прямо в него.
И вот подобные избыточные преобразования uint32_t -> BCD -> ASCII — уже сожрут места не хуже чем конвертация из CC-кода в CA-код.

P.S. Дай полный код (можно в личку), я интегрирую в него мой вариант кода и ты сможешь проверить экспериментально, раз уж код читать не умеешь.
  • avatar
  • Vga
  • 20 июня 2016, 02:17
0
Ну и TL;DR моей позиции в обсуждении выше: разница между индикатором с СС и индикатором с CA на TM1638 при правильном подходе составляет до полусотни команд (проиллюстрировано кодом, в том числе на ассемблере 8051). Не так уж мало, но вполне можно выделить даже на МК с 2кб флеша.
Сколько в это можно впихнуть дополнительных менюшек? Ну, не знаю. У Леонида Ивановича в его паяльной станции меню — 30 кило кода на С (и килобайт 5-8 — скомпиленного), 50 команд с таким меню — один пункт, быть может.
  • avatar
  • Vga
  • 20 июня 2016, 02:10
+1
Вижу я, как оно «шлет из промежуточного буфера». Хотя, комментарии наводят на мысль, что в коде где-то есть сперва преобразование выводимого числа в упакованный BCD, затем распаковка в неупакованный BCD и уже он побуквенно выводится в индикатор с попутным удалением leading zeroes.
А вам бы посоветовал прокомментировать код (в смысле в коде)
В стиле «CLR F0; очистить пользовательский флаг»? Поведение кода описывается кодом, а не комментариями к нему, и у тебя я изучал именно код (комменты к нему по большей части довольно бесполезны).
  • avatar
  • Vga
  • 20 июня 2016, 02:04
0
т.е. если надо в третий разряд вывести число 7 — пишем Buf[2] = 7 (MOV #Buf+2, #7)
Ну, точнее, поместить туда надо не само число, а соответствующий ему код семисегментного индикатора, т.е. байт, где каждому сегменту индикатора соответствует бит. Так же как в строке хранится не число 7, а ASCII-код символа «7».
  • avatar
  • Vga
  • 20 июня 2016, 01:37
+1
Я от него отказался и написал почему.
Почему? Потому что для этого надо написать функцию размером в пару десятков команд, при двух килобайтах флеша в распоряжении?
Вы уже приводили функцию для индикатора с ОА?
В данном случае это она и есть. И тут нету извратов, достаточно простой и прямолинейный код.

Ну и чтобы десять раз не ходить — поясню твою ошибку. Она видна из приведенного кода — ты мыслишь шаблоном «считать цифирки по одной и сразу слать в индикатор». Это не нужно. Вместо этого надо выделить фреймбуфер и складывать цифирки туда, а затем просто отправить буфер на индикатор в один присест.
С фреймбуфером возможны два варианта. Первый — выводить в него данные как в строку, т.е. если надо в третий разряд вывести число 7 — пишем Buf[2] = 7 (MOV #Buf+2, #7), а конвертировать в требуемые индикатору данные при отправке. Этот вариант у меня реализуется функцией SendBuffer. Второй вариант — хранить буфер в том виде, в каком он отправляется на индикатор, тогда требуется конвертировать выводимый символ при записи его в буфер. Этим и занимается функция Put.
  • avatar
  • Vga
  • 20 июня 2016, 01:35
0
Нет, я думаю, что на тебя тупняк напал. Приведенная функция выведет данные на дисплей, при условии:
1) Дисплей включен нестандартно, первые 8 разрядов с CC, следующие 2 с CA
2) Данные для вывода на дисплей лежат в буфере uint8_t Buf[10], в виде маски для семисегментного индикатора (т.е. цифра 0 — 0x3F, 1 — 0x06, ..., 8 — 0x7F).
3) Функция SendByte отправляет на индикатор байт данных с автоинкрементом адреса
4) Перед вызовом SendBuffer адрес в индикаторе выставлен на 0.
  • avatar
  • Vga
  • 20 июня 2016, 01:24
+1
Данный пример рассматривает предложенный тобой изврат «8 цифр ОК и 2 цифры ОА». Надо отметить, на 8-битках с их убогим сдвигом он выигрывает у варианта «10 цифр с ОА». Впрочем, в таком случае заметно лучше будет работать вариант с 16-байтным буфером уже в формате RAW-данных для отправки на индикатор. В таком случае, вывод символа в буфер будет не Buf[3] = DigitToSegs[8], а Put(3, DigitToSegs[8]).
void Put(uint8_t Digit, uint8_t C) {
  uint8_t Shift = Digit > 7 ? 1 : 0;
  uint8_t Mask = 1 << (Digit % 8);
  for(uint8_t i = 0; i < 8; i++)
    if(C & (1 << i))
      Buf[i + Shift] |= Mask;
    else
      Buf[i + Shift] &= !Mask;
}

Данная функция, однако, занимает уже 51 команду на AVR. Быть может, можно ее и оптимизировать.
  • avatar
  • Vga
  • 20 июня 2016, 01:19
0
(на 8051, похоже, хуже — либо я оптимизирую хуже, чем GCC)
А, нет, в 21 команду уложился:
SendBuffer:
    MOV R0, #Buf           ; Buffer pointer
    MOV R2, #Buf+8         ; D9 buffer
    MOV R3, #Buf+9         ; D10 buffer
  loop:
    MOV A, @R0             ; Send CC byte
    ACALL SendByte
    MOV R1, #0             ; Prepare CA byte
    MOV A, R2              ; Load D9
    JNB A.0, S1            ; Move LSB to R1
    ADD R1, #1         
  S1:
    RR A                   ; Shift and store D9
    MOV R2, A
    MOV A, R3              ; Load D10
    JNB A.0, S2            ; Move LSB to R1
    ADD R1, #2
  S2:
    RR A                   ; Shift and store D10
    MOV R3, A
    MOV A, R1              ; Send CA byte
    ACALL SendByte
    INC R0                 ; Increment pointer
    CJNE R0, #Buf+8, loop  ; Check loop condition
    RET
  • avatar
  • Vga
  • 20 июня 2016, 01:01
+1
Я-то читал, а вот читал ли ты мой код? Именно этим он и занимается — берет буфер, скажем "__80.000" (закодированный сразу в кодах семисегментника, т.е. вместо 8, например, там будет 0x7F, а вместо точки — 0x80) и выплевывает его в индикатор в виде 16 последовательных байт. И на все про все на AVR уходит 25 команд (на 8051, похоже, хуже — либо я оптимизирую хуже, чем GCC).
  • avatar
  • Vga
  • 20 июня 2016, 00:53
0
Я таки не понимаю, о каком коде ты говоришь. В этой ветке — только LCD_SendDataByte, битовые возможности 8051 не использующий. Да и в простыне код, релевантный именно выводу на индикатор, а не подготовке данных, битовые возможности не использует (либо использует в том объеме, в каком они есть и на других МК — типа «дернуть одним пином из порта»).
  • avatar
  • Vga
  • 20 июня 2016, 00:27
+1
Для отправки одного символа через МТ1638 на индикатор подключенный по ОА требуется послать 8 байт с адресом и еще 8 байт с битами символа.
Зачем? Все гораздо проще — подготавливаешь в памяти буфер данных и отсылаешь его за один присест (одна команда для установки адреса на 0 и затем 16 команд передачи байта).
  • avatar
  • Vga
  • 20 июня 2016, 00:23
+1
Приведенный тобой код совершенно иррелевантен теме.
И объясни таки, что я предлагаю делять 32 раза.
  • avatar
  • Vga
  • 20 июня 2016, 00:03
+2
Приведенная мной функция разворачивается в 25 команд на ассемблере AVR, что явно меньше предложенных тобой 320. Полагаю, на 8051 она даже компактнее будет.
Сложно найти соответствие в твоей простыне, так как мухи (подготовка данных) плотно смешаны с котлетами (выводом на дисплей).
Мой код предполагает, что вывод данных производится в буфер uint8_t Buf[10], где хранится строка для выведения на дисплей, и что одиночный байт выводится в дисплей командой SendByte (по очередному адресу).
Говнокод не приветствуется…
Извини, но смешивание мух с котлетами я именно говнокодом и называю. Хотя, возможно, в данном случае он позволяет сократить размер ценой читабельности (что осмысленно только в том случае, если в итоге сэкономленные байты не окажутся залиты FF-ками).
  • avatar
  • Vga
  • 19 июня 2016, 23:56
+1
Что-то я не понял, что я предлагаю делать 32 раза.
К тмоу же, аналогом приведенной функции в моем коде является SendByte, которую я не расписывал (она не зависит от того, CC или CA индикаторы). И, полагаю, софтовый SPI на 8051 займет заметно больше места, нежели перекодирование данных под CA.
  • avatar
  • Vga
  • 19 июня 2016, 23:50
0
И?
  • avatar
  • Vga
  • 19 июня 2016, 23:42
0
SendByte((D9 & 0x01) | ((D10 & 0x02) >> 1));

Упс.
SendByte((D9 & 0x01) | ((D10 & 0x01) << 1));
  • avatar
  • Vga
  • 19 июня 2016, 23:32
0
Она компилируется менее оптимально (где-то на треть больше)
А точнее, 36 команд против 25, при компиляции на GCC 4.5.3 -O2. Основная причина — необходимость сдвигать Buf[8] и Buf[9] каждый раз заново (на AVR и x51 есть только однобитный сдвиг, на арме с его шифтером разницы не будет).
  • avatar
  • Vga
  • 19 июня 2016, 23:14