// write data
void Write_Data(unsigned int _data) {
TFT_RS = 1;
Lo(LATE) = Hi(_data);
Lo(LATA) = Lo(_data);
TFT_WR = 0;
TFT_WR = 1;
}
void save_int_to_eeprom( unsigned char add, unsigned int data )
{
eeprom_write( add, Hi( data ) ); //and save msb
DelayMs( 10 );
eeprom_write( add + 1, Lo( data ) ); //and lsb
DelayMs( 10 );
}
void Interrupt(){
unsigned int vcalc;
unsigned long wts;
unsigned short encVal = 0;
unsigned char cs = 50;
if (TMR1IF_bit) // Timer1 Code
{
TMR1IF_bit = 0;
TMR1H = Hi(tmrOffset);
TMR1L = Lo(tmrOffset);
if (wavSel == 0)
{
wts = (unsigned long)sizeof( envelope_table );
vcalc = (envelope_table[x1]);
}
else if (wavSel == 1)
{
wts = (unsigned long)sizeof( envelope_table2 );
vcalc = (envelope_table2[x1]);
}
x1+=xStep;
if(x1 == wts)
{
xStep=1;
x1 = 0;
T1CON = 0x00;
}
PWM1_Set_Duty( vcalc );
}
}
void InitTimer1(){
T1CON = 0x00;
TMR1IF_bit = 0;
TMR1H = Hi(tmrOffset);
TMR1L = Lo(tmrOffset);
TMR1IE_bit = 1;
INTCON = 0xC0;
}
// Transfer Address.
bool SPIFlash::_transferAddress(void) {
if (address4ByteEnabled) {
_nextByte(WRITE, Highest(_currentAddress));
}
_nextByte(WRITE, Higher(_currentAddress));
_nextByte(WRITE, Hi(_currentAddress));
_nextByte(WRITE, Lo(_currentAddress));
return true;
}
/*****************************************************************************
* Function: ADCStoreTemperature()
*
* Preconditions: SPIMPolInit and EEPROMInit must be called before.
*
* Overview: The function stores the current temperature into EEPROM.
*
* Input: None.
*
* Output: None.
*
*****************************************************************************/
void ADCStoreTemperature(){
unsigned Temp;
// Get temperature
Temp = _uADCTemperature>>4;
// Write MS byte into EEPROM address = 0
EEPROMWriteByte(Hi(Temp),0);
// Write LS byte into EEPROM address = 1
EEPROMWriteByte(Lo(Temp),1);
}
void BazaModBus::readarchive(unsigned char* mass, unsigned char shift, unsigned int address){
if (address<128){
mass[shift] = Hi(JournalMass[address+1]);
mass[shift+1] = Lo(JournalMass[address+1]);
}else{
mass[shift]=0xFF;
mass[shift+1]=0xFF;
}
};
S16 CalcRamp1(S16 ref,S16 max,S16 min, S16 incr)
{
S32 tmpl;
/* new reference limitation */
if (ref > max) ref = max;
else if (ref < min) ref = min;
/* process reference ramp */
if (incr)
{
min = Hi(ramp1);
if (ref > min) /* reference must be increased */
{
tmpl = ramp1 + incr;
if (Hi(tmpl) > ref)
{
Hi(ramp1) = ref;
Lo(ramp1) = 0;
}
else ramp1 = tmpl;
}
else if (ref < min) /* reference must be decreased */
{
tmpl = ramp1 - incr;
if (Hi(tmpl) < ref)
{
Hi(ramp1) = ref;
Lo(ramp1) = 0;
}
else ramp1 = tmpl;
}
}
else /* no ramp */
{
Hi(ramp1) = ref;
Lo(ramp1) = 0;
}
min = Hi(ramp1);
return (min);
}
void BazaModBus::readregister(unsigned char* mass, unsigned char shift, unsigned int address){
//если считываем пароль пользователя
if (address==0x0016) NewPass(ePassword);
if (address<256){
mass[shift] = Hi(DataMass[address]);
mass[shift+1] = Lo(DataMass[address]);
}else{
mass[shift]=0xFF;
mass[shift+1]=0xFF;
}
};
/**************************************************************************************************
* Function MP3_SCI_Write()
* -------------------------------------------------------------------------------------------------
* Overview: Function writes one byte to MP3 SCI
* Input: register address in codec, data
* Output: Nothing
**************************************************************************************************/
void MP3_SCI_Write(char address, unsigned int data_in) {
XDCS = 1;
MP3_CS = 0; // select MP3 SCI
SPI0_Write(WRITE_CODE);
SPI0_Write(address);
SPI0_Write(Hi(data_in)); // high byte
SPI0_Write(Lo(data_in)); // low byte
MP3_CS = 1; // deselect MP3 SCI
while (DREQ == 0); // wait until DREQ becomes 1, see MP3 codec datasheet, Serial Protocol for SCI
}
void BazaModBus::readregisters(unsigned char* mass, unsigned char shift, unsigned int address, unsigned char number) {
for (i_mod=0; i_mod<number; i_mod++){
if ((address+i_mod)<256){
mass[shift+i_mod*2] = Hi(DataMass[address+i_mod]);
mass[shift+1+i_mod*2] = Lo(DataMass[address+i_mod]);
}
else{
mass[shift+i_mod*2]=0xFF;
mass[shift+1+i_mod*2]=0xFF;
}
}
};
int main()
{
Object* ns = NULL;
esInit(&ns);
Handle<es::Alarm> alarm = es::Alarm::createInstance();
AlarmCallback* alarmCallback = new AlarmCallback;
alarm->setInterval(50000000LL);
alarm->setEnabled(true);
alarm->setCallback(static_cast<es::Callback*>(alarmCallback));
MonitorA = new Monitor();
MonitorB = new Monitor();
TEST(MonitorA && MonitorB);
ThreadHi = new Thread(Hi, // thread function
0, // argument to thread function
es::Thread::Normal+2); // priority
ThreadMid = new Thread(Mid, // thread function
0, // argument to thread function
es::Thread::Normal+1);// priority
TEST(ThreadHi && ThreadMid);
Lo(0);
alarm->setEnabled(false);
delete alarmCallback;
MonitorA->release();
MonitorB->release();
esReport("done.\n");
return 0;
}
// set index
void Set_Index(unsigned short index) {
TFT_RS = 0;
Lo(LATA) = index;
TFT_WR = 0;
TFT_WR = 1;
}
void BazaModBus::writeregister(unsigned char* mass){
switch(AddressRegister){
case 0x0010:
case 0x0011:
case 0x0012:
case 0x0013:
case 0x0014:
case 0x0015:{//изменение даты/времени
for(i_mod=0; i_mod<6; i_mod++) mass[4+i_mod]=((DataMass[i_mod+0x10]/10)<<4)+(DataMass[i_mod+0x10]%10);
mass[4+AddressRegister-0x10]=(char) (((DataRegister/10)<<4) + (DataRegister%10));
NumCom=0xB2; NumByte=6;
}break;
case 0x0016:{ //запись пароля в EEPROM
ePassword[0]=((DataRegister>>12)&0x0F)+0x30;
ePassword[1]=((DataRegister>>8)&0x0F)+0x30;
ePassword[2]=((DataRegister>>4)&0x0F)+0x30;
ePassword[3]=(DataRegister&0x0F)+0x30;
eWrite=1;eAddressWrite=0;eMassiveWrite=ePassword;
}break;
case 0x0030:
case 0x0033:
case 0x0036:{
if (DataRegister==2) {NumCom=0x71; NumByte=0;} //ввод утройств
if (DataRegister==0) {NumCom=0x70; NumByte=0;} //вывод устройств
}break;
case 0x0050:
case 0x0051:
case 0x0052:
case 0x0053:
case 0x0054:
case 0x0055:
case 0x0056:{
NumCom=AddressRegister+0x31; NumByte=1;
mass[4]=DataRegister;
}break;
case 0x0060:
case 0x0061:{
NumCom=AddressRegister+0x31; NumByte=1;
mass[4]=DataRegister;
}break;
case 0x0062:
case 0x0063:
case 0x0064:
case 0x0065:{
NumCom=0x94; NumByte=2;
mass[4]=AddressRegister-0x0061;
mass[5]=DataRegister;
}break;
case 0x0066:
case 0x0067:
case 0x0068:
case 0x0069:{
NumCom=0x95; NumByte=2;
mass[4]=AddressRegister-0x0065;
mass[5]=DataRegister;
}break;
/*
case 0x0062:
case 0x0063:
case 0x0064:
case 0x0065{
NumCom=0x94; NumByte=2;
mass[4]=AddressRegister-0x0062+1;
mass[5]=DataRegister;
}break;
case 0x0066:
case 0x0067:
case 0x0068:
case 0x0069:{
NumCom=0x95; NumByte=2;
mass[4]=AddressREgister-0x0066+1;
mass[5]=DataRegister;
}break;
*/
case 0x006A:
case 0x006B:
case 0x006C:
case 0x006D:
case 0x006E:
case 0x006F:
case 0x0070:
case 0x0071:
case 0x0072:
case 0x0073:
case 0x0074:
case 0x0075:
case 0x0076:
case 0x0077:
case 0x0078:
case 0x0079:
case 0x007A:
case 0x007B:
case 0x007C:
case 0x007D:
case 0x007E:
case 0x007F:
case 0x0080:
case 0x0081:
case 0x0082:
case 0x0083:
case 0x0084:
case 0x0085:
case 0x0086:
case 0x0087:
case 0x0088:
case 0x0089:{
NumCom=0x93; NumByte=2;
mass[4]=AddressRegister-0x6A+1;
mass[5]=DataRegister;
}break;
case 0x0090:
case 0x0091:
case 0x0092:{
NumCom=AddressRegister+0x11; NumByte=1;
mass[4]=DataRegister;
}break;
case 0x0093:
case 0x0094:
case 0x0095:
case 0x0096:{
NumCom=0xA4; NumByte=2;
mass[4]=AddressRegister-0x0092;
mass[5]=DataRegister;
}break;
case 0x0097:
case 0x0098:
case 0x0099:
case 0x009A:{
NumCom=0xA5; NumByte=2;
mass[4]=AddressRegister-0x0096;
mass[5]=DataRegister;
}break;
/*
case 0x0093:
case 0x0094:
case 0x0095:
case 0x0096:{
NumCom=0xA4; NumByte=2;
mass[4]=AddressRegister-0x93+1;
mass[5]=DataRegister;
}break;
case 0x0097:
case 0x0098:
case 0x0099:
case 0x009A:{
NumCom=0xA5; NumByte=2;
mass[4]=AddressRegister-0x97+1;
mass[5]=DataRegister;
}break;
*/
case 0x00A0:
case 0x00A1:
case 0x00A2:
case 0x00A3:
case 0x00A4:{
NumCom=AddressRegister+0x15; NumByte=1;
mass[4]=DataRegister;
}break;
case 0x00A5:{
NumCom=AddressRegister+0x15; NumByte=2;
mass[4]=Hi(DataRegister);
mass[5]=Lo(DataRegister);
}break;
case 0x00A6:{
NumCom=AddressRegister+0x15; NumByte=1;
mass[4]=DataRegister;
}break;
case 0x00A7:{
NumCom=0xBD; NumByte=1;
mass[4]=DataRegister;
}break;
case 0x00B4:{
NumCom=0xFA; NumByte=0;
for (i_mod=0; i_mod<129; i_mod++) JournalMass[i_mod]=0xEEEE;
}break; //стереть архив событий, для этого пишется любое значение в ячейку с количеством записей архива
case 0x00B5:{
NumCom=0xCA; NumByte=0;
for (i_mod=0; i_mod<129; i_mod++) JournalMass[i_mod]=0xEEEE;
}break; //стереть архив Поста, для этого пишется любое значение в ячейку с количеством записей архива
case 0x00B6:{
NumCom=0xDA; NumByte=0;
for (i_mod=0; i_mod<129; i_mod++) JournalMass[i_mod]=0xEEEE;
}break; //стереть архив Приемника, для этого пишется любое значение в ячейку с количеством записей архива
case 0x00B7:{
NumCom=0xEA; NumByte=0;
for (i_mod=0; i_mod<129; i_mod++) JournalMass[i_mod]=0xEEEE;
}break; //стереть архив Передатчика, для этого пишется любое значение в ячейку с количеством записей архива
}
};
// Write int to EEPROM.
void EEPROM_Write_int(unsigned int address, unsigned int num) {
EEPROM_Write(address , Lo(num));
EEPROM_Write(address+1, Hi(num));
// Note that the EEPROM delay is only needed between write and read functions.
}
void init_ramp2(S16 init_val)
{
Hi(ramp2) = init_val;
Lo(ramp2) = 0;
}
void init_ramp1(S16 init_val)
{
Hi(ramp1) = init_val;
Lo(ramp1) = 0;
}
int main(void) {
/* Init system */
TM_RCC_InitSystem();
/* Init HAL layer */
HAL_Init();
/* Timer Init for SysTick */
timer_start();
/* Init leds */
TM_DISCO_LedInit();
/* Init delay */
TM_DELAY_Init();
/* Init USB peripheral */
TM_USB_Init();
/* Init VCP on FS port.. */
TM_USBD_CDC_Init(TM_USB_FS);
/* Start USB device mode on FS port.. */
TM_USBD_Start(TM_USB_FS);
while (1) {
/* Process USB CDC device, send remaining data if needed */
/* It is better if you call this in periodic timer, like each ms in SYSTICK handler */
TM_USBD_CDC_Process(TM_USB_FS);
/* Check if device is ready, if drivers are installed if needed on FS port */
if (TM_USBD_IsDeviceReady(TM_USB_FS) == TM_USBD_Result_Ok) {
TM_DISCO_LedOn(LED_GREEN);
} else {
TM_DISCO_LedOff(LED_GREEN);
}
/* Check if user has changed parameter for COM port */
TM_USBD_CDC_GetSettings(TM_USB_FS, &USB_FS_Settings);
/* Check if updated */
if (USB_FS_Settings.Updated) {
/* Update settings for UART here if needed */
TM_USBD_CDC_Puts(TM_USB_FS, "USB FS settings changed!\n");
}
/* Check if anything received on FS port */
if (TM_USBD_CDC_Getc(TM_USB_FS, &ch)) {
/* One character received */
/* Send it back */
/* TM_USBD_CDC_Putc(TM_USB_FS, ch); */
/* Control LEDs based on input (debug) */
switch(ch){
case '1':
TM_DISCO_LedToggle(LED_BLUE);
break;
case '2':
TM_DISCO_LedToggle(LED_ORANGE);
TM_USBD_CDC_Puts(TM_USB_FS, "Toggling Orange LED\n");
break;
case '3':
TM_DISCO_LedToggle(LED_RED);
TM_USBD_CDC_Puts(TM_USB_FS, "Toggling Red LED\n");
break;
case '4':
TM_DISCO_LedToggle(LED_GREEN);
break;
case '5':
/* Transfer Sample Audio */
trace_puts("Sending Audio Sample");
/* For now, send entire sample audio data */
/* TODO get size of sample to be transfered from serial port */
/* at 115k BAUD 800 bytes is sub 10 msec total transfer time */
for(int i = 0; i < SAMPLEAUDIO_SIZE;i++)
{
/* Need to split 16 bit samples into upper and lower bytes */
/* Note that these will need to be reconstructed in the
* processing script. Updated Buffer size to 1024 from 256 in
* USBD_CDC library file for this operation.
*/
/* Send MSB first */
TM_USBD_CDC_Putc(TM_USB_FS, Hi(SampleAudio[i]));
trace_putchar((int)Hi(SampleAudio[i]));
/* Then Send LSB */
TM_USBD_CDC_Putc(TM_USB_FS, Lo(SampleAudio[i]));
trace_putchar((int)Lo(SampleAudio[i]));
}
break;
default:
break;
}
}
//Wait for next system tick
while (g_SysTick_Flag == 0){};
g_SysTick_Flag = 0;
TM_DISCO_LedToggle(LED_BLUE);
}
}
// write command
void Write_Command(unsigned short cmd) {
TFT_RS = 1;
Lo(LATA) = cmd;
TFT_WR = 0;
TFT_WR = 1;
}
// Read int from EEPROM.
unsigned int EEPROM_Read_int (unsigned int address) {
unsigned int num = 0;
Lo(num) = EEPROM_Read(address);
Hi(num) = EEPROM_Read(address+1);
return num;
}
vec3 DirectLightIntegrator::income(const Ray &r,
const shared_ptr<Scene> &scene,
int level) {
vec3 L(0.0f);
Intersection hit(NULL, NULL, CONST_FAR);
// Is there intersection?
if (!scene->intersect(r, hit)) {
return L;
}
// Is this intersection on the light?
if (hit.type == INTERSECTION_LIGHT) {
// Simply return the color from the light.
const Light *light = static_cast<const Light *>(hit.intersectable);
return light->Le(hit.point) * clamp(dot(hit.normal, -r.d), 0.0f, 1.0f);
}
// Sample for one light.
if (!hit.m->bsdf->isDelta()) {
// This is not a delta brdf. Randomly pick one light.
int lightId = floor(Sampler::sample1D(0.0f, (float)scene->lights.size() - 0.1f));
const shared_ptr<Light> &light = scene->lights[lightId];
// Get the shadow ray and the distance to the light.
vec3 Lo(0.0f);
for (int i = 0; i < nLightSamples; ++i) {
auto sample = light->genShadowRay(hit);
Ray shadowRay = sample.first;
float lightPDF = sample.second;
if (lightPDF < CONST_EPSILON) {
continue;
}
// Use the shadow ray to find intersect.
if (scene->occlude(shadowRay)) {
continue;
}
// Get the light color.
vec3 pointOnLight = shadowRay.o + shadowRay.tmax * shadowRay.d;
vec3 Le = light->Le(pointOnLight);
vec3 f = hit.m->bsdf->bsdf(hit, r.d, shadowRay.d);
float w = powerHeuristec(lightPDF, nLightSamples, hit.m->bsdf->pdf(hit, r.d, shadowRay.d), nBSDFSamples);
// Here the geometry term is inside the pdf.
// Use power heuristic.
Lo += f * Le * w / lightPDF;
}
Lo /= nLightSamples;
L += Lo;
// Sample for BSDF.
if (level < maxDepth - 1) {
vec3 LBSDF(0.0f);
for (int i = 0; i < nBSDFSamples; ++i) {
while (true) {
auto sample = hit.m->bsdf->sample(hit, r.d);
if (sample.second > 0.1f) {
auto Li = income(sample.first, scene, level + 1);
vec3 f = hit.m->bsdf->bsdf(hit, r.d, sample.first.d);
float w = powerHeuristec(sample.second, nBSDFSamples, light->pdfRay(hit, sample.first.d), nLightSamples);
//float w = 1.0f;
LBSDF += w * f * Li / sample.second;
break;
}
}
}
LBSDF /= nBSDFSamples;
L += clamp(LBSDF, 0.0f, 1.0f);
}
}
else {
// This is a delta brdf. Just sample the delta direction.
if (level < maxDepth - 1) {
auto sample = hit.m->bsdf->sample(hit, r.d);
auto Li = income(sample.first, scene, level + 1);
vec3 f = hit.m->bsdf->bsdf(hit, r.d, sample.first.d);
L += f * Li;
}
}
return L;
}
#include "intpseudo.h"
#include "headids.h"
/*-------------------------------------------------------------------------*/
/* Variables */
static CPUVar CPU1802, CPU1805;
/*-------------------------------------------------------------------------*/
/* Subroutines */
static Boolean PutCode(Word Code)
BEGIN
if (Hi(Code) == 0)
BEGIN
BAsmCode[0] = Lo(Code); CodeLen = 1;
return True;
END
else if (MomCPU <= CPU1802)
BEGIN
WrError(1500);
return False;
END
else
BEGIN
BAsmCode[0] = Hi(Code); BAsmCode[1] = Lo(Code); CodeLen = 2;
return True;
END
END
/*-------------------------------------------------------------------------*/
