За един проект ми се налага да използвам PIC16F527.
Проблемът е, че работя в MikroC, а този контролер не се поддържа. Затова се хванах и почти завърших мои файлове с дефинизии на контролера.
Успявам да го вкарам в проекта, но има един такъв проблем: В Datashhet-а адресите на OPTION и TRIS регистрите са дадени като N/A. Доколкото виждам от примерния код в описанието, TRIS се третира като инструкция, въпреки, че се дава като "регистър".
Пример:
MOVLW 007h ;
TRIS PORTB ;--10 -ppp--11 pppp

Два дни търся дефиниции за който и да било С компилатор, за да видя как се използва това, но не успявам да намеря. Ако някой знае, нека обясни или да ми даде връзка за сваляне на файл с описание за C на въпросния микроконтролер.

Трис са ти регистри, и записа в тях става със същата MOV команда, въпроса е че тоя регистър ак не ме лъже паметта е в друга банка, не е в 0.

Иначе като на всеки друг пик 16 това трябва да са ти 0х05, 0х06, 0х07 ... съотвенто за А, B, C и т.н. каквото има, но във банка ... 1 ако не се лъжа.

Няма АДРЕС на такъв регистър. А се използва. Освен това, обърни внимание как се използва TRIS в примера от Datasheet-а. Има някаква особеност, която не мога да схвана при няколко подобни процесора. И нито един не се поддържа от МикроC, за да намеря пример. Не мога да дефинирам като константа нещо, което няма адрес...
Същото е и с OPTION.

Сега загледах мануала, наистина там не са дадени адреси в тоя даташиит, с тоя не съм работил никога и не вярвах да са сменили концепцията .. но май са, явно мноооого отдавна не съм бутал пикове .. има няма 12 години

Това са относително нови пикове. Но само при част от тях е така. Ползвам и по-сериозни и там има адреси. Микроелектроника две години обещават, а нищо не направиха. Изтеглих Майкрочипските дефиниции за Асемблер и там няма адреси, а направо го ползват. Накрая ще махна тези дефиниции и част от командите ще вкарам на Асемблер. Но подобни подходи ме отблъскват.

while(TRUE)
.................... {
.................... SET_TRIS_B( 0x0F );
000A: MOVLW 0F
000B: TRIS 6
000C: MOVLB 0
000D: MOVWF 10
000E: MOVLB 1
000F: GOTO 00A
....................
.................... //TODO: User Code
.................... }

ето как го прави CCS така като гледам не е май само дефиниця на регистъра.
Ето го и целия .h файл за тоя пик

//////////// Standard Header file for the PIC16F527 device ////////////////
///////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996, 2014 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS C ////
//// compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, reproduction ////
//// or distribution is permitted without written permission. ////
//// Derivative programs created using this software in object code ////
//// form are not restricted in any way. ////
///////////////////////////////////////////////////////////////////////////
#device PIC16F527

#nolist
//////// Program memory: 1024x12 Data RAM: 68 Stack: 4
//////// I/O: 18 Analog Pins: 8
//////// Data EEPROM: 64
//////// C Scratch area: 0C ID Location: 0440
//////// Oscilator Calibration Address: 05
//////// Fuses: LP,XT,HS,EC_IO,INTRC_IO,INTRC,RC_IO,RC,NOWDT,WDT,PROTECT
//////// Fuses: NOPROTECT,NOMCLR,MCLR,IOSC4,IOSC8,CPD,NOCPD,NOBROWNOUT
//////// Fuses: BROWNOUT,NOPUT,PUT
////////
#if (!defined(__PCB__)||defined(__ISNT_CCS__))
#define _bif
#define int8 char
#define int16 long
#define int32 long long
#define float32 float
#define int1 char

