SED1335,PIC18F4550 и LCD320x240, разбираем по косточкам модуль SED1335.c Опции

[andreichk]

Привет народ.Вот решил я слепить себе нечто из указанных в теме компонентов.Нарисовал и изготовил макетку, красиво всё распаял и написал из надёрганных в сети кусков маленькую програмку для управления ЖКИ. Вначале, после нудного изучения даташитов никак не мог инициализировать ЖКИ, но потом разобрался что к чему и наконец он начал подавать признаки жизни и засветился.
Компилятор, который я пользую - CCS, имеет в своём составе файл SED1335.C , но как я не пытался приспособить его, так и не смог.Порывшись в сети,я нашёл другой файл с таким же названием, но вроде бы не для ПИКов, а для чего-то другого.Однако , слегка подшаманив его, я смог встроить его в прогу и он заставил таки выдавать на экран символы в текстовом режиме(даже с возможностью размещения в заданое место) и переключаться в графический режим.
И на этом всё и закончилось.
Все попытки нарисовать линию или круг или просто точку,несмотря на множество примеров, я так и не смог. Позаимствовав из старого файла процедуру

void glcd_pixel(int16 x, int16 y, int1 color)
{
int8 data;
int16 addr;
// Calculate the byte address containing the pixel
addr = GLCD_GRAPHICS_ADDR + (GLCD_WIDTH/8 * y + x/8);
// Read the byte of data at the address
data = getData(addr);
// Turn the pixel on or off
if(color == ON)
bit_set(data, 7 - x%8);
else
bit_clear(data, 7 - x%8);
// Write the new data byte to display memory
setData(addr, data);
}

я попробовал нарисовать на экране пиксель, но он вроде как нарисовался но разместился не в тех координатах, которые я указывал.Как я понимаю, за размещение отвечает строка
//GLCD_GRAPHICS_ADDR- нач. адрес- 1200, GLCD_WIDTH- кол во символов в строке- 320
addr = GLCD_GRAPHICS_ADDR + (GLCD_WIDTH/8 * y + x/8);
Может кто из вас раскомментирует эту странную формулу и подправит её, если она неправильная.

Сообщение отредактировал andreichk - Jan 25 2008, 21:03

[andreichk]

Ура !!! Заработало !!! Подправил биты инициализации.Умею нарисовать кружёчки и линии. И даже примитивный осциллограф получился.Берёт сигнал с АЦП1, а АЦП0 как развёртка, получается хреновенько, но как сказал известный демократ- ПРОЦЕСС ПОШЁЛ. Теперь надо научиться выводить параметры и картинки.Может кто подскажет , куды кинуться?

[arizona]

Теперь надо научиться выводить параметры и картинки.Может кто подскажет , куды кинуться?

посмотри микрочиповскую реализацию
www.microchip.com/graphics
и немного по-русски
http://microchip.com.ru/1010/Support/GUI.html

[andreichk]

посмотри микрочиповскую реализацию
www.microchip.com/graphics
и немного по-русски
http://microchip.com.ru/1010/Support/GUI.html

Спасибо, будем поглядеть

[andreichk]

Сегодня закончил оформление внешнего вида. Нарисовал сетку размером 320х240, но она вся не влезла, очевидно из-за каких-то ограничений.Пришлось поделить её на две части и с помошью процедуры перевёртыша загрузить два раза.Благодаря двухслойной функции экрана сетка не затирается.Так же нарисовал несколько маленьких картинок и подгрузил их для красявости.
Ниже привожу текст процедуры и фото

void bild(unsigned int16 addr,unsigned char data)
{
send_msg( 0x46, 1, 0, 1, 0 );
Output_bit(LCD_A0 ,0);
write_data( (addr) & 0x00ff );
write_data( (addr)>>8 & 0x00ff );
send_msg( 0x42, 1, 0, 1, 0 );//
Output_bit(LCD_A0 ,0);
Output_d(data);
Output_bit(LCD_CS,0);//
Output_bit(LCD_WR,0); //
Output_bit(LCD_WR,1);//
Output_bit(LCD_CS,1);//
}

void DrawImage(unsigned int16 y1,unsigned int16 y2 )// нормальный вид
{
unsigned int16 addr, x,y,i;i=0;
for (y = y1; y < y2; y++)
{
for (x = 0; x < 264;x=x+8)
{
addr = 40 * y + x/8 - 1 ;//10802;//расчитать байт адреса, содержащего пиксель
bild( addr,Grid_8x4[i++]);// работает
}
}
}//--------------------------OK
//#####################################################################
void DrawImage11(unsigned int16 y1,unsigned int16 y2 )// перевёртыш

{
unsigned int16 addr, x,y,i;i=3959;
for (y = y1; y < y2; y++)//
{
for (x = 264; x > 0;x=x-8)
{
addr = 40 * y + x/8 - 2 ;//10802;//расчитать байт адреса, содержащего пиксель
bild( addr,Grid_8x4[i--]);// работает
}
}
}//--------------------------OK
//#####################################################################

[andreichk]

Хочу попробовать перенести все картинки в последовательную память с I2C-BUS протоколом, а то они много места в процессоре занимают.

[DL36]

Сегодня закончил оформление внешнего вида. Нарисовал сетку размером 320х240, но она вся не влезла, очевидно из-за каких-то ограничений.Пришлось поделить её на две части и с помошью процедуры перевёртыша загрузить два раза.Благодаря двухслойной функции экрана сетка не затирается.Так же нарисовал несколько маленьких картинок и подгрузил их для красявости.
Ниже привожу текст процедуры и фото

Код

//#####################################################################
void DrawImage11(unsigned int16 y1,unsigned int16 y2 )// перевёртыш

{
unsigned int16 addr, x,y,i;i=3959;
  for (y = y1; y < y2; y++)//
  {
    for (x = 264; x > 0;x=x-8)
      {
        addr = 40 * y + x/8 - 2;//10802;//расчитать байт адреса, содержащего пиксель
        bild( addr,Grid_8x4[i--]);// работает
      }
  }
}//--------------------------OK
//#####################################################################

Не вдаваясь в подробности, просто по оформлению, используй теги под символом #.
Если кто смотреть будет, так читать легче.

[andreichk]

Слепил сегодня процедурку рисования кривых.Теперь вот голову ломаю . как это всё синхронизировать, чтобы картинка устойчивой была.Подскажите плиз


//#####################################################################
void front(unsigned int8 x,unsigned int8 y_anf,unsigned int8 y_end)
{unsigned int8 y;
for (y = y_anf ; y > y_end; y--)
{
pixel(x,y,1);
}
}//--------------------------OK
//#####################################################################
void spad(unsigned int8 x,unsigned int8 y_anf,unsigned int8 y_end)
{unsigned int8 y;
for ( y = y_anf ; y < y_end ; y++ )
{
pixel(x,y,1);
}
}//--------------------------OK
//#####################################################################
void pix(unsigned int8 y_pos)// рисуем кривую, типа синусоиды и пр.
{unsigned int8 x , y , yy ; x = 1; y = 0; yy = 0;
for(;;){
x++;
if (x==255) {x=1;setCursorAddress(0x2581);clear_graphic();}
delay_ms(Zeitablenkung_x(0)); //развёртка Sec/Div
yy=y;
y = input_b()+y_pos;
// y = Amplitude_y(1) + y_pos-150;
if (yy>y) front(x,yy,y); // Рисуем фронт
if (yy<y) spad(x,yy,y); // Рисуем спад
pixel(x,y,1);// Рисуем вершину
}
}//--------------------------OK
//#####################################################################

[FDA]

Вот готовый видеоконтроллер для управления ЖКИ на базе SED1335:
http://www.telesys.ru/electronics/projects.php?do=p148

[andreichk]

вы мне его уже предлагали, только за деньги я и сам купить умею.
Коммерческие предложения меня не интересуют, так что спасибо.... не надо

[Itch]

А почему у вас экран малинового цвета, это пленка наклеена или подсветку поменяли?
Для рисования рекомендую посмотреть библиотечку uc/GUI, драйвер для этого контроллера там уже есть, возможностей у нее много, а самое главное - хоть как-то систематизируется подход. В будущем сможете безболезненно поменять один дисплей на другой с расширением количества цветов например.

[andreichk]

да цвет любой можно сотворить- плёночку цветную под экран сунул и всё.А вообще он ЧБ.
Насчёт uc/GUI не нашёл ничего.У меня поисковик только на какие-то китайские сайты выводит, ничего не понятно.Может ссылочку кините.Спасибо заранее

[Itch]

китайские сайты нормально читаются через http://babelfish.altavista.com/ язык - chinese-simp. там и ссылки есть. можно также с электроникса скачать, но надо быть "своим".

[andreichk]

Выяснил причину по которой HEX-файл неполностью зашивался в процессор. Оказывается программа прошивки IC-Prog1.6А програмирует только до адреса 0х1000.Дальше сплошные FFFF.
Выкинул её нафик.Теперь програмирую другой прогой - P18 Parallelportbrenner V1.8 , взятой с сайта http://www.sprut.de.
По ходу научился выводить тексты в графическом режиме и переменные величины.

//########## выводим на экран числа в графическом режиме ##################
void displayVoltage(int wert) {
char voltage[9];
sprintf(voltage, "%f",(float)(1.715*(5.00 - wert * .01960784))); // преобразуем в текст
voltage[4] = '\0'; //ограничиваем тремя знаками
rect(5, 230, 29, 237, 1,0); //стираем старое значение
text57(5, 230, voltage, 1, 1); //выводим новое значение
}//--------------------------OK
//####################################################

[andreichk]

частота 88 Гц, амплитуда 2.15 вольт

[andreichk]

Попытки записи массива типа

const byte mS_uS[] = {
0,0,0,0,0,
0,7,128,1,224,
0,8,64,2,16,
61,200,1,10,0,
34,40,1,10,0,
34,39,129,9,224,
34,32,65,8,16,
34,32,65,8,16,
34,40,65,26,16,
34,39,129,233,224,
0,0,1,0,0,
0,0,1,0,0,
};

не увенчались успехом

Написал процедуру

void EEPROM_WRITE(long int address)
{unsigned int16 i;

for (i=0;i<60;i++)
{
write_ext_eeprom(address, mS_uS[i]);
}break;
}//--------------------------

во-первых пишет целых 5 минут
во-вторых нифига не читает с помошью процедуры

long int EEPROM_READ(long int addr)
{long int dat;

for (addr=0;addr<990;addr++)
{
dat = read_ext_eeprom(addr);
}return dat;
}//--------------------------
//#####################################################################
void Grid_UpXXX(unsigned int16 y1,unsigned int16 y2,unsigned char setka )//
{unsigned int16 addr, x,y,i;i=0;
for (y = y1; y < y2; y++)
{
for (x = 0; x < 264;x=x+8)
{
addr = 40 * y + x/8 ;//расчитать байт адреса, содержащего пиксель
if( setka==1 ) bild( addr,EEPROM_READ(0));// крупная сетка
else bild( addr,EEPROM_READ(1));// мелкая сетка

}
}
}//--------
Подскажите где я напортачил

[andreichk]

да, не густо тут помошников.....

[andreichk]

ещё одно фото для истории.
двухканальный вариант,построенный на ADS831 и FIFO IDT7201 .Всем этим хозяйством управляет PLCD XILINX XC9572.
Cинус , частота- 20 кГц.Каждый канал имеет свой переключатель развёртки.Почему-то рисует половинкой

[andreichk]

проблема рисования синусоиды половинками решена добавлением резистора 47к на неинвертирующий вход входного ОУ.Осталось добиться устойчивой синхронизации и максимально возможной частоты сигнала.

Первая попытка наблюдения видеосигнала с камеры(сверху)
и одновременный синус 20 кГц(снизу)
Ну хоть кто-нибудь порадуется вместе со мной

[andreichk]

Ура !!! Удалось засинхронизироать картинку
//#####################################################################
void pix_A(unsigned int8 y_pos_A,unsigned int8 offset)// рисуем кривую, типа синусоиды и пр.
{unsigned int8 x, y , yy ;//
unsigned int16 xx;
y = y_pos_A;
Output_bit(PLCD_FIFO_RES ,0);//PIN_C0// сброс FIFO в "0"
Output_bit(PLCD_FIFO_RES ,1);//PIN_C0// и разрешение на считывание
Output_bit(READ_FIFO_B ,1); //PIN_C1 запрет канала B

do{ // слабая попытка синхронизации
Output_bit(READ_FIFO_A ,0);//PIN_C2
adcA=input_b();
Output_bit(READ_FIFO_A ,1);//PIN_C2
}while(input_b()== adcA );//уже лучше,но всё равно плохо
//--------------- предварительная запись в буфер ---------------------
for(xx=0;xx<512;xx++){// канал A
Output_bit(READ_FIFO_A ,0);//PIN_C2. разрешить
adcA=input_b();
adcA = (adcA > offset) ? offset : adcA;//ограничитель до 115
adcA = 255 - adcA;
Buff_[xx] = adcA;//записываемся в буфер 512 раз
Output_bit(READ_FIFO_A ,1);//PIN_C2.запретить
} xx=0;
for(;;) {//синхронизация буфера по фронту или по спаду
if( Buff_[xx++] <= 175) break; //по фронту
// if( Buff_[xx++] >= 175) break; //по спаду
}
sbros(adcA);
wert_A(adcA);
if( xx >= 255 ) xx = xx - 255; //приводим к int8
//--------------- собственно кривая ---------------------------
for(x=1;x<255;x++){
yy = y;
y = Buff_[xx++] + y_pos_A;
if (yy>y) front(x,yy,y); // Рисуем фронт A
if (yy<y) spad(x,yy,y); // Рисуем спад A
adcA=y-y_pos_A;
pixel(x,y,1); // Рисуем вершину A
}
}//--------------------------OK
//####################################################################

[Ilya_A]

Поздравляю, картинка, конечно красивая, но меня волнует следующий вопрос:

Насколько я помню, при рисовании динамически изменяющихся картинок на SED1335 должны возникать флики на экране. Как у вас обстоят дела, с такими глюками?

Сообщение отредактировал Илья - Feb 26 2008, 07:54

[andreichk]

Поздравляю, картинка, конечно красивая, но меня волнует следующий вопрос:

Насколько я помню, при рисовании динамически изменяющихся картинок на SED1335 должны возникать флики на экране. Как у вас обстоят дела, с такими глюками?

Если флики - это когда в разных кадрах есть места по-разному освещенные, то на тёмном фоне их практически не видно, линии-то тонкие и все эти мелькания происходят как бы за экраном, так что с фликами пока всё ОК.

[andreichk]

У меня сегодня день рождения. Спасибо всем за поздравления

[andreichk]

сегодня попробовал подать на вход меандр от кварцевого генератора.Нармально можно рассмотреть частоту в 1 МГц при тактовой частоте ПИКа и FIFO- 40МГц. Но вот незадача- не совпадает меандр с масштабом клеток- получается примерно полторы клетки на 1МГц. Перерисовывать клетки как-то не очень хочется, значит надо подгонять частоту тактирования.Можно ли это сделать программно в ПЛИСе или нет-кто мне подскажет?

[andreichk]

Прошу помощи по теме
Дело такое, надо мне от шифратора кнопок , кот. я зашил в ПЛИСе передать в ПИК значение нажатой кнопки.То есть , если нажата кнопка 1, то вылетает один импульс, если 2, то два импульса и т.д. до 15ти.Длительность импульса прим. 0.5мс без паузы , то есть весь пакет примерно от 0.5 + пауза 0.5мс, до 30ти.Импульсы подаются на вход РА4.также смоделирован признак нажатия кнопки, то есть высокий уровень на весь размер пакета, он подается на порт РА5. Я нарисовал вот такую процедурку, но она почему-то не работает как надо.Может такой способ опознавания вообще не катит?

//###### ШИФРАТОР КНОПОК УПРАВЛЕНИЯ. ПОРТ А НА ВХОД ########################
#ifndef Code_Out
#define Code_Out PIN_A4// Пакеты импульсов от 1 до 15
#endif
//--------------------------
#ifndef TASTE_EN
#define TASTE_EN PIN_A5//Признак нажатия кнопки- лог.1
#endif
//###############################
void Tasten(void)// ОПРОС КНОПОК
{unsigned int8 puls;
if (input(TASTE_EN))//признак нажатия кнопки лог."1"
{
while(!input(TASTE_EN));//ждём спад обрезанного импульса
rect(265, 80, 269, 86, 1,0);
text57(265,80,u ,1,1);
puls=0;
while(!input(Code_Out));//ждём спад
while(input(TASTE_EN))//начинаем отсчёт по фронту
{
while(input(Code_Out));//ждём фронт

while(!input(Code_Out));//ждём спад
wert_A(puls++);
}
puls=0;
delay_ms(200);
}
else{
rect(265, 80, 269, 86, 1,0);
text57(265,80,m ,1,1);
}
}
//###########################################################################
void wert_A(unsigned int8 wert)
{
char voltage[9];
sprintf(voltage, "%u",(unsigned int8)( wert)); // преобразуем в текст
//voltage[4] = '\0'; //ограничиваем тремя знаками
rect(150, 230, 175, 237, 1,0); //стираем старое значение
text57(150, 230, voltage, 1, 1); //выводим новое значение
}//--------------------------OK
//######################################################################

[Ilya_A]

Насколько я понимаю нужно дождаться перехода из низкого в высокий уровень на RA5, а затем посчитать количество импульсов на RA4.

Следовательно нужно сделать так:

Код

unsigned int8 GetButton(void){
   unsigned int8 puls;
   while(input(TASTE_EN)); // если зашли уже в момент передачи кода кнопки то дождаться окончания передачи
   puls=0;
   while(!input(TASTE_EN));//дождаться начала следующей передачи кода кнопки
   while(input(TASTE_EN)){//пока активно RA5
        while(!input(Code_Out)){//ждём фронт
            if (!input(TASTE_EN)) return puls;//проверяем: если передача законилась то выйти, чтобы не зависнуть
        }
        while(input(Code_Out));//ждём спад
        puls++;
   }
   return puls;
}

А вообще зачем такие сложности, не проще ли сделать так: Передача кода кнопки только по одной ноге, а кодирование длительностью ипульса, например:
0.5 мс - кнопка №1
1 мс - кнопка №2
1.5 мс - кнопка №3
и т.д.

тогда для дешифровки делаем следующим образом:
настраиваем прерывание по фронту.
в обработчике прерывания стартуем таймер, и ждем в цикле спада. Стопорим таймер и смотрим: сколько натикало - такой и код

[andreichk]

Спасибо, я попробую как вы советуете и отпишусь

[andreichk]

попробовал предложенный код.Он работает,только не совсем так.А именно- теперь осциллограмма появляется только в момент нажатия любой кнопки, а иначе картинка замирает.Значение кнопки отображается не совсем корректно- или 0 или на одно значение меньше или правильное значение.
Наверное нужно уточнять частоту импульсов и настраивать прерывание по нажатию- изменению состояния RA5 ? Только я не знаю как(ещё не изучал этот вопрос).Если укажете правильный путь- буду благодарен

[andreichk]

код работает с небольшой доделкой и понижением частоты импульсов опроса кнопок до 150 кГц.
думаю, что этим можно и ограничиться


unsigned int8 GetButton(void){
unsigned int8 puls;
if (!input(TASTE_EN)) return ;//если кнопка не нажималась- уходим
while(input(TASTE_EN)); // если зашли уже в момент передачи кода кнопки то дождаться окончания передачи
puls=0;
while(!input(TASTE_EN));//дождаться начала следующей передачи кода кнопки
while(input(TASTE_EN))//пока активно RA5
{
while(!input(Code_Out))//ждём фронт
{
if (!input(TASTE_EN)) return puls;//проверяем: если передача законилась то выйти, чтобы не зависнуть
}
while(input(Code_Out));//ждём спад
puls++;
}
return puls;
}
...................................................................
а вызов делаем так и уходим от нуля
x=GetButton();
if(x>0) wert_A(x);

[andreichk]

вот такое у меня ещё пожелание(чувствую, что без посторонней помощи не обойдусь) касательно кнопок управления.
каждый раз ,при нажатии кнопки со значением переменной puls==12, нужно, чтобы значение другой переменной (хх напр.)однократно увеличивалось на единицу и оставалось таким, а при нажатии кнопки со значением puls==13 уменьшалось на единицу и оставалось таким. Я сам пробовал,фигня у меня получается-если держать кнопку и не отпускать, то хх всё время увеличивается или соотв. уменьшается, а это недопустимо.Если с этим поможете, то тогда влпрос с управлением будет закрыт.Спасибо заранее

[Ilya_A]

Извиняюсь за задержку с ответом - праздники, даже не заходил на форум

Решить вашу проблему можно, заведя переменную для хранения значения предыдущей нажатой кнопки, следующим образом:

Код

unsigned char XX; // переменная которая будет изменяться
unsigned char key=0,keyold=0;

key=GetButton();
if(key==12){
   if(keyold!=12) XX++;
}else if(key==13){
   if(keyold!=13) XX--;
}
keyold=key;

[Transon]

Это самая лучшая разработка одного человека какую я видел за последнее время.
Я сам пытался разработать цифровой осциллограф, но так до конца не доделал, АЦП не заработал (AD9283 100Msps), сделал его только как логический анализатор через LPT порт с частотой дискретизации 48MHz и 8 каналов, потом забросил, щас снова интерес появился, я хочу повторить ваш осциллограф для себя.
Аналогов такого осциллографа со схемами я не нашёл.

Сообщение отредактировал Transon - Mar 12 2008, 13:20

[andreichk]

Спасибо всем ответившим и помогающим.Не надо извиняться, все мы ведь понимаем , что кроме и-нета у каждого есть ещё и личная жизнь, работа и многое другое, так что всё нормально, спасибо, что отозвались.