#endif
////////////////////////////////////////////////////////////////// I/O
// Discrete I/O Functions: SET_TRIS_x(), OUTPUT_x(), INPUT_x(),
// PORT_x_PULLUPS(), INPUT(),
// OUTPUT_LOW(), OUTPUT_HIGH(),
// OUTPUT_FLOAT(), OUTPUT_BIT(),
// Discrete I/O Prototypes:
_bif void set_tris_a(int8 value);
_bif void set_tris_b(int8 value);
_bif void set_tris_c(int8 value);
_bif int8 get_tris_a(void);
_bif int8 get_tris_b(void);
_bif int8 get_tris_c(void);
_bif void output_a(int8 value);
_bif void output_b(int8 value);
_bif void output_c(int8 value);
_bif int8 input_a(void);
_bif int8 input_b(void);
_bif int8 input_c(void);
_bif int8 input_change_a(void);
_bif int8 input_change_b(void);
_bif int8 input_change_c(void);
_bif int1 input(int16 pin);
_bif int1 input_state(int16 pin);
_bif void output_low(int16 pin);
_bif void output_high(int16 pin);
_bif void output_toggle(int16 pin);
_bif void output_bit(int16 pin, int1 level);
_bif void output_float(int16 pin);
_bif void output_drive(int16 pin);

// Constants used to identify pins in the above are:

#define PIN_A0 48
#define PIN_A1 49
#define PIN_A2 50
#define PIN_A3 51
#define PIN_A4 52
#define PIN_A5 53

#define PIN_B4 60
#define PIN_B5 61
#define PIN_B6 62
#define PIN_B7 63

#define PIN_C0 64
#define PIN_C1 65
#define PIN_C2 66
#define PIN_C3 67
#define PIN_C4 68
#define PIN_C5 69
#define PIN_C6 70
#define PIN_C7 71

////////////////////////////////////////////////////////////////// Useful defines
#define FALSE 0
#define TRUE 1

#define BYTE int8
#define BOOLEAN int1

#define getc getch
#define fgetc getch
#define getchar getch
#define putc putchar
#define fputc putchar
#define fgets gets
#define fputs puts

////////////////////////////////////////////////////////////////// Control
// Control Functions: RESET_CPU(), SLEEP(), RESTART_CAUSE()
// Prototypes:
_bif int8 restart_cause(void);
_bif void reset_cpu(void);
_bif void sleep(void);
// Constants returned from RESTART_CAUSE() are:
#define WDT_FROM_SLEEP 3
#define WDT_TIMEOUT 11
#define MCLR_FROM_SLEEP 19
#define MCLR_FROM_RUN 27
#define NORMAL_POWER_UP 25
#define BROWNOUT_RESTART 26

////////////////////////////////////////////////////////////////// Timer 0
// Timer 0 (AKA RTCC)Functions: SETUP_COUNTERS() or SETUP_TIMER_0(),
// SET_TIMER0() or SET_RTCC(),
// GET_TIMER0() or GET_RTCC()
// Timer 0 Prototypes:
_bif void setup_timer_0(int8 mode);
_bif void set_timer0(int8 value);
_bif int8 get_timer0(void);
_bif void setup_counters(int8 mode, int8 prescaler);
_bif void set_rtcc(int8 value);
_bif int8 get_rtcc(void);
// Constants used for SETUP_TIMER_0() are:
#define T0_INTERNAL 0
#define T0_EXT_L_TO_H 32
#define T0_EXT_H_TO_L 48

#define T0_DIV_1 8
#define T0_DIV_2 0
#define T0_DIV_4 1
#define T0_DIV_8 2
#define T0_DIV_16 3
#define T0_DIV_32 4
#define T0_DIV_64 5
#define T0_DIV_128 6
#define T0_DIV_256 7


#define T0_8_BIT 0

#define RTCC_INTERNAL 0 // The following are provided for compatibility
#define RTCC_EXT_L_TO_H 32 // with older compiler versions
#define RTCC_EXT_H_TO_L 48
#define RTCC_DIV_1 8
#define RTCC_DIV_2 0
#define RTCC_DIV_4 1
#define RTCC_DIV_8 2
#define RTCC_DIV_16 3
#define RTCC_DIV_32 4
#define RTCC_DIV_64 5
#define RTCC_DIV_128 6
#define RTCC_DIV_256 7
#define RTCC_8_BIT 0

// Constants used for SETUP_COUNTERS() are the above
// constants for the 1st parameter and the following for
// the 2nd parameter:

////////////////////////////////////////////////////////////////// WDT
// Watch Dog Timer Functions: SETUP_WDT() or SETUP_COUNTERS() (see above)
// RESTART_WDT()
// WDT base is 18ms
// WDT Prototypes:
_bif void setup_wdt(int16 mode);
_bif void restart_wdt(void);
// Constants used for SETUP_WDT() are:

#define WDT_18MS 8
#define WDT_36MS 9
#define WDT_72MS 10
#define WDT_144MS 11
#define WDT_288MS 12
#define WDT_576MS 13
#define WDT_1152MS 14
#define WDT_2304MS 15


#define DISABLE_PULLUPS 0x40 // for 505, 508, 509, 527 and 570 only
#define DISABLE_WAKEUP_ON_CHANGE 0x80 // for 505, 508, 509, 527 and 570 only
#define PIN_CHANGE_FROM_SLEEP 0 // DEFAULT, for 505, 508, 509, 527 and 570 only

////////////////////////////////////////////////////////////////// COMP
// Comparator Variables: C1OUT, C2OUT
// Comparator Prototypes:
_bif void setup_comparator(unsigned int16 mode);
// Constants used in setup_comparator() are:
//
#define NC_NC_NC_NC 0x00

//Pick one constant for COMP1
#define CP1_A0_A1 0x0E
#define CP1_A0_VREF 0x0A
#define CP1_A1_VREF 0x08
//Optionally OR with any of the following
#define CP1_WAKEUP_ON_CHANGE 0x01
#define CP1_OUTPUT_IS_TMR0_CLK 0x10
#define CP1_INVERT 0x20
#define CP1_OUT_ON_A2 0x40

//Pick one constant for COMP2
#define CP2_C0_C1 0x0E00
#define CP2_A0_C1 0x1C00
#define CP2_C0_VREF 0x0A00
#define CP2_A0_VREF 0x1800
#define CP2_C1_VREF 0x0800
//Optionally OR with any of the following
#define CP2_WAKEUP_ON_CHANGE 0x0100
#define CP2_INVERT 0x2000
#define CP2_OUT_ON_C4 0x4000

#bit C1OUT = getenv("SFR:CM1CON0").7
#bit C2OUT = getenv("SFR:CM2CON0").7

////////////////////////////////////////////////////////////////// VREF
// VREF Prototypes:
_bif void setup_vref(int8 mode);
// Constants used in setup_vref() are:
#define VREF_LOW 0xA0
#define VREF_HIGH 0x80
#define VREF_OUT_A1 0x40
// Or (with |) the above with a number 0-15

////////////////////////////////////////////////////////////////// OPAMP
// OPAMP Functions: SETUP_OPAMPx()
// OPAMP Prototypes:
_bif void setup_opamp1(int8 mode);
_bif void setup_opamp2(int8 mode);
// Constants used in SETUP_OPAMPx() are:
#define OPAMP_ENABLED 1
#define OPAMP_DISABLED 0


////////////////////////////////////////////////////////////////// ADC
// ADC Functions: SETUP_ADC(), SETUP_ADC_PORTS() (aka SETUP_PORT_A),
// SET_ADC_CHANNEL(), READ_ADC(), ADC_DONE()
// ADC Prototypes:
_bif void setup_adc(int16 mode);
_bif int8 read_adc(void);
_bif int8 read_adc(int8 mode);
_bif int16 read_adc(void);
_bif int16 read_adc(int8 mode);
_bif int1 adc_done(void);
// Constants used for SETUP_ADC() are:
#define ADC_OFF 0 // ADC Off
#define ADC_CLOCK_DIV_2 0x100
#define ADC_CLOCK_DIV_8 0x40
#define ADC_CLOCK_DIV_32 0x80
#define ADC_CLOCK_INTERNAL 0xc0 // Internal 2-6us