[andreichk]

Код

unsigned char XX; // переменная которая будет изменяться
unsigned char key=0,keyold=0;

key=GetButton();
if(key==12){
   if(keyold!=12) XX++;
}else if(key==13){
   if(keyold!=13) XX--;
}
keyold=key;

тут не совсем так как надо получается, а именно- значение переменной ХХ меняется только один раз, при повторном нажатии на ту же кнопку оно уже не меняется. А нужно , чтобы оно увеличивалось(или уменьшалось) на единицу при каждом нажатии.

[Ilya_A]

Код

unsigned char XX; // переменная которая будет изменяться
unsigned char key=0,keyold=0;

key=GetButton();
if(key==12){
   if(keyold!=12) XX++;
}else if(key==13){
   if(keyold!=13) XX--;
}
keyold=key;

тут не совсем так как надо получается, а именно- значение переменной ХХ меняется только один раз, при повторном нажатии на ту же кнопку оно уже не меняется. А нужно , чтобы оно увеличивалось(или уменьшалось) на единицу при каждом нажатии.

Почему же? Все будет ОК если функция GetButton() будет возвращать 0 если не получила никакого кода клавиши. Тогда переменная keyold занулится (в момент отжатия) и при следующем нажатии на ту же кнопку произойдет необходимая операция

[andreichk]

дело в том , что момент отжатия невозможно установить точно, так как он происходит в произвольный момент времени и там ведь ещё целая куча задач выполняется.Плохо то, что я не могу назначить прерывание по изменению состояния порта РА5,в компиляторе такого почему-то не прописано(может его вобще не существует для ПИКа 18Ф4550), хотя в общей доке для компилятора описание имеется.Плёхо, очень плёхо......

[Ilya_A]

дело в том , что момент отжатия невозможно установить точно, так как он происходит в произвольный момент времени и там ведь ещё целая куча задач выполняется.Плохо то, что я не могу назначить прерывание по изменению состояния порта РА5,в компиляторе такого почему-то не прописано(может его вобще не существует для ПИКа 18Ф4550), хотя в общей доке для компилятора описание имеется.Плёхо, очень плёхо......

Есть 2 выхода:

Во первых можно перекинуть с RA5 на одну из ног: RB0, RB1, RB2 - ноги на которых можно настроить прерывания по фронту или по спаду.

Либо можно завести внутренний таймер, с периодом переполнения, например 100 мс и настроить прерывание, по переполнению. А уже в прерывании выполнять GetButton(). - появиться гарантированное время между опросами клавы.

[andreichk]

перекидывать ножки на порт РВ как-то не очень хочется, так как с него читаются данные(вдруг какие-нибудь баги полезут и картинка начнёт портиться.А вот второй вариант наверное подойдёт, только вот с прерываниями у меня сложности.....

вот перечень прерываний.какие мои дальнейшие действия?

////////////////////////////////////////////////////////////////// INT
// Interrupt Functions: ENABLE_INTERRUPTS(), DISABLE_INTERRUPTS(),
// CLEAR_INTERRUPT(), INTERRUPT_ACTIVE(),
// EXT_INT_EDGE()
//
// Constants used in EXT_INT_EDGE() are:
#define L_TO_H 0x40
#define H_TO_L 0
// Constants used in ENABLE/DISABLE_INTERRUPTS() are:
#define GLOBAL 0xF2C0
#define INT_RTCC 0xF220
#define INT_TIMER0 0xF220
#define INT_TIMER1 0x9D01
#define INT_TIMER2 0x9D02
#define INT_TIMER3 0xA002
#define INT_EXT 0xF210
#define INT_EXT1 0xF008
#define INT_EXT2 0xF010
#define INT_RB 0xFFF208
#define INT_AD 0x9D40
#define INT_RDA 0x9D20
#define INT_TBE 0x9D10
#define INT_SSP 0x9D08
#define INT_CCP1 0x9D04
#define INT_CCP2 0xA001
#define INT_BUSCOL 0xA008
#define INT_LOWVOLT 0xA004
#define INT_COMP 0xA040
#define INT_EEPROM 0xA010
#define INT_OSCF 0xA080
#define INT_SPP 0x9D80
#define INT_USB 0xA020
#list

Сообщение отредактировал andreichk - Mar 15 2008, 12:57

[Ilya_A]

Так... насколько я понял компилятор у вас CCS - я с ним не знаком (дружу в основном с C18, PICC18)
Ну ничего, бум думать, где-то он у меня валялся...
Хреново что реализация прерываний сильно зависит от компилятора, но постараюсь помочь хотябы идеологически)

Тактовая частота, насколько я понял - 40 МГц (т.е. 10 MIPS) ?

Для начала ссобщите какие остались свободные таймера и использовали ли вы CCP модули?
Да, и еще, используется ли у вас в программе на данный момент уже хоть одно прерывание?

И на последок - какая сейчас используется длина импульса кодировки. Насколько я понял вы идеологию кодировки не поменяли?

Сообщение отредактировал Илья - Mar 15 2008, 17:48

[andreichk]

частота 40 МГц.
ни один из трёх таймеров не задействован, прерывания тоже.
ССР также отключены.
длительность импульса 4мкс, между импульсами тоже 4 мкс
идеология не поменялась, хотя меня долго кто-то уговаривал,но я не поддался.....

Сообщение отредактировал andreichk - Mar 15 2008, 18:58

[Ilya_A]

Хорошо. Теперь приступим:
Возьмем за базу TMR0, у него большой прескалер (на 10 MIPS можно получить до 1.6 с.)

Код

.....
//Гдето в инициализации программы
в T0CON указываем:
   as 16 bit timer/counter
   Internal instruction cycle clock
   TMR0 prescaler is assigned
   Prescaler выбираем из следующих соображений:
    1:8 - 0.0524288 с
    1:16 - 0.1048576 с
    можно и другие варианты, достаточное значение опредилится опытным путем

TMR0H=0;    // Зануляем таймер
TMR0L=0;

TMR0IF=0;    //Очищаем флаг
TMR0IE=1;    //Включаем прерывание по переполнению
IPEN=0;        //Отключаем приоритет прерываний
PEIE=1;        //Включаем прерывания перефирии
GIE=1;        //Включаем глобальный флаг разрешения прерываний
TMR0ON=1;        //Затем стартуем таймер:
.....

Почитал я немного про CSS, походу там обработка прерываний делается так:
(для экономии времени на вызов функции лучше тело GetButton перенести сюда, также нужно сделать глобальными переменные key и keyold)

Код

...
где- то  в программе:
int8 key=0,keyold=0; // незнаю, как в CCS но в PICC18 я бы добавил ключевое слово volatile
...
//Непосредственно обработчик прерываний
#int_timer0
void timer0_isr(void){
   TMR0IF=0;// Очистим флаг прерывания
   key=0;
   if (!input(TASTE_EN)){//теперь, раз уж мы сюда зашли, придется дождаться начала передачи кода клавиши
      while(!input(TASTE_EN));
   }else{// а если зашли уже в момент передачи кода кнопки то придеться дождаться окончания передачи...
      while(input(TASTE_EN));
      while(!input(TASTE_EN));//а также ждем начало следующей передачи
   }
   while(input(TASTE_EN))//пока активно RA5
   {
       while(!input(Code_Out))//ждём фронт
      {
         if (!input(TASTE_EN)) break;//проверяем: если передача законилась то выходим
      }
      if (!input(TASTE_EN)) break;//проверяем: если передача законилась то выходим
      while(input(Code_Out));//ждём спад
      key++;
   }
   //по хорошему эту обработку тоже нужно занести сюда:  
   if(key==12){
      if(keyold!=12) XX++;    //XX тоже должна быть глобальной
   }else if(key==13){
      if(keyold!=13) XX--;
   }
   keyold=key;
}
...

А уже в теле программы можно спокойно, в любой момент, проверять переменную key....

В особо критичных моментах можно будет на время выключать прерывания, например:

Код

GIE=0;    
   бла, бла,бла....
GIE=1;

Да, и еще - не совсем понял как кодируется "не нажата ни одна клавиша" - по хорошему, нужно чтобы был импульс на TASTE_EN, без импульса на Code_Out

Сообщение отредактировал Илья - Mar 16 2008, 08:16

[andreichk]

компилятор не хочет это признавать
TMR0IF=0;// Очистим флаг прерывания

[Ilya_A]

компилятор не хочет это признавать
TMR0IF=0;// Очистим флаг прерывания

Значит этот бит либо не прописан, либо прописан каким либо другим образом.
Вообще-то этот бит принадлежит регистру INTCON.

Можно попробывать варианты: INTCON.TMR0IF=0 или INTCONbits.TMR0IF=0.

Ну вообще-то вам лучше знать как обращаться к битам регистров в вашем компиляторе.

На крайняк такой вариант точно проканает: INTCON&=0b11111011;

Сообщение отредактировал Илья - Mar 16 2008, 13:00

[andreichk]

пробую так его прописать
set_timer0(0); // TMR0IF=0;// Очистим флаг прерывания

тоже не катит INTCON&=0b11111011;
вообще это идиотизм, что эти компиляторописатели подменяют стандартные описания какими-то собственновыдуманными конструкциями, поди разбери, что чем заменяется.

Вот что я решил, у меня тут с ПЛИСкой проблемы, вернее с обьеденением некоторых функций, которые я в ней заложил.Поэтому я решил инициализировать ещё 4 пина и напрямую ввести их в ПИК на порты РА0,РА1,РА2,РА3(они у меня ничем не заняты).И тогда я смогу простым нажатием на соотв.кнопку увеличивать-уменьшать значение переменной ХХ.Прошу пока все дальнейие изыскания на эту тему приостановить, сделать паузу и попить пивка напр.

[Ilya_A]

Ну ладно, удачи, все способы полезны - главное, чтобы цель была достигнута.

П.С. Единственный плюс, помоему, этого CCS - в том, что в нем написана куча библиотек для периферии. А так, IMHO не серьезный компилятор. 8)

[andreichk]

вот такой вид приняла означенная процедура опроса кнопок.теперь все кнопки вызывают правильные команды и выдаютправильные значения на ЖКИ

//######################################################################
//Непосредственно обработчик прерываний
#int_timer0
void timer0_isr(void){
set_timer0(0); // TMR0IF=0;// Очистим флаг прерывания
//...... Этими кнопками изменяем показания SEC/DIV Канал А ....
if (input(OUT_A_UP))
{
while(input(OUT_A_UP));XX++;
}
else if (input(OUT_A_DOWN))
{
while(input(OUT_A_DOWN));XX--;
}
if(XX>8) XX=1;
if(XX<1) XX=8; //ограничиваем ХХ от 1 до 8
//.................Другие кнопки........................
key=0;
if (!input(TASTE_EN)) return ;//если кнопка не нажата - уходим
while(input(TASTE_EN));
while(!input(TASTE_EN));//а также ждем начало следующей передачи
while(input(TASTE_EN))//пока активно RA5
{
while(!input(Code_Out))//ждём фронт
{
if (!input(TASTE_EN)) break;//проверяем: если передача закончилась то выходим
}
if (!input(TASTE_EN)) break;//проверяем: если передача закончилась то выходим
while(input(Code_Out));//ждём спад
key++;
}
} //--------------------------OK
//######################################################################

Спасибо за оказанную помощь .
Илье особый и уважуха

Сообщение отредактировал andreichk - Mar 16 2008, 20:16

[andreichk]

Чего-то ни одной умной мысли не лезет в голову, наверное пора отпуск брать.
Решил пока привести пример написания процедуры рисования кривой на экране.Покритикуйте плиз, может что-нить улучшить можно.

//############### Рисуем фронт #################################
void front(unsigned int8 x,unsigned int8 y_anf,unsigned int8 y_end)
{unsigned int8 y;
for (y = y_anf ; y > y_end; y--)
{
pixel(x,y,1);
}
} //--------------------------OK
//################ Рисуем спад #####################################
void spad(unsigned int8 x,unsigned int8 y_anf,unsigned int8 y_end)
{unsigned int8 y;
for ( y = y_anf ; y < y_end ; y++ )
{
pixel(x,y,1);
}
} //--------------------------OK
//#####################################################################
void pix_A(unsigned int8 y_pos_A) // рисуем кривую, типа синусоиды и пр.
{unsigned int8 x, y , yy ;//
unsigned int16 xx;
Output_bit(PLCD_FIFO_RES ,0); //PIN_C0// сброс FIFO в "0"
Output_bit(PLCD_FIFO_RES ,1); //PIN_C0// и разрешение на считывание
Output_bit(READ_FIFO_B ,1); //PIN_C1 запрет канала B
// слабая попытка синхронизации
do{ Output_bit(READ_FIFO_A ,0);//PIN_C2
adcA=input_b();
Output_bit(READ_FIFO_A ,1);//PIN_C2
}while( adcA == 0);
do{ // ещё одна попытка синхронизации
Output_bit(READ_FIFO_A ,0);//PIN_C2
adcA=input_b();
Output_bit(READ_FIFO_A ,1); //PIN_C2
}while(input_b()== adcA ); //уже лучше,но всё равно плохо
//--------------- предварительная запись в буфер ---------------------
for(xx=0;xx<1024;xx++){ // канал A
Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
adcA=input_b(); //чтение порта В
adcA = (adcA > 200) ? 200 : adcA; //ограничитель до выбранной величины
adcA = 255 - adcA; // разворот на 180° по вертикали
Buff_[xx] = adcA; //записываемся в буфер
Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
} xx=0;
switch(syncA){ //синхронизация буфера по фронту или по спаду
case 1 :while( Buff_[xx++] > sync_volume_A);break; //по фронту
case 2 :while( Buff_[xx++] <= sync_volume_A+115);break; //по спаду
}
//значительно лучше в совокупности с двумя предыдущими
if( xx >= 255 ) xx = xx - 255; //приводим к int8
//--------------- собственно кривая ---------------------------
for(x=1;x<255;x++){
yy = y;
y = Buff_[xx++] + y_pos_A;
if (yy>y) front(x,yy,y); // Рисуем фронт A
if (yy<y) spad(x,yy,y); // Рисуем спад A
adcA=y-y_pos_A;
pixel(x,y,1); // Рисуем вершину A
}
} //--------------------------OK
//####################################################################

Сообщение отредактировал andreichk - Mar 19 2008, 20:57

[Ilya_A]

Чего-то ни одной умной мысли не лезет в голову, наверное пора отпуск брать.
Решил пока привести пример написания процедуры рисования кривой на экране.Покритикуйте плиз, может что-нить улучшить можно.

Что касаемо улучшения - то в первую очередь нужно оптимизировать самые "тормозные места" - и в первую очередь это циклы.

Я бы процедуру отрисовки переписал иначе:

Код

void pix_A(unsigned int8 y_pos_A) // рисуем кривую, типа синусоиды и пр.
{  unsigned int8 x, y , yy;
   Output_bit(PLCD_FIFO_RES ,0); //PIN_C0// сброс FIFO в "0"
   Output_bit(PLCD_FIFO_RES ,1); //PIN_C0// и разрешение на считывание
   Output_bit(READ_FIFO_B ,1); //PIN_C1 запрет канала B
   // слабая попытка синхронизации
   do{ Output_bit(READ_FIFO_A ,0);//PIN_C2
      adcA=input_b();
      Output_bit(READ_FIFO_A ,1);//PIN_C2
   }while( adcA == 0);
   do{ // ещё одна попытка синхронизации
      Output_bit(READ_FIFO_A ,0);//PIN_C2
      adcA=input_b();
      Output_bit(READ_FIFO_A ,1); //PIN_C2
   }while(input_b()== adcA ); //уже лучше,но всё равно плохо
   //-------------------- синхронизация ---------------------------
   while(1){
      Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
      adcA=input_b(); //чтение порта В
      Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
      adcA = (adcA > 200) ? 200 : adcA; //ограничитель до выбранной величины
      adcA = 255 - adcA; // разворот на 180° по вертикали
      if (syncA==1){
         if(adcA>sync_volume_A) continue;
         else break;
      }else if (syncA==2){
         if(adcA<=sync_volume_A+115) continue;
         else break;
      }
    }
   //--------------- собственно кривая ---------------------------
   for(x=1;x<255;x++){
      yy = y;
      Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
      adcA=input_b(); //чтение порта В
      Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
      adcA = (adcA > 200) ? 200 : adcA; //ограничитель до выбранной величины
      y = (255 - adcA) + y_pos_A; // разворот на 180° по вертикали и сдвиг
      if (yy>y) front(x,yy,y); // Рисуем фронт A
      if (yy<y) spad(x,yy,y); // Рисуем спад A
      pixel(x,y,1); // Рисуем вершину A
   }
}

В итоге мы избавились от лишнего цикла. А также освободили 1Кб RAM

Может, конечно, я что-то упустил - в следствии не полного понимания общего алгоритма работы, но помоему должно работать

В частности мне совсем непонятна строка:

Код

if( xx >= 255 ) xx = xx - 255; //приводим к int8

Перед этой строчкой в xx лежит индекс в буфере указывающий на место синхронизации (пересечение sync_volume_A в нужном направлении). Если я правильно понял нужно просто отрисоваь буфер с этого места на экране. Это и произойдет, если xx<255. А в противном случае вы отнимете 255 и точка синхронизации окажется в конце отрисовки... Не получиться ли у вас, что картинка начнет скакать?

Сообщение отредактировал Илья - Mar 20 2008, 04:02

[andreichk]

if( xx >= 255 ) xx = xx - 255; //приводим к int8