//ADC Prototypes:
_bif void setup_adc_ports(int8 pins);
_bif void set_adc_channel(int8 channel);
_bif void set_analog_pins(int8 pins);
// Constants used in SETUP_ADC_PORTS() and SET_ANALOG_PINS() are:
// First argument:
// OR together desired pins
#define sAN0 0x01 //| A0
#define sAN1 0x02 //| A1
#define sAN2 0x04 //| A2
#define sAN3 0x08 //| A4
#define sAN4 0x10 //| C0
#define sAN5 0x20 //| C1
#define sAN6 0x40 //| C2
#define sAN7 0x80 //| C3
#define NO_ANALOGS 0 // None
#define ALL_ANALOG 0xFF // A0 A1 A2 A4 C0 C1 C2 C3

// Constants used in READ_ADC() are:
#define ADC_START_AND_READ 7 // This is the default if nothing is specified
#define ADC_START_ONLY 1
#define ADC_READ_ONLY 6

////////////////////////////////////////////////////////////////// BIF
// Built In Functions Prototypes
//
// Math Prototypes:
_bif signed int8 abs(signed int8 x);
_bif signed int16 abs(signed int16 x);
_bif signed int32 abs(signed int32 x);
_bif float32 abs(float32 x);
_bif unsigned int16 _mul(unsigned int8, unsigned int8);
_bif signed int16 _mul(signed int8, signed int8);
_bif unsigned int32 _mul(unsigned int16, unsigned int16);
_bif signed int32 _mul(signed int16, signed int16);

// Memory Manipulation Prototypes:
_bif int8 read_bank(int8 bank, int8 offset);
_bif void write_bank(int8 bank, int8 offset, int8 value);
_bif void strcpy(char* dest, char* src);
_bif void memset(unsigned int8* destination, unsigned int8 value, unsigned int16 num);
_bif void memcpy(unsigned int8* destination, unsigned int8* source, unsigned int16 num);

// String Prototypes:
_bif char toupper(char cvalue);
_bif char tolower(char cvalue);
_bif void sprintf(char* string, char* cstring, ...);

// Data Manipulators Prototypes:
_bif int1 shift_left(unsigned int8* address, unsigned int8 bytes, int1 value);
_bif int1 shift_right(unsigned int8* address, unsigned int8 bytes, int1 value);
_bif void rotate_left(unsigned int8* address, unsigned int8 bytes);
_bif void rotate_right(unsigned int8* address, unsigned int8 bytes);
_bif void swap(unsigned int8 value);
_bif unsigned int8 make8(unsigned int16 var, unsigned int8 offset);
_bif unsigned int8 make8(unsigned int32 var, unsigned int8 offset);
_bif unsigned int16 make16(unsigned int8 varhigh, unsigned int8 varlow);
_bif unsigned int32 make32(unsigned int16 var1);
_bif unsigned int32 make32(unsigned int16 var1, unsigned int16 var2);
_bif unsigned int32 make32(unsigned int16 var1, unsigned int8 var2);
_bif unsigned int32 make32(unsigned int16 var1, unsigned int8 var2, unsigned int8 var3);
_bif unsigned int32 make32(unsigned int8 var1);
_bif unsigned int32 make32(unsigned int8 var1, unsigned int8 var2);
_bif unsigned int32 make32(unsigned int8 var1, unsigned int8 var2, unsigned int8 var3);
_bif unsigned int32 make32(unsigned int8 var1, unsigned int8 var2, unsigned int8 var3, unsigned int8 var4);
_bif unsigned int32 make32(unsigned int8 var1, unsigned int16 var2);
_bif unsigned int32 make32(unsigned int8 var1, unsigned int16 var2, unsigned int8 var3);
_bif unsigned int32 make32(unsigned int8 var1, unsigned int8 var2, unsigned int16 var3);
_bif void bit_set(unsigned int8 var, unsigned int8 bit);
_bif void bit_set(unsigned int16 var, unsigned int8 bit);
_bif void bit_set(unsigned int32 var, unsigned int8 bit);
_bif void bit_clear(unsigned int8 var, unsigned int8 bit);
_bif void bit_clear(unsigned int16 var, unsigned int8 bit);
_bif void bit_clear(unsigned int32 var, unsigned int8 bit);
_bif int1 bit_test(unsigned int8 var, unsigned int8 bit);
_bif int1 bit_test(unsigned int16 var, unsigned int8 bit);
_bif int1 bit_test(unsigned int32 var, unsigned int8 bit);

// #use delay() Prototypes:
_bif void delay_cycles(unsigned int8 count);
_bif void delay_ms(unsigned int16 time);
_bif void delay_us(unsigned int16 time);

// #use rs232() Prototypes:
_bif void putchar(char cdata);
_bif void putchar(char cdata, unsigned int8 stream);
_bif void puts(char* string);
_bif void puts(char* string, unsigned int8 stream);
_bif char getch(void);
_bif char getch(unsigned int8 stream);
_bif void gets(char* string);
_bif void gets(char* string, unsigned int8 stream);
_bif int1 kbhit(void);
_bif int1 kbhit(unsigned int8 stream);
_bif void printf(char* string, ...);
_bif void fprintf(unsigned int8 stream, char* string, ...);
_bif void putc_send(void);
_bif void fputc_send(unsigned int8 stream);
_bif int1 rcv_buffer_full(void);
_bif int1 rcv_buffer_full(unsigned int8 stream);
_bif unsigned int16 rcv_buffer_bytes(void);
_bif unsigned int16 rcv_buffer_bytes(unsigned int8 stream);
_bif int1 tx_buffer_full(void);
_bif int1 tx_buffer_full(unsigned int8 stream);
_bif unsigned int16 tx_buffer_bytes(void);
_bif unsigned int16 tx_buffer_bytes(unsigned int8 stream);

// #use i2c() Prototypes:
_bif unsigned int8 i2c_read(void);
_bif unsigned int8 i2c_read(unsigned int8 stream);
_bif unsigned int8 i2c_read(unsigned int8 stream, int1 ack);
_bif int1 i2c_write(unsigned int8 data);
_bif int1 i2c_write(unsigned int8 stream, unsigned int8 data);
_bif void i2c_start(void);
_bif void i2c_start(unsigned int8 stream);
_bif void i2c_start(unsigned int8 stream, unsigned int8 restart);
_bif void i2c_stop(void);
_bif void i2c_stop(unsigned int8 stream);
_bif int8 i2c_isr_state(void);
_bif void i2c_slaveaddr(unsigned int8 addr);
_bif void i2c_slaveaddr(unsigned int8 stream, unsigned int8 addr);
_bif int1 i2c_poll(void);
_bif int1 i2c_poll(unsigned int8 stream);
_bif void i2c_init(unsigned int32 baud);
_bif void i2c_init(unsigned int8 stream, unsigned int32 baud);

// #use spi() Prototypes:
_bif unsigned int8 spi_xfer(void);
_bif unsigned int16 spi_xfer(void);
_bif unsigned int32 spi_xfer(void);
_bif unsigned int8 spi_xfer(unsigned int8 data);
_bif unsigned int16 spi_xfer(unsigned int16 data);
_bif unsigned int32 spi_xfer(unsigned int32 data);
_bif unsigned int8 spi_xfer(unsigned int8 stream, unsigned int8 data);
_bif unsigned int16 spi_xfer(unsigned int8 stream, unsigned int16 data);
_bif unsigned int32 spi_xfer(unsigned int8 stream, unsigned int32 data);
_bif unsigned int8 spi_xfer(unsigned int8 stream, unsigned int8 data, unsigned int8 bits);
_bif unsigned int16 spi_xfer(unsigned int8 stream, unsigned int16 data, unsigned int8 bits);
_bif unsigned int32 spi_xfer(unsigned int8 stream, unsigned int32 data, unsigned int8 bits);
_bif void spi_init(unsigned int32 baud);
_bif void spi_init(unsigned int8 stream, unsigned int32 baud);
_bif void spi_speed(unsigned int32 baud);
_bif void spi_speed(unsigned int8 stream, unsigned int32 baud);
_bif void spi_speed(unsigned int8 stream, unsigned int32 baud, unsigned int32 clock);
_bif void spi_prewrite(unsigned int8 data);
_bif void spi_prewrite(unsigned int16 data);
_bif void spi_prewrite(unsigned int32 data);
_bif void spi_prewrite(unsigned int8, unsigned int8 data);
_bif void spi_prewrite(unsigned int8, unsigned int16 data);
_bif void spi_prewrite(unsigned int8, unsigned int32 data);
_bif unsigned int8 spi_xfer_in(void);
_bif unsigned int16 spi_xfer_in(void);
_bif unsigned int32 spi_xfer_in(void);
_bif unsigned int8 spi_xfer_in(unsigned int8 bits);
_bif unsigned int16 spi_xfer_in(unsigned int8 bits);
_bif unsigned int32 spi_xfer_in(unsigned int8 bits);
_bif unsigned int8 spi_xfer_in(unsigned int8 stream, unsigned int8 bits);
_bif unsigned int16 spi_xfer_in(unsigned int8 stream, unsigned int8 bits);
_bif unsigned int32 spi_xfer_in(unsigned int8 stream, unsigned int8 bits);