тут , как я себе представляю, смысл в том, чтобы хх укладывалось в интервал от 0 до 255, так как сам буфер в 4 раза больше. хх- это координата точки и поскольку момент захвата синхронизации может наступить за пределами этого диапазона, то эта конструкция всё равно установит этот момент в начало.
потому что в цикле начала отрисовки for(x=1;x<255;x++){
лежит другая переменная.

ЗЫ.попробовал ваш код- он работает, но если нет сигнала, то на экране не прорисовывается прямая, как в обычном осциллографе.Как-то не привычно, создаётся впечатление, что что-то не работает.

Сообщение отредактировал andreichk - Mar 20 2008, 19:05

[andreichk]

кстати вопрос имею- чем два раза IF лучше одного SWITCH?
это я про синхронизацию

[Ilya_A]

if( xx >= 255 ) xx = xx - 255; //приводим к int8
тут , как я себе представляю, смысл в том, чтобы хх укладывалось в интервал от 0 до 255, так как сам буфер в 4 раза больше. хх- это координата точки и поскольку момент захвата синхронизации может наступить за пределами этого диапазона, то эта конструкция всё равно установит этот момент в начало.
потому что в цикле начала отрисовки for(x=1;x<255;x++){
лежит другая переменная.

Хоть убейте не догоняю хода вашей мысли.... Зачем xx укладываться от 0 до 255? она же int16, да и буффер размером 1024 байта... Если мы нашли точку синхронизации - надо от нее и рисовать, зачем же ее изменять???

Ну ладно допустим вы хотите чтобы xx лежал от 0 до 255, то все равно ваша конструкция ошибочна: ведь если xx будет больше 512 или 768 то отняв 256 вы не получите требуемого диапазона!

кстати вопрос имею- чем два раза IF лучше одного SWITCH?
это я про синхронизацию

В данном случае разницы нет, но я специально так написал, чтобы затем предложить вам переобозначить значение переменной типа синхронизации (syncA), пусть
SyncA=1 синхронизация по фронту
SyncA=0 синхронизация по спаду

тогда проверку можно будет переписать так:

Код

      if (syncA){
         if(adcA>sync_volume_A) continue;
         else break;
      }else{
         if(adcA<=sync_volume_A+115) continue;
         else break;
      }

А это уже экономия на одной лишней проверке. если учесть что эта операция выполняется на каждой итерации цилкла - получится приличное чилсло тактов процессора.

ЗЫ.попробовал ваш код- он работает, но если нет сигнала, то на экране не прорисовывается прямая, как в обычном осциллографе.Как-то не привычно, создаётся впечатление, что что-то не работает.

А в вашем коде она прорисовывалась?

Предлагаю сделать так: Завести переменную, котороая будет зануляться перед каждой попыткой синхронизации, и затем инкрементироваться в цикле. А при превышении n-го количества попыток, тупо отрисовывала текущий сигнал и выходила из цикла.

Следовательно код будет такой:

Код

//!!!SyncA=1  синхронизация по фронту!!!
//!!!SyncA=0  синхронизация по спаду!!!

void curve_A(unsigned int8 y_pos_A); //добавить функцию в прототипы

#define TIMEOUT             10000

void pix_A(unsigned int8 y_pos_A) // рисуем кривую, типа синусоиды и пр.
{  unsigned int16 n=0;
   Output_bit(PLCD_FIFO_RES ,0); //PIN_C0// сброс FIFO в "0"
   Output_bit(PLCD_FIFO_RES ,1); //PIN_C0// и разрешение на считывание
   Output_bit(READ_FIFO_B ,1); //PIN_C1 запрет канала B
   // слабая попытка синхронизации
   do{ Output_bit(READ_FIFO_A ,0);//PIN_C2
      adcA=input_b();
      Output_bit(READ_FIFO_A ,1);//PIN_C2
      if (n++>TIMEOUT) {curve_A(y_pos_A); return;}
   }while( adcA == 0);
   n=0;
   do{ // ещё одна попытка синхронизации
      Output_bit(READ_FIFO_A ,0);//PIN_C2
      adcA=input_b();
      Output_bit(READ_FIFO_A ,1); //PIN_C2
      if (n++>TIMEOUT) {curve_A(y_pos_A); return;}
   }while(input_b()== adcA ); //уже лучше,но всё равно плохо
   //-------------------- синхронизация ---------------------------
   n=0;
   while(1){
      Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
      adcA=input_b(); //чтение порта В
      Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
      adcA = (adcA > 200) ? 200 : adcA; //ограничитель до выбранной величины
      adcA = 255 - adcA; // разворот на 180° по вертикали
      if (n++>TIMEOUT) {curve_A(y_pos_A); return;}
      if (syncA){
         if(adcA>sync_volume_A) continue;
         else break;
      }else{
         if(adcA<=sync_volume_A+115) continue;
         else break;
      }
    }
    curve_A(y_pos_A);
}

//--------------- собственно кривая ---------------------------
void curve_A(unsigned int8 y_pos_A){
   unsigned int8 x, y , yy;
   for(x=1;x<255;x++){
      yy = y;
      Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
      adcA=input_b(); //чтение порта В
      Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
      adcA = (adcA > 200) ? 200 : adcA; //ограничитель до выбранной величины
      y = (255 - adcA) + y_pos_A; // разворот на 180° по вертикали и сдвиг
      if (yy>y) front(x,yy,y); // Рисуем фронт A
      if (yy<y) spad(x,yy,y); // Рисуем спад A
      pixel(x,y,1); // Рисуем вершину A
   }
}

значение TIMEOUT нужно определить опытным путем (я написал для примера) а можно и завести и глобальную переменную под это дело - дабы динамически изменять во время работы

Сообщение отредактировал Илья - Mar 21 2008, 03:09

[andreichk]

вначале буфер был размером в 512 кб и всё как раз там укладывалось,а сделано это было для того, чтобы момент синхронизации попадал в диапазон от 0 до 255, если он наступал за его пределом(экран-то размером 255 пикс. по горизонтали).Это потом я увеличил буфер(сам не знаю зачем)

ОК, последний предложенный код работает, синхронизация в норме, при отстутствии сигнала рисуется прямая линия с мелкими шумовыми вкраплениями.Думаю, что этот момент завершён. Спасибо за помощь

[Ilya_A]

ОК, последний предложенный код работает, синхронизация в норме, при отстутствии сигнала рисуется прямая линия с мелкими шумовыми вкраплениями.Думаю, что этот момент завершён. Спасибо за помощь

Вери Гуд

Удаленная отладка - конечно прикольная вещь, но жутко интересно посмотреть как ваше устройство работает в живую... жаль что не увижу

Сам всегда мечтал сделать свой осциллограф - поэтому и заинтересовался вашим постом, но никто не предлагает такой задачи... а заниматься этим от нечего делать - нету времени

[andreichk]

не вопрос- научусь в Гугль видео выкладывать- обязательно сделаю, так что увидите. Тут есть ещё чего поотлаживать, напр. запихнуть сетку в ЕЕПРОМ и при включении рисовать её на экран оттуда.Можно будет ещё 10кб меса сэкономить.Есть желание дальше копаться?
В перспективе можно будет ещё спектроанализатор поизобретать, да мало ли чего......

[Ilya_A]

Тут есть ещё чего поотлаживать, напр. запихнуть сетку в ЕЕПРОМ и при включении рисовать её на экран оттуда.

Непонял, а что сложного в векторном рисовании сетки? (с помощю линий)
Зачем ее по пикселам из памяти считывать?

[andreichk]

я про такое даже не слышал, поэтому просто нарисовал сетку в бмп-формате, разложил на байты и загрузил в проц.Места она заняла ок.10кб, вот я и подумал, что может её в еепром затолкать?

[Ilya_A]

я про такое даже не слышал, поэтому просто нарисовал сетку в бмп-формате, разложил на байты и загрузил в проц.Места она заняла ок.10кб, вот я и подумал, что может её в еепром затолкать?

Еще раз посмотрел на вашу сетку - в принципе немного попариться и можно нарисовать векторно.
Насколько я понял линии вы рисовать умеете (нет ничего сложного) написать еще алгоритм рисования пунктирных линий с задаваемым шагом пунктира. И все, сетку спокойно можно будет собрать из этих процедур

А по поводу иконок - речи нет надо битмапы юзать

[andreichk]

линии, прямоугольники и кружки рисовать умеем, а штрихпунктиры нет.Даже не представляю себе такие формулы

[andreichk]

прямоугольник и видеосигнал

[Ilya_A]

линии, прямоугольники и кружки рисовать умеем, а штрихпунктиры нет.Даже не представляю себе такие формулы

Я сам лично никогда не задавался вопросом рисования пунктирных линий, щас подумал - алгоритм мне представился довольно простым, если есть желание - выкладывайте вашу процедуру для обычных линий, видоизменим под пунктир...

прямоугольник и видеосигнал

Да, картинка красивая... единственно не понятен смысл значка в правом нижнем углу... на нем что вообще нарисовано? (похоже на ворону на камне )

[andreichk]

Я сам лично никогда не задавался вопросом рисования пунктирных линий, щас подумал - алгоритм мне представился довольно простым, если есть желание - выкладывайте вашу процедуру для обычных линий, видоизменим под пунктир...
Да, картинка красивая... единственно не понятен смысл значка в правом нижнем углу... на нем что вообще нарисовано? (похоже на ворону на камне )

ворона на камне да ето же бонсай, для души

void line(int16 x1, int16 y1, int16 x2, int16 y2, int1 color)

{
int16 dy, dx;
signed int8 addx=1, addy=1;
signed int16 P, diff;


int16 i=0;
dx = abs((signed int16)(x2 - x1));
dy = abs((signed int16)(y2 - y1));


if(x1 > x2)
addx = -1;
if(y1 > y2)
addy = -1;

if(dx >= dy)
{
dy *= 2;
P = dy - dx;
diff = P - dx;

for(; i<=dx; ++i)
{
pixel(x1, y1, color);

if(P < 0)
{
P += dy;
x1 += addx;
}
else
{
P += diff;
x1 += addx;
y1 += addy;
}
}
}
else
{
dx *= 2;
P = dx - dy;
diff = P - dy;

for(; i<=dy; ++i)
{
pixel(x1, y1, color);

if(P < 0)
{
P += dx;
y1 += addy;
}
else
{
P += diff;
x1 += addx;
y1 += addy;
}
}
}
}//--------------------------OK
//####################################################

Сообщение отредактировал andreichk - Mar 22 2008, 14:36

[Шпиндель]

Посмотрел с интересом, спасибо! Через время.. чувствую, придётся мне делать нечто подобное, вот я тогда за вами побегаю..
Сейчас появляются всевозможные матрицы по ценам до 50 долларов, так что многие задачи для хобби и для работы становятся оправданными.

[alexsl]

to andreichk.
Добрый день. Уменя вопрос по схемотехнике. Чем вы подсветку питали? У вас ведь CCFL подсветка?

[Ilya_A]

Вот, собственно, у меня получилась такая процедурка:

Код

/*
входные параметры:
color - с чего начинать (1- с пунктира, 0 -с промежутка)
Len1 - длина пунктира (в пикселах)
Len0 - длина промежутка (в пикселах)
*/
void pline(int16 x1, int16 y1, int16 x2, int16 y2, int1 color, int8 Len1, in8 Len0){
int16 dy, dx;
signed int8 addx=1, addy=1;
signed int16 P, diff;
int16 i=0;
int8 count=0;

dx = abs((signed int16)(x2 - x1));
dy = abs((signed int16)(y2 - y1));
if(x1 > x2) addx = -1;
if(y1 > y2) addy = -1;
if(dx >= dy){
   dy *= 2;
   P = dy - dx;
   diff = P - dx;
   for(; i<=dx; ++i){
      pixel(x1, y1, color);
      if(color){
          if (++count>=Len1) {count=0;color=0;}
      }else{
          if (++count>=Len0) {count=0;color=1;}
      }
      if(P < 0){
         P += dy;
         x1 += addx;
      }else{
         P += diff;
         x1 += addx;
         y1 += addy;
      }
   }
}else{
   dx *= 2;
   P = dx - dy;
   diff = P - dy;
   for(; i<=dy; ++i){
      pixel(x1, y1, color);
      if(color){
          if (++count>=Len1) {count=0;color=0;}
      }else{
          if (++count>=Len0) {count=0;color=1;}
      }
      if(P < 0){
         P += dx;
         y1 += addy;
      }else{
         P += diff;
         x1 += addx;
         y1 += addy;
      }
   }
}
}

В принципе переменную count можно тоже вынести в список входных параметров - и задавать ему начальное значение, тогда можно будет начинать , например, с середины пунктира

[andreichk]

Посмотрел с интересом, спасибо! Через время.. чувствую, придётся мне делать нечто подобное, вот я тогда за вами побегаю..
Сейчас появляются всевозможные матрицы по ценам до 50 долларов, так что многие задачи для хобби и для работы становятся оправданными.

ну побегайте

to andreichk.
Добрый день. Уменя вопрос по схемотехнике. Чем вы подсветку питали? У вас ведь CCFL подсветка?

http://www.bue.de/tabdata/datasheet/ds_en_inv-l10a.pdf


Ок, штрихпунктир прорисовывается без косяков,отличная работа Илья.Только теперь я с ужасом представляю себе, что вызов этой процедуры для прорисовки всей сетки нужно будет сделать более 160ти раз, причём с разным шагом и координатами.Стоит ли овчинка выделки?

Сообщение отредактировал andreichk - Mar 23 2008, 13:17

[Ilya_A]

Ок, штрихпунктир прорисовывается без косяков,отличная работа Илья.Только теперь я с ужасом представляю себе, что вызов этой процедуры для прорисовки всей сетки нужно будет сделать более 160ти раз, причём с разным шагом и координатами.Стоит ли овчинка выделки?

Что-то вы сильнор преувеличиваете
Помоему код будет вполне компактным. Я так понимаю, координата (0,0) у вас в верхнем левом углу. Сообщите координату правой нижней точки окна в котором выводиться сигнал.

[andreichk]

X-256, Y-239

[Ilya_A]

X-256, Y-239

Решил сделать универсальную процедуру рисования сетки:

Код

/*
Процедура рисует сетку
    координаты лев. верхнего угла (0,0)
    координаты прав. нижнего угла (x,y)
    step - шаг сетки в пикселах
    len - длина половинных меток в пикселах
*/
void setka(int16 x,int16 y,int8 step,int8 len){
    int8 xm=x/2,ym=y/2;
    BYTE ds=0,            //Приращение для сетки
         ds2=step/2;    //Приращение для половинных меток
    // Рисуем сетку и половинные метки
    while((ds<xm)||(ds<ym)||(ds2<xm)||(ds2<ym)){// пока не вышли за пределы квдрата
        if(ds<ym){// Горизонтальные линии
            pline(0,ym+ds,x,ym+ds,0,1,1);
            pline(0,ym-ds,x,ym-ds,0,1,1);
        }
        if(ds<xm){// Вертикальные линии
            pline(xm+ds,0,xm+ds,y,1,1,1);
            pline(xm-ds,0,xm-ds,y,1,1,1);
        }
        if(ds2<xm){
            line(xm+ds2,0,xm+ds2,len,1);
            line(xm+ds2,ym-len,xm+ds2,ym+len,1);
            line(xm+ds2,y,xm+ds2,y-len,1);
            line(xm-ds2,0,xm-ds2,len,1);
            line(xm-ds2,ym-len,xm-ds2,ym+len,1);
            line(xm-ds2,y,xm-ds2,y-len,1);
        }
        if(ds2<ym){
            line(0,ym+ds2,len,ym+ds2,1);
            line(xm-len,ym+ds2,xm+len,ym+ds2,1);
            line(x,ym+ds2,x-len,ym+ds2,1);
            line(0,ym-ds2,len,ym-ds2,1);
            line(xm-len,ym-ds2,xm+len,ym-ds2,1);
            line(x,ym-ds2,x-len,ym-ds2,1);
        }
        ds+=step;
        ds2+=step;
    }
    // Границы сетки
    line(0,0,0,y,1);
    line(0,0,x,0,1);
    line(0,y,x,y,1);
    line(x,0,x,y,1);
}

Для вашего случая нужно вызывать со следующими параметрами:

Код

setka(256,239,30,2);

П.С. функция line втречается всего 20 раз
скомпилированная процедура будет занимать явно меньше 1kB, так что 9kB вы точно сэкономите

[andreichk]

c небольшой доработкой,приданием ей ещё бОльшей универсальности и дополнительными вызовами процедура отрисовала сетку и сэкономила 22% памяти ПИКа

Вызовы процедур, отрисовки сетки(рамки и пр.)

pline(8,1,250,1,1,1,14);//штрих-пунктирная линия
setka(256,239,30,2,2);//сетка
pline(8,119,250,119,1,1,14);//штрих-пунктирная линия
Line_(8,120,247,120,1 );//центральная горизонтальная линия
pline(8, 121, 256,121,1, 1,14);//штрих-пунктирная линия
pline(8,238,250,238,1,1,14);//штрих-пунктирная линия
pline(127,0,127,239,1,1,14);//средняя штрих-пунктирная линия
Line_(128,2,128,237,1 );//центральная вертикальная линия
pline(129,0,129,239,1,1,14);//средняя штрих-пунктирная линия
pline(1,0,1,238,1,1,14);//левая штрих-пунктирная линия
pline(255,0,255,238,1,1,14);//правая штрих-пунктирная линия
rect(0, 0, 256, 239, 0,1);//рамка

/*
Процедура рисует сетку
координаты лев. верхнего угла (0,0)
координаты прав. нижнего угла (x,y)
step - шаг сетки в пикселах
len - длина половинных меток в пикселах
len0 - длина половинных пустых меток в пикселах
*/
char ds2;
void setka(int16 x,int16 y,int8 step,int8 len,int8 len0){
int8 xm,ym;
char ds; ds=0; //Приращение для сетки
ds2=step/2; //Приращение для половинных меток
xm=x/2;ym=(y/2) + 1;
// Рисуем сетку и половинные метки
while((ds<xm)||(ds<ym)||(ds2<xm)||(ds2<ym)){// пока не вышли за пределы квдрата
if(ds<ym){// Горизонтальные линии
pline(0,ym+ds,x,ym+ds,0,1,len0);
pline(0,ym-ds,x,ym-ds,0,1,len0);
}
if(ds<xm){// Вертикальные линии
pline(xm+ds,0,xm+ds,y,1,1,len0);
pline(xm-ds,0,xm-ds,y,1,1,len0);
}
if(ds2<xm){
line(xm+ds2,0,xm+ds2,len,len0);
line(xm+ds2,ym-len,xm+ds2,ym+len,len0);
line(xm+ds2,y,xm+ds2,y-len,len0);
line(xm-ds2,0,xm-ds2,len,len0);
line(xm-ds2,ym-len,xm-ds2,ym+len,len0);
line(xm-ds2,y,xm-ds2,y-len,len0);
}
if(ds2<ym){
line(0,ym+ds2,len,ym+ds2,len0);
line(xm-len,ym+ds2,xm+len,ym+ds2,len0);
line(x,ym+ds2,x-len,ym+ds2,len0);
line(0,ym-ds2,len,ym-ds2,len0);
line(xm-len,ym-ds2,xm+len,ym-ds2,len0);
line(x,ym-ds2,x-len,ym-ds2,len0);
}
ds+=step;
ds2+=step;
}
// Границы сетки
line(0,0,0,y,len0);
line(0,0,x,0,len0);
line(0,y,x,y,len0);
line(x,0,x,y,len0);
}//--------------------------
//#####################################################################

Найдите отличия( когда я говорил о 160ти вызовах, я имел ввиду именно это)
На форму сигналов и правую часть не обращайте внимания

Сообщение отредактировал andreichk - Mar 24 2008, 13:11

[Ilya_A]

c небольшой доработкой,приданием ей ещё бОльшей универсальности и дополнительными вызовами процедура отрисовала сетку и сэкономила 22% памяти ПИКа.

Найдите отличия

Ну что же, поздравляю! Новая картинка мне даже нравиться больше

Высвободившуюся память можно заюзать под какую-нибудь цифровую обработку сигналов (как вы и говорили, например FFT)

[andreichk]

а скажите мне, преобразование Фурье к осциллографу имеет применение?

нашёл вот в сети какой-то страшенный код.Скажите, это оно? И что с ним делать?

/*************************************************************************
Быстрое преобразование Фурье

Алгоритм проводит быстрое преобразование Фурье комплексной
функции, заданной nn отсчетами на действительной оси.

В зависимости от переданных параметров, может выполняться
как прямое, так и обратное преобразование.

Входные параметры:
nn - Число значений функции. Должно быть степенью
двойки. Алгоритм не проверяет правильность
переданного значения.
a - array [0 .. 2*nn-1] of Real
Значения функции. I-ому значению соответствуют
элементы a[2*I] (вещественная часть)
и a[2*I+1] (мнимая часть).
InverseFFT
- направление преобразования.
True, если обратное, False, если прямое.

Выходные параметры:
a - результат преобразования. Подробнее см.
описание на сайте.
*************************************************************************/
void fastfouriertransform(char *a,int nn,char inversefft)
{
int ii = 0;
int jj = 0;
int n = 0;
int mmax = 0;
int m = 0;
int j = 0;
int istep = 0;
int i = 0;
int isign = 0;
double wtemp = 0;
double wr = 0;
double wpr = 0;
double wpi = 0;
double wi = 0;
double theta = 0;
double tempr = 0;
double tempi = 0;

if( inversefft )
{
isign = -1;
}
else
{
isign = 1;
}
n = 2*nn;
j = 1;
for(ii=1; ii<=nn; ii++)
{
i = 2*ii-1;
if( j>i )
{
tempr = a[j-1];
tempi = a[j];
a[j-1] = a[i-1];
a[j] = a[i];
a[i-1] = tempr;
a[i] = tempi;
}
m = n/2;
while( m>=2 & j>m )
{
j = j-m;
m = m/2;
}
j = j+m;
}
mmax = 2;
while( n>mmax )
{
istep = 2*mmax;
theta = 2*PI/(isign*mmax);
wpr = -(2.0*sqrt(Sin(0.5*theta)));
wpi = Sin(theta);
wr = 1.0;
wi = 0.0;
for(ii=1; ii<=mmax/2; ii++)
{
m = 2*ii-1;
for(jj=0; jj<=(n-m)/istep; jj++)
{
i = m+jj*istep;
j = i+mmax;
tempr = wr*a[j-1]-wi*a[j];
tempi = wr*a[j]+wi*a[j-1];
a[j-1] = a[i-1]-tempr;
a[j] = a[i]-tempi;
a[i-1] = a[i-1]+tempr;
a[i] = a[i]+tempi;
}
wtemp = wr;
wr = wr*wpr-wi*wpi+wr;
wi = wi*wpr+wtemp*wpi+wi;
}
mmax = istep;
}
if( inversefft )
{
for(i=1; i<=2*nn; i++)
{
a[i-1] = a[i-1]/nn;
}
}
}

Сообщение отредактировал andreichk - Mar 24 2008, 17:37

[andreichk]

искал что-нибудь по теме почитать- наткнулся на это.Тут на форуме комната смеха есть?
http://ru.fileaward.com/oscillometer_spectrum_analyzer.html

[Ilya_A]

а скажите мне, преобразование Фурье к осциллографу имеет применение?

Если хотите строить спектр сигнала, то без FFT не обойтись

нашёл вот в сети какой-то страшенный код.Скажите, это оно? И что с ним делать?

Вполне похоже. но только этот алгоритм для комплексной функции. А ваш сигнал - действительная величина. Следовательно вам нужно вот это:
http://alglib.sources.ru/fft/realfft.php

Там же написано что получится на выходе.

искал что-нибудь по теме почитать- наткнулся на это.Тут на форуме комната смеха есть?
http://ru.fileaward.com/oscillometer_spectrum_analyzer.htm

Мда..... 400 у.е. за такую хрень.... интересно, а как этот чувак получает динамический диапазон в 190 дБ на звуковой плате компьютера????

[andreichk]

Ок , оставим пока товарища Фурье в сторонке покурить и попробуем разобраться в следующей проблеме.Значит так,включаю сегодня осциллограф, а на экране вижу вместо сильно растянутого меандра вот эту жуть. Частота на входе 320 кГц, синронизация по фронту, то есть всё как обычно.Никакие нажатия на кнопки ничего не меняют, но по прошествии минут пяти картинка восстановилась, синхронизировалась и начал нормально срабатывать переключатель развёртки. Что это , разогрев микросхем или Барабашка у меня завёлся?

[Ilya_A]

Что это , разогрев микросхем или Барабашка у меня завёлся?

Сложно что-либо сказать, не зная как у вас вообще все это устроенно....
У вас переключается частота оцифровки сигнала? Каким образом?
Что означают 2 цифры uSec/div (из названия смысл понятен, но почему тогда они разные... или это просто для 2х каналов? ) Тогда, судя по этим цифрам (сравнивая с предыдущей) на экран должен укладываться ровно 1 период меандра (0.8 против 0.4 uSec/div).
А ваша картинка больше похожа на уменьшенную частоту оцифровки (картинка мелькала, или стояла на месте?)
Если же это результат потери синхронизации, может у вас триггер синхронизации был выставлен не правильно?

[andreichk]

на АЦП подаётся фиксированная частота оцифровки 80 МГц. С него 8бит идут на ФИФО, кот. в свою очередь тактируется частотой от 80 МГц до 625 кГц,посредством запрограммированной ПЛИСки, то есть это и есть переключатель развёртки и соответственно показания от 0.4 мкс до 51.2 мкс(за что мы с вами не так давно бились) оба канала имеют независимый переключатель, то есть одновременно можно наблюдать и 20 кГц и 2 МГц. На последнем фото импульсы подаются на нижний канал(0.4 мкс) .Но нормальный их вид как вы правильно заметили , это 1 период на весь экран.А тут вдруг такая мелкота и не пойму -откуда она берётся и почему потом пропадает? Причём частота оцифровки никоим образом не менялась(ну разве только какая-нить гармоника пролазит) такое вообще возможно?
На всякий случай вот тут схема.Кстати, что теперь будем делать с EEPROM? С картинками , как я понимаю, вопрос закрыт

[Ilya_A]

А тут вдруг такая мелкота и не пойму -откуда она берётся и почему потом пропадает?

А раньше (до изменения программы) такое случалось?

Просто я сомтрю у вас FIFO буферы то всего по 512 байт. (я думал несколько Кб). Следовательно скорость считывания при отрисовке должна быть не меньше чем 1/2 от скорости заполнения данными АЦП.
Если она будет меньше, то на высоких частотах оцифровки возможна отрисовка неправильной картины (из-за перезаписи правильных значений новыми данными)

Чтобы этого избежать придется переписать процедуру curve_A() следующим образом:

Код

unsigned int8 Buf[256];
//--------------- собственно кривая ---------------------------
void curve_A(unsigned int8 y_pos_A){
   unsigned int8 x, y , yy;
   for(x=0;x<254;x++){
      Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
      Buf[x]=input_b(); //чтение порта В
      Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
   }
   for(x=1;x<255;x++){
      yy = y;
      adcA = (Buf(x-1) > 200) ? 200 : Buf(x-1); //ограничитель до выбранной величины
      y = (255 - adcA) + y_pos_A; // разворот на 180° по вертикали и сдвиг
      if (yy>y) front(x,yy,y); // Рисуем фронт A
      if (yy<y) spad(x,yy,y); // Рисуем спад A
      pixel(x,y,1); // Рисуем вершину A
   }
}

Может быть это поможет....

Кстати, что теперь будем делать с EEPROM? С картинками , как я понимаю, вопрос закрыт

Кстати на счет EEPROM: не вижу подтягивающих резисторов на линиях SCL, SDA

[andreichk]

А раньше (до изменения программы) такое случалось?

я думаю,что да, просто я не обращал внимания


adcA = (Buf(x-1) > 200) ? 200 : Buf(x-1); //ограничитель до выбранной величины
тут очепятка ? должно быть так-Buf[х-1]

Может быть это поможет....

пока не понятно, но мне кажется , что ничего не изменилось

Кстати на счет EEPROM: не вижу подтягивающих резисторов на линиях SCL, SDA

Упс, забыл нарисовать, на самом деле они есть и даже припаяны

Просто я сомтрю у вас FIFO буферы то всего по 512 байт. (я думал несколько Кб). Следовательно скорость считывания при отрисовке должна быть не меньше чем 1/2 от скорости заполнения данными АЦП.
Если она будет меньше, то на высоких частотах оцифровки возможна отрисовка неправильной картины (из-за перезаписи правильных значений новыми данными)

тут мне не понятно- скорость считывания ФИФО устанавливает ПИК и она постоянная и всегда меньше
частоты АЦП, как быть?

кстати насчёт ФИФО, имеет ли смысл применить более ёмкую, напр.IDT7204 или даже IDT7205?

а может у меня вот это имеет место быть?

Сообщение отредактировал andreichk - Mar 29 2008, 08:30

[Ilya_A]

adcA = (Buf(x-1) > 200) ? 200 : Buf(x-1); //ограничитель до выбранной величины
тут очепятка ? должно быть так-Buf[х-1]

Естественно!

тут мне не понятно- скорость считывания ФИФО устанавливает ПИК и она постоянная и всегда меньше
частоты АЦП, как быть?
кстати насчёт ФИФО, имеет ли смысл применить более ёмкую, напр.IDT7204 или даже IDT7205?

Тут, помоему чем больше тем лучше. Ведь даже на 10 MIPS вы сможете обеспечить максимальную скорость считывания порядка единиц Мгц. А записывать данные вы можете до 80 Мгц!!!!

а может у меня вот это имеет место быть?

Чтобы это проверить, нужно замерить реальную скорость выгребания данных из FIFO буфера (можно по по количеству ассемблерных инструкций после компиляции программы) И сравнить со скоростью записи в буфер

[andreichk]

Чтобы это проверить, нужно замерить реальную скорость выгребания данных из FIFO буфера (можно по по количеству ассемблерных инструкций после компиляции программы) И сравнить со скоростью записи в буфер

Ок, а с какого места нужно начинать считать эти инструкции?

[Ilya_A]

Ок, а с какого места нужно начинать считать эти инструкции?

Незнаю, как в CCS, но в MPLABe это делается очень просто, открываем Dissasebly listing, находим строчку начала цикла:

Код

   for(x=0;x<254;x++){
      Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
      Buf[x]=input_b(); //чтение порта В
      Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
   }

И считаем сколько команд ушло на этот цикл

Если в CCS такого нет, то может он хотябы отобразить текст откомпилированной программы? И если в нем возможна симуляция, то поставить BreakPoint на начало цикла, а затем посмотреть на какой строчке программа остановиться в асме. далее выполнять программу по шагам ассемблерных инструкций, пока не вернетесь снова на точку останова. Таким образом можно подсчитать количестов асм. инструкций.

Ну или в крайнем случае можно померять клоки осциллографом.

[andreichk]

есть такое дело

.................... //--------------- собственно кривая ---------------------------
.................... void curve_A(unsigned int8 y_pos_A){
.................... unsigned int8 x, y , yy;
.................... for(x=0;x<254;x++){
*
26E4: MOVLB 1
26E6: CLRF x6B
26E8: MOVF x6B,W
26EA: SUBLW FD
26EC: BNC 2710
.................... Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
26EE: BCF F8B.2
26F0: BCF F94.2
.................... Buf[x]=input_b(); //чтение порта В
26F2: CLRF 03
26F4: MOVF x6B,W
26F6: ADDLW 55
26F8: MOVWF FE9
26FA: MOVLW 00
26FC: ADDWFC 03,W
26FE: MOVWF FEA
2700: MOVLW FF
2702: MOVWF F93
2704: MOVFF F81,FEF
.................... Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
2708: BSF F8B.2
270A: BCF F94.2
.................... }
270C: INCF x6B,F
270E: BRA 26E8
.................... for(x=1;x<255;x++){
2710: MOVLW 01
2712: MOVWF x6B
2714: INCFSZ x6B,W
2716: BRA 271A
2718: BRA 27AA
.................... yy = y;
271A: MOVFF 16C,16D
.................... adcA = (Buf[x-1] > 200) ? 200 : Buf[x-1]; //ограничитель до выбранной величины
271E: MOVLW 01
2720: SUBWF x6B,W
2722: CLRF 03
2724: ADDLW 55
2726: MOVWF FE9
2728: MOVLW 00
272A: ADDWFC 03,W
272C: MOVWF FEA
272E: MOVF FEF,W
2730: SUBLW C8
2732: BC 2738
2734: MOVLW C8
2736: BRA 274A
2738: MOVLW 01
273A: SUBWF x6B,W
273C: CLRF 03
273E: ADDLW 55
2740: MOVWF FE9
2742: MOVLW 00
2744: ADDWFC 03,W
2746: MOVWF FEA
2748: MOVF FEF,W
274A: MOVWF x54
.................... y = (255 - adcA) + y_pos_A; // разворот на 180° по вертикали и сдвиг
274C: MOVLW FF
274E: BSF FD8.0
2750: SUBFWB x54,W
2752: ADDWF x6A,W
2754: MOVWF x6C
.................... adcA = y;
2756: MOVFF 16C,154
.................... if (yy>y) front(x,yy,y); // Рисуем фронт A
275A: MOVF x6D,W
275C: SUBWF x6C,W
275E: BC 2774
2760: MOVFF 16B,16E
2764: MOVFF 16D,16F
2768: MOVFF 16C,170
276C: MOVLB 0
276E: CALL 1DEC
2772: MOVLB 1
.................... if (yy<y) spad(x,yy,y); // Рисуем спад A
2774: MOVF x6C,W
2776: SUBWF x6D,W
2778: BC 278E
277A: MOVFF 16B,16E
277E: MOVFF 16D,16F
2782: MOVFF 16C,170
2786: MOVLB 0
2788: CALL 1E18
278C: MOVLB 1
.................... pixel(x,y,1); // Рисуем вершину A
278E: CLRF x8B
2790: MOVFF 16B,18A
2794: CLRF x8D
2796: MOVFF 16C,18C
279A: MOVLW 01
279C: MOVWF x8E
279E: MOVLB 0
27A0: CALL 0BE8
.................... }
27A4: MOVLB 1
27A6: INCF x6B,F
27A8: BRA 2714
.................... }
27AA: MOVLB 0
27AC: RETLW 00
....................
.................... //########################################

Сообщение отредактировал andreichk - Mar 30 2008, 11:04

[Ilya_A]

есть такое дело

Да, это в принципе оно и есть. только не видать конца цикла, приведите еще несколько инструкций, чтобы точнее определить полное количество тактов. Я предполагаю, что конец цикла по адресу 0x270F

[andreichk]

Да, это в принципе оно и есть. только не видать конца цикла, приведите еще несколько инструкций, чтобы точнее определить полное количество тактов. Я предполагаю, что конец цикла по адресу 0x270F

заменил предыдущий пость на полный текст процедуры

[Ilya_A]

заменил предыдущий пость на полный текст процедуры

Цикл от 0x26E8 до 0x270E итого 18 интсрукций, по 1му такту и 1 инструкция 2 такта всего 20 тактов

Следовательно период считываения 2 мкс, а частота 500 кГц

Следовательно можно сделать вывод, что если частота заполнения FIFO будет больше чем 1 Мгц то за время считывания 255 отсчетов в FIFO положится более 512 новых значений и часть отсчетов просто перезапишется новыми.

[andreichk]

ну это понятно, что перепишется.А как это связано с образованием частокола и последующим его исчезновением?

[Ilya_A]

ну это понятно, что перепишется.А как это связано с образованием частокола и последующим его исчезновением?

А при какой частоте тактирования FIFO они возникают?

Вообще говоря цикл получился крайне не оптимальным.

Совершенно напонятно зачем выполняются строчки:

Код

26F0: BCF F94.2
270A: BCF F94.2

Зачем каждый раз чистить TRIS???? А это уже 2 лишних такта!

Советую вам переписать следующим образом, должно получится гораздо компактнее:

Код

unsigned char * ptr=Buf;
x=2;
while(x++){
      LATC2=0;
      *ptr++=input_b(); //чтение порта В
      LATC2=1;
}

А вообще, похорошему нужно воспользоваться регистрами косвенной адресации (FSR) тогда указатель будет инкрементироваться автоматически после каждого присвоения.
Но тут уже без асма не обойтись....

[andreichk]

А при какой частоте тактирования FIFO они возникают?

да собственно на всех восьми, но заметнее всего при 80ти МГц, то есть 0.4 мксек

LATC2=0;

это что такое?

А вообще, похорошему нужно воспользоваться регистрами косвенной адресации (FSR) тогда указатель будет инкрементироваться автоматически после каждого присвоения.
Но тут уже без асма не обойтись....

тут я без поллитры не разберусь.
про Асм и FSR слышал, но живьём не видел

Сообщение отредактировал andreichk - Mar 30 2008, 13:42

[Ilya_A]

LATC2
это что такое?

Это регистр защелок порта C, а 2 - номер бита.

если не работает можно попробывать сделать асмовскую вставку, незнаю как у вас в CCS, но в PICC это делается так:

Код

asm("BSF F8B.2");  //LATC2=1
asm("BCF F8B.2");  //LATC2=0

F8B - это адрес LATC, вообщето он должен быть прописан и можно писать так:

Код

asm("BSF LATC.2");  //LATC2=1
asm("BCF LATC.2");  //LATC2=0

А вообще тут что нету специалистов по CCS? подскажите человеку!!!!

пытаюсь загрузить видео, не знаю можно уже посмотреть или нет?

Видео посметреть пока у меня не получается....

[andreichk]

можно написать так
#asm
BSF F8B.2 //LATC2=1
#endasm
но он не хочет узнавать F8B.2
пишет- неопределённая переменная.
может чего в настройках компилятора недостаёт, буду разбираться

тут попробуйте
http://video.google.de/videoplay?docid=330...h&plindex=0

Сообщение отредактировал andreichk - Mar 30 2008, 13:40

[Ilya_A]

можно написать так
#asm
BSF F8B.2 //LATC2=1
#endasm
но он не хочет узнавать F8B.2

Попробуйте написать так: BSF 0x0F8B, 0x2

[andreichk]

написал так, ошибок нет,но экран тухнет через пару сек

#asm
BSF 0xF8B.2//LATC2=0;
#endasm
*ptr++=input_b(); //чтение порта В
#asm
BCF 0xF8B.2//LATC2=1;
#endasm

Попробуйте написать так: BSF 0x0F8B, 0x2

всё равно тухнет

просмотр видео состоялся?

Сообщение отредактировал andreichk - Mar 30 2008, 15:19

[Ilya_A]

написал так, ошибок нет,но экран тухнет через пару сек

Что значит тухнет экран? Весь? или только перестает рисоваться сигнал?

[andreichk]

в самом прямом смысле тухнет.Пропадает не только линия,но и сетка и цифирьки.

[Ilya_A]

в самом прямом смысле тухнет.Пропадает не только линия,но и сетка и цифирьки.

При добавлении какой именно строчки такое происходит? Попробуйте модифицировать постепенно.

просмотр видео состоялся?

Нет, пишет: No matching videos.

Не проще ли залить файлик на рапиду?

[andreichk]

вот этой
*ptr++=input_b(); //чтение порта В
ну тогда отсюда попробуйте
http://forum.radiospec.ru/index.php?showtopic=6310

[Ilya_A]

вот этой
*ptr++=input_b(); //чтение порта В

попробуйте сделать так:

Код

*ptr=input_b(); //чтение порта В
ptr++;

Кстати, а приведите лучше дизассемблер, посмотрим что там ваш компилятор на компилировал

ну тогда отсюда попробуйте
http://forum.radiospec.ru/index.php?showtopic=6310

12 МБ.... я щас на диалапе, завтра качну по нормальному каналу

[andreichk]

.................... //####################################################################
.................... //--------------- собственно кривая ---------------------------
.................... unsigned char *ptr=Buf;
.................... void curve_A(unsigned int8 y_pos_A){
.................... unsigned int8 x,y, yy;
.................... x=2;
*
26E4: MOVLW 02
26E6: MOVLB 1
26E8: MOVWF x6D
.................... // for(x=0;x<254;x++){
.................... while(x++){
26EA: MOVF x6D,W
26EC: INCF x6D,F
26EE: XORLW 00
26F0: BZ 270E
.................... #asm
.................... BSF 0x0F8B,0x2//LATC2=0;
26F2: BSF F8B.2
.................... #endasm
.................... *ptr=input_b(); //чтение порта В
26F4: MOVFF 15F,FE9
26F8: MOVFF 160,FEA
26FC: MOVLW FF
26FE: MOVWF F93
2700: MOVFF F81,FEF
.................... ptr++;
2704: INCF x5F,F
2706: BTFSC FD8.2
2708: INCF x60,F
.................... #asm
.................... BCF 0x0F8B,0x2//LATC2=1;
270A: BCF F8B.2
.................... #endasm
.................... //Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
.................... //Buf[x]=input_b(); //чтение порта В
.................... //Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
.................... }
270C: BRA 26EA
.................... for(x=1;x<255;x++){
270E: MOVLW 01
2710: MOVWF x6D
2712: INCFSZ x6D,W
2714: BRA 2718
2716: BRA 27A4
.................... yy = adcA;//y
2718: MOVFF 154,16F
.................... adcA = (Buf[x-1] > 200) ? 200 : Buf[x-1]; //ограничитель до выбранной величины
271C: MOVLW 01
271E: SUBWF x6D,W
2720: CLRF 03
2722: ADDLW 55
2724: MOVWF FE9
2726: MOVLW 00
2728: ADDWFC 03,W
272A: MOVWF FEA
272C: MOVF FEF,W
272E: SUBLW C8
2730: BC 2736
2732: MOVLW C8
2734: BRA 2748
2736: MOVLW 01
2738: SUBWF x6D,W
273A: CLRF 03
273C: ADDLW 55
273E: MOVWF FE9
2740: MOVLW 00
2742: ADDWFC 03,W
2744: MOVWF FEA
2746: MOVF FEF,W
2748: MOVWF x54
.................... adcA = (255 - adcA) + y_pos_A; // разворот на 180° по вертикали и сдвиг
274A: MOVLW FF
274C: BSF FD8.0
274E: SUBFWB x54,W
2750: ADDWF x6C,W
2752: MOVWF x54
.................... if (yy>adcA) front(x,yy,adcA); // Рисуем фронт A
2754: MOVF x6F,W
2756: SUBWF x54,W
2758: BC 276E
275A: MOVFF 16D,170
275E: MOVFF 16F,171
2762: MOVFF 154,172
2766: MOVLB 0
2768: CALL 1DEC
276C: MOVLB 1
.................... if (yy<adcA) spad(x,yy,adcA); // Рисуем спад A
276E: MOVF x54,W
2770: SUBWF x6F,W
2772: BC 2788
2774: MOVFF 16D,170
2778: MOVFF 16F,171
277C: MOVFF 154,172
2780: MOVLB 0
2782: CALL 1E18
2786: MOVLB 1
.................... pixel(x,adcA,1); // Рисуем вершину A
2788: CLRF x8D
278A: MOVFF 16D,18C
278E: CLRF x8F
2790: MOVFF 154,18E
2794: MOVLW 01
2796: MOVWF x90
2798: MOVLB 0
279A: CALL 0BE8
.................... }
279E: MOVLB 1
27A0: INCF x6D,F
27A2: BRA 2712
.................... }
27A4: MOVLB 0
27A6: RETLW 00
....................
.................... //####

всё равно тухнет.Я так думаю, что там всё правильно и нужно.Наверное не стоит там ковыряться

12 МБ....

Ограбили я на 43 наснимал !!!

давайте лучше это строить, только я не знаю с какого боку подьезжать

//##############################################
void spectrum_analizator(void)
{
realfastfouriertransform( Buf,128,0);
}
//##############################################

Сообщение отредактировал andreichk - Mar 30 2008, 16:28

[Ilya_A]

всё равно тухнет.Я так думаю, что там всё правильно и нужно.

Нет, вы не правы, там половина операций ненужна... но я заметил что не происходит инициализация указателя ptr, при входе в функцию, хотя у меня написано (ненравится мне этот компилятор, блин...)

напишите явное присвоение

Код

ptr=Buf;

перед циклом

Код

while(x++)

Просто происходило следующее: при каждом входе в процедуру, указатель все увеличивался и увеличивался... и затирал все подряд...

также абсолютнно бессмыслены следующие строчки:

Код

26FC: MOVLW FF
26FE: MOVWF F93

их нужно максимум выполнить 1 раз перед циклом.

А проверка условия выхода из цикла:

Код

26EA: MOVF x6D,W
26EC: INCF x6D,F
26EE: XORLW 00
26F0: BZ 270E

Это же просто ужас!!! Они что не знают инструкции INCFSZ ???

Я бы написал весь цикл в 5 асмовских инструкций, и выполнялся бы он за 6 тактов процессора...

давайте лучше это строить, только я не знаю с какого боку подьезжать

Ну вы хоть начните подъезжать!!! Может вопросы по конкретнее появятся...

[andreichk]

Илья, я уже запутался, что куда вписывать, сделайте плиз это за меня , а я сразу же проверю

//####################################################################
void pix_A(unsigned int8 y_pos_A) // рисуем кривую, типа синусоиды и пр.
{ unsigned int16 n=0;

Output_bit(PLCD_FIFO_RES ,0); //PIN_C0// сброс FIFO в "0"
Output_bit(PLCD_FIFO_RES ,1); //PIN_C0// и разрешение на считывание
Output_bit(READ_FIFO_B ,1); //PIN_C1 запрет канала B
//-------------------- синхронизация ---------------------------
n=0;
for(;;){
Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
adcA=input_b(); //чтение порта В
Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
adcA = (adcA > 200) ? 200 : adcA; //ограничитель до выбранной величины
adcA = 255 - adcA; // разворот на 180° по вертикали
if (n++>TIMEOUT) {curve_A(y_pos_A); return;}
if (syncA){
if(adcA>sync_volume_A) continue;else break;
}else{
if(adcA<=sync_volume_A+115) continue;else break;
}
} curve_A(y_pos_A);//собственно кривая

}//--------------------------OK
//####################################################################
//--------------- собственно кривая ---------------------------
unsigned char *ptr=Buf;
void curve_A(unsigned int8 y_pos_A){
unsigned int8 x,y, yy;
x=2;
// for(x=0;x<254;x++){
while(x++){
#asm
BSF 0x0F8B,0x2//LATC2=0;
#endasm
*ptr=input_b(); //чтение порта В
ptr++;
#asm
BCF 0x0F8B,0x2//LATC2=1;
#endasm
//Output_bit(READ_FIFO_A ,0); //PIN_C2. разрешить
//Buf[x]=input_b(); //чтение порта В
//Output_bit(READ_FIFO_A ,1); //PIN_C2.запретить
}
for(x=1;x<255;x++){
yy = adcA;//y
adcA = (Buf[x-1] > 200) ? 200 : Buf[x-1]; //ограничитель до выбранной величины
adcA = (255 - adcA) + y_pos_A; // разворот на 180° по вертикали и сдвиг
if (yy>adcA) front(x,yy,adcA); // Рисуем фронт A
if (yy<adcA) spad(x,yy,adcA); // Рисуем спад A
pixel(x,adcA,1); // Рисуем вершину A
}
}
//#########################################