// #use rtos() Prototypes:
_bif void rtos_run(void);
_bif void rtos_yield(void);
_bif void rtos_enable(unsigned int8 task);
_bif void rtos_disable(unsigned int8 task);
_bif void rtos_terminate(void);
_bif void rtos_await(int1 flag);
_bif void rtos_wait(unsigned int8 sem);
_bif void rtos_signal(unsigned int8 sem);
_bif void rtos_msg_send(unsigned int8 task, unsigned int8 msg);
_bif unsigned int8 rtos_msg_read(void);
_bif unsigned int8 rtos_msg_poll(void);
_bif int1 rtos_overrun(unsigned int8 task);
_bif void rtos_stats(unsigned int8 task, unsigned int8* stat);

// #use timer() Prototypes:
_bif unsigned int8 get_ticks(void);
_bif unsigned int16 get_ticks(void);
_bif unsigned int32 get_ticks(void);
_bif unsigned int8 get_ticks(unsigned int8 stream);
_bif unsigned int16 get_ticks(unsigned int8 stream);
_bif unsigned int32 get_ticks(unsigned int8 stream);
_bif void set_ticks(unsigned int8 value);
_bif void set_ticks(unsigned int16 value);
_bif void set_ticks(unsigned int32 value);
_bif void set_ticks(unsigned int8 stream, unsigned int8 value);
_bif void set_ticks(unsigned int8 stream, unsigned int16 value);
_bif void set_ticks(unsigned int8 stream, unsigned int32 value);

// #use pwm() Prototypes:
_bif void pwm_on(void);
_bif void pwm_on(unsigned int8 stream);
_bif void pwm_off(void);
_bif void pwm_off(unsigned int8 stream);
_bif void pwm_set_duty(unsigned int16 duty);
_bif void pwm_set_duty(unsigned int8 stream, unsigned int16 duty);
_bif void pwm_set_duty_percent(unsigned int16 percent);
_bif void pwm_set_duty_percent(unsigned int8 stream, unsigned int16 percent);
_bif void pwm_set_frequency(unsigned int32 frequency);
_bif void pwm_set_frequency(unsigned int8 stream, unsigned int32 frequency);

// #use capture() Prototypes:
_bif unsigned int16 get_capture_time(void);
_bif unsigned int16 get_capture_time(unsigned int8 stream);
_bif int1 get_capture_event(void);
_bif int1 get_capture_event(unsigned int8 stream);

// Enviroment Prototypes:
//_bif unsigned int8 getenv(char* cstring);

// Address Prototypes:
#ifndef __ADDRESS__
#if defined(__PCM__) || defined(__PCB__)
typedef unsigned int16 __ADDRESS__;
#else
typedef unsigned int32 __ADDRESS__;
#endif
#endif
_bif void goto_address(__ADDRESS__ address);
_bif __ADDRESS__ label_address(__ADDRESS__ label);

// EEPROM Prototypes:
#ifndef __EEADDRESS__
#if getenv("DATA_EEPROM")>=0x100
typedef unsigned int16 __EEADDRESS__;
#else
typedef unsigned int8 __EEADDRESS__;
#endif
#endif
_bif unsigned int8 read_eeprom(__EEADDRESS__ address);
_bif void write_eeprom(__EEADDRESS__ address, unsigned int8 value);

////////////////////////////////////////////////////////////////// INT
// Interrupt Functions: ENABLE_INTERRUPTS(), DISABLE_INTERRUPTS(),
// CLEAR_INTERRUPT(), INTERRUPT_ACTIVE()
// INT Prototypes:
_bif void enable_interrupts(int32 interrupt);
_bif void disable_interrupts(int32 interrupt);
_bif void clear_interrupt(int32 interrupt);
_bif int1 interrupt_active(int32 interrupt);
_bif int1 interrupt_enabled(int32 interrupt);
_bif void jump_to_isr(int16 address);
// Constants used in ENABLE/DISABLE_INTERRUPTS() are:
#define GLOBAL 0x0B01
#define INT_RA 0x00FF6510
#define INT_TIMER0 0x006520
#define INT_COMP 0x006540
#define INT_AD 0x006580

#list

Най-добре си направи твои tris функции и изпозлвай тях, но проблем ще има навсякъде където компилатора се опита да бута tris-а, ако се опитва. Примерно в CCS има директива което му забранява да бута трис-а, иначе по дифолт той сам се грижи да го прави вход/изход в зависимост от това за каква функция го изпозлваш, но аз винаги му го забранявам. Въпроса е че в някои библиотечни функции то си го има и си го прави, а и то нямам как, примерно ако има 1 wire библиотека тя просто трбява да го прави вход / изход и ще трябва и там да буташ.

ТОВАА!
Благодаря ти много!

Направо ме озадачиха с тоя пик, не знаех че иам ткаива 16-ки, то и адресното пространство е организирано по иначе май ...

Налага ми се да го ползвам, заради операционните усилватели. Подобни са нещата при 520, 525 и някои нови 12-тици.

Добре е да го имам в предвид, не че ще го запомня, нито пък сигурно скоро ще бутам някой пик но все пак ... то CCS си го поддържа, но аз в някои стари библиотеки имам и доста asm код ... така може би след няколко псувни ще се сетя.

Само от ей т'ва трябва да светне лапичката! TRIS вече е асемблерска инструкция. Сигурно е някакъв Си-френдли напън. Или защита от инцидентна промяна на портовете?

Абе лампичката ми е светнала още преди доста време. Въпросът е как да си осветя работното поле с нея.

Ами само с това ме съмнява да стане, стандартно трис командата изисква смяна на банката, запис в редистъра връщане на банката, ако компилатора не знае това няма да го прави както трябва. .. Сега като се задълбочих малко какво са направили, имаш нова команда, movlb която сетва банката, но това може да си стане и по стария начин предполагам. Има и втора нова команда, тази tris която взема W и го пише в съответният трис регистър, който вече се намира някъде другаде, може би не може да бъде директно адресиран но може и да има начин за индиректна адресация. Реално компилатора ти трябва да започне за изпозлва tris командата вместо movwf когато променяш tris-a. Другото което е са изместили самия порт А и вече не е на 5-ти адрес но това не е проблем.
000C: MOVLB 0
000D: MOVWF 10
000E: MOVLB 1

Ето това малко ме озадачава, отиват в банка 0, записват W на 10-ти адрес и се връщат в банка 1 .... може да е от компилатора .. обаче .. не знам зачитал ли си подробно I/O-то, току що го зачетох, има съществени различия с другите от серията, които на пръв поглед са незначителни но всъщност може да ти създадът проблеми.
Променили са начина по който се управлява порта, изобщо няма tris регистър, трис регистъра са самите тригери на порта, те са директно линкнати с W регистъра.
Работата със самия порт е read / modify / write последователност от където може да имаш и проблем, прочети внимателно секция 6.7.1 и го имай в предвид. И сигурно в тази връзка CCS добавя тази смяна на банки и писане в 10-ти адрес където няма нищо.

Не е само това, променили са начина на работа на порта ..

... аз ли се въобразявам или преди нямаше movlb команда ? т.е. с нея и с тоя tris трябва да са 37 а не 36 .